def on_selec_img_clicked(self,widget):
FileChoose=FileDialog(self.PrjPath,"Seleccionar Archivos","Imagenes",["*.png","*.gif","*.jpg","*.svg"])
Result,FileName=FileChoose.run()
if Result==1:
gconf.client_get_default().set_string('/desktop/gnome/background/picture_filename', FileName)
else:
print "falso"
def __on_response(self, self2, id):
if id != gtk.RESPONSE_CANCEL:
gconf.client_get_default().set_bool(GCONF_PREFIX + 'first_time_minimize_seen', True)
else:
# Avoid set of same value on notify receipt
gobject.timeout_add(100, self.__idle_undo_visible)
self.destroy()
def test_intializing_writes_defaults(self):
key = self.__class__._gconf_base + 'remove_whitespace'
gconf.client_get_default().unset(key)
self.assertRaises(Exception,
self._config.get_bool, 'remove_whitespace')
config = ConfigSettings()
self.assertTrue(config.get_bool('remove_whitespace'))
def on_item_activated(self, widget, item):
print ""
model = widget.get_model()
path = model[item][COL_PATH]
print path
print self.BACKGROUND_DIRS[0]
gconf.client_get_default().set_string('/desktop/gnome/background/picture_filename',(str(self.BACKGROUND_DIRS[0])+'/'+path) )
def set_wallpaper():
if sys.platform == 'win32':
SPI_SETDESKWALLPAPER = 20
ctypes.windll.user32.SystemParametersInfoA(SPI_SETDESKWALLPAPER, 0, "Picture_of_the_day.bmp", 0)
else:
gconf.client_get_default().get_string('/desktop/gnome/background/picture_options', 'scaled')
gconf.client_get_default().get_string('/desktop/gnome/background/picture_filename', 'Picture_of_the_day.png')
def get_login_password():
""" Retrieve credentials from Gnome Keyring """
# From python-gnomekeyring examples
keyring = gnomekeyring.get_default_keyring_sync()
auth_token = gconf.client_get_default().get_int(GCONF_AUTH_KEY)
if auth_token > 0:
try:
secret = gnomekeyring.item_get_info_sync(keyring,
auth_token).get_secret()
except gnomekeyring.DeniedError:
login = None
password = None
auth_token = 0
else:
login, password = secret.split('\n')
else:
login = None
password = None
login, password = password_dialog(login, password)
# Save new login and password to gnome keyring
auth_token = gnomekeyring.item_create_sync(
keyring,
gnomekeyring.ITEM_GENERIC_SECRET,
"TV-kaista subtitles downloader",
dict(appname="tv-kaista-subs-py, subtitles downloader"),
"\n".join((login, password)), True)
gconf.client_get_default().set_int(GCONF_AUTH_KEY, auth_token)
return login, password
def __init__(self):
rb.BrowserSource.__init__(self, name=_("豆瓣电台"))
self.__activated=False
self.__db=None
self.__channel=0
self.__userName=gconf.client_get_default().get_without_default(USER_NAME_KEY).get_string()
self.__userPWD=gconf.client_get_default().get_without_default(USER_PWD_KEY).get_string()
log.info("_userName:"+self.__userName);
def get_twitter_api(self):
username = gconf.client_get_default().get_string(gconf_keys['username'])
password = gconf.client_get_default().get_string(gconf_keys['password'])
api = twitter.Api(username, password);
api.SetSource('rhythmboxtwitterplugin')
api.SetXTwitterHeaders('Rhythmbox twitter-plugin', 'http://trac.codecheck.in/share/browser/platform/rhythmbox/twitter-plugin', '0.1')
return api
def getProxy():
import gconf
if gconf.client_get_default().get_bool('/system/http_proxy/use_http_proxy'):
port = gconf.client_get_default().get_int('/system/http_proxy/port')
http = gconf.client_get_default().get_string('/system/http_proxy/host')
proxy = proxy = urllib2.ProxyHandler( {"http":"http://%s:%s/"% (http,port)} )
return (True, proxy)
return (False, None)
def item_create_callback(result, auth_token, user_data):
assert user_data == "user data"
if result is None:
print "result is ok"
gconf.client_get_default().set_int(GCONF_AUTH_KEY, auth_token)
else:
print "result:", result
gtk.main_quit()
def __init__ (self, locations):
# By default use burnproof
self.__write_flags = nautilusburn.RECORDER_WRITE_BURNPROOF
# Sets up data dir and version
self.version = release.version
# setup ui
filename = locations.get_data_file("serpentine.glade")
g = glade.XML (filename, "preferences_dialog")
self.__dialog = g.get_widget ("preferences_dialog")
self.dialog.connect ("destroy-event", self.__on_destroy)
self.dialog.set_title ("")
# Drive selection
drv = g.get_widget ("drive")
cmb_drv = nautilusburn.DriveSelection ()
cmb_drv.set_property ("show-recorders-only", True)
cmb_drv.show ()
self.__drive_selection = cmb_drv
drv.pack_start (cmb_drv, False, False)
# Speed selection
self.__speed = WriteSpeed(g, self.__drive_selection.get_drive)
# eject checkbox
self.__eject = gaw.data_toggle_button (g.get_widget ("eject"),
GCONF_DIR + "/eject")
# use gap checkbox
self.__use_gap = gaw.data_toggle_button (
g.get_widget ("use_gap"),
GCONF_DIR + "/use_gap",
default = True
)
# temp
ncb_temp_dir = NCB_GCONF_DIR + "/temp_iso_dir"
gconf.client_get_default ().add_dir (ncb_temp_dir, gconf.CLIENT_PRELOAD_NONE)
self.__tmp = gaw.GConfValue (
key = ncb_temp_dir,
data_spec = gaw.Spec.STRING,
default = "file:///tmp"
)
# debug
self.__debug = gaw.GConfValue (
key = GCONF_DIR + "/debug_mode",
data_spec = gaw.Spec.BOOL,
default = False
)
# Pool
self.__pool = GvfsMusicPool ()
# Close button
self.__close_button_handler = HideCloseButton(g.get_widget("close_btn"))
def __init__(self, hardcoded_urls):
super(StockManager, self).__init__()
self.__stockdir = os.path.join(os.path.dirname(bigboard.__file__), 'stocks')
self.__widget_environ = widget_environ = pyonlinedesktop.widget.WidgetEnvironment()
widget_environ['google_apps_auth_path'] = ''
self.__listing_key = GCONF_PREFIX + 'url_listings'
gconf.client_get_default().notify_add(self.__listing_key, self.__on_listings_change)
self.__metainfo_cache = {}
self.__hardcoded_urls = hardcoded_urls
def imei_cb(imei):
gconf_key = "/apps/%s/%s/keyring_auth_token" % (slug, imei)
auth_token = gnomekeyring.item_create_sync(
self.keyring,
gnomekeyring.ITEM_GENERIC_SECRET,
"%s secrets!" % APP_LONG_NAME,
dict(appname=APP_LONG_NAME),
str(pin), True)
gconf.client_get_default().set_int(gconf_key, auth_token)
return auth_token
def set_directory(self, dir):
if dir != "": #change the dir
if self.org_directory + dir != self.directory: #check if the dir has to change
self.directory = self.org_directory + dir
self.client = gconf.client_get_default()
self.client.add_dir (self.directory, gconf.CLIENT_PRELOAD_NONE)
else: #change dir to original dir
self.directory = self.org_directory
self.client = gconf.client_get_default()
self.client.add_dir (self.directory, gconf.CLIENT_PRELOAD_NONE)
def setLogin(self, login, password): authToken = gnomekeyring.item_create_sync( self.keyring, gnomekeyring.ITEM_GENERIC_SECRET, '%s, %s'%(self.appName, self.appDescription), dict(appname='%s, %s'%(self.appName, self.appDescription)), self.dividingSymbol.join((login, password)), True ) gconf.client_get_default().set_int(self.gconfKey, authToken)
def activate(self, shell):
""" Activation method, initialization phase """
# Store the shell
self.shell = shell
# Retrieve some gconf values
self.autosaveenabled = gconf.client_get_default().get_bool(gconf_keys["autosaveenabled"])
self.ratingsenabled = gconf.client_get_default().get_bool(gconf_keys["ratingsenabled"])
self.playcountsenabled = gconf.client_get_default().get_bool(gconf_keys["playcountsenabled"])
# Create stock id for icons (save,restore, clean)
iconfactory = gtk.IconFactory()
# stock_ids = gtk.stock_list_ids()
for stock_id, file in [
("save_rating_playcount", "save.png"),
("restore_rating_playcount", "restore.png"),
("clean_alltags", "clean.png"),
]:
# only load image files when our stock_id is not present
# if stock_id not in stock_ids:
iconset = gtk.IconSet(gtk.gdk.pixbuf_new_from_file(self.find_file(file)))
iconfactory.add(stock_id, iconset)
iconfactory.add_default()
# Setup gtk.Action (for the right-click menu) (see method definition below)
self.setup_gtkactions(shell)
# Setup statusbar and progressbar
player = shell.get_player()
self.statusbar = player.get_property("statusbar")
# Is there a better way to get access to it ???
self.progressbar = self.statusbar.get_children()[1]
# Store a reference to the db
self.db = shell.props.db
# If autosave is enabled, each time an entry is changed call the given method
if self.autosaveenabled:
self.entrychanged_sig_id = self.db.connect("entry-changed", self._on_entry_change)
# Variable to store processing stats
self.num_saved = 0
self.num_failed = 0
self.num_restored = 0
self.num_already_done = 0
self.num_cleaned = 0
# Index of the current selected item
self.iel = 0
# Start time
self.t0 = 0
print("Plugin activated")
def __init__(self):
rb.BrowserSource.__init__(self, name=_("豆瓣电台"))
self.__activated = False
self.__db = None # rhythmdb
self.__notify_id = 0 # gobject.idle_add id for status notifications
self.__info_screen = None # the loading screen
self.__channel=0
self.__userName=gconf.client_get_default().get_without_default(USER_NAME_KEY).get_string()
self.__userPWD=gconf.client_get_default().get_without_default(USER_PWD_KEY).get_string()
log.info("_userName:"+self.__userName);
def setCredential(self, username, password, appDesc=None): if appDesc == None: appDesc = self.appDesc appName = '%s, %s'%(self.appName, appDesc) authToken = gnomekeyring.item_create_sync( self.keyring, gnomekeyring.ITEM_GENERIC_SECRET, appName, dict(appname=appName), self.separator.join((username, password)), True ) gconf.client_get_default().set_int(self.gconfkey + '_' + appDesc, authToken)
def setup_panels():
toplevels = gnomepanel.get_toplevels()
if toplevels == [PANEL_ID]:
return
gnomepanel.create_toplevel(PANEL_ID)
gnomepanel.add_applet(PANEL_ID, 'bigboard_' + NAME, 'GNOME_OnlineDesktop_BigBoardButtonApplet', 1)
gnomepanel.add_applet(PANEL_ID, 'windowlist_' + NAME, 'GNOME_WindowListApplet', 2)
gnomepanel.add_applet(PANEL_ID, 'mixer_' + NAME, 'GNOME_MixerApplet', 1, right=True)
gnomepanel.add_applet(PANEL_ID, 'clock_' + NAME, 'GNOME_ClockApplet', 1, right=True)
gnomepanel.add_applet(PANEL_ID, 'tray_' + NAME, 'GNOME_SystemTrayApplet', 0, right=True)
gnomepanel.set_toplevels([PANEL_ID])
# TODO no schema for this, ugly to use /bigboard too
gconf.client_get_default().set_list('/apps/bigboard/prev_panel_config', gconf.VALUE_STRING, toplevels)
def dialog_response (self, dialog, response): if self.when_post_rb1_auto_song.get_active(): when_post = "auto_song"; self.plugin.deactivate_twitter_button() elif self.when_post_rb2_auto_album.get_active(): when_post = "auto_album"; self.plugin.deactivate_twitter_button() elif self.when_post_rb3_manual_song.get_active(): when_post = "manual_song"; self.plugin.activate_twitter_button() self.plugin.when_post = when_post gconf.client_get_default().set_string(gconf_keys['when_post'], when_post) dialog.hide()
def move_listing(self, url, isup):
curlist = list(self.get_listed_urls())
curlen = len(curlist)
pos = curlist.index(url)
if pos < 0:
_logger.debug("couldn't find url in listings: %s", url)
return
if isup and pos == 0:
return
elif (not isup) and pos == (curlen-1):
return
del curlist[pos]
pos += (isup and -1 or 1)
curlist.insert(pos, url)
gconf.client_get_default().set_list(self.__listing_key, gconf.VALUE_STRING, curlist)
def get_filebrowser_root(self):
base = u'/apps/gedit-2/plugins/filebrowser/on_load'
client = gconf.client_get_default()
client.add_dir(base, gconf.CLIENT_PRELOAD_NONE)
path = os.path.join(base, u'virtual_root')
val = client.get(path)
if val is not None:
base = u'/apps/gedit-2/plugins/filebrowser'
client = gconf.client_get_default()
client.add_dir(base, gconf.CLIENT_PRELOAD_NONE)
path = os.path.join(base, u'filter_mode')
fbfilter = client.get(path).get_string()
return val.get_string()
def set_listed(self, url, dolist):
curlist = list(self.get_listed_urls())
if (url in curlist) and dolist:
_logger.debug("attempting to list currently listed stock %s", url)
return
elif (url not in curlist) and (not dolist):
_logger.debug("attempting to delist currently unlisted stock %s", url)
return
elif dolist:
_logger.debug("listing %s", url)
curlist.append(url)
elif not dolist:
_logger.debug("delisting %s", url)
curlist.remove(url)
gconf.client_get_default().set_list(self.__listing_key, gconf.VALUE_STRING, curlist)
def start(self, shell):
if self.__shell is not None:
log.warning("already started")
return
remuco.PlayerAdapter.start(self)
self.__shell = shell
sp = self.__shell.get_player()
# gconf is used to adjust repeat and shuffle
self.__gconf = gconf.client_get_default()
# shortcuts to RB data
self.__item_id = None
self.__item_entry = None
self.__playlist_sc = sp.get_playing_source()
self.__queue_sc = self.__shell.props.queue_source
# connect to shell player signals
self.__signal_ids = (
sp.connect("playing_changed", self.__notify_playing_changed),
sp.connect("playing_uri_changed", self.__notify_playing_uri_changed),
sp.connect("playing-source-changed", self.__notify_source_changed)
)
# state sync will happen by timeout
# trigger item sync:
self.__notify_playing_uri_changed(sp, sp.get_playing_path()) # item sync
log.debug("start done")
def gconf_activate(self):
self.gconf_client = gconf.client_get_default()
self.gconf_client.add_dir(self.ConfigRoot, gconf.CLIENT_PRELOAD_NONE)
self.notify_id = self.gconf_client.notify_add(
self.ConfigRoot, self.gconf_event)
self.gconf_set_defaults(self.gconf_client)
self.gconf_configure(self.gconf_client)
def __init__(self):
totem.Plugin.__init__(self)
self.debug = True
self.gstreamer_plugins_present = True
self.totem = None
self.gconf = gconf.client_get_default()
self.init_settings()
def __init__(self,strAppId, strIconName, strIconThemePath):
self.ind = appi.Indicator(strAppId, strIconName, appi.CATEGORY_APPLICATION_STATUS, strIconThemePath)
self.gc = gconf.client_get_default()
self.ind.set_status (appi.STATUS_ACTIVE)
self.menus = {"root":gtk.Menu()}
self.labels = {}
self.cfgpath = GCONF_ROOT + "/" + strAppId + "/"
def activate(self, window):
self.window = window
self.spaces_instead_of_tabs = False
self.tabs_width = 2
# Prime the statusbar
self.statusbar = window.get_statusbar()
self.context_id = self.statusbar.get_context_id("AutoTab")
self.message_id = None
# Init defaults, set up callbacks to get notified of changes
client = gconf.client_get_default()
if client.__class__.__name__ == 'FakeGConfClient':
client.set_defaults(window)
self.new_tabs_size(client)
self.new_insert_spaces(client)
client.notify_add("/apps/gedit-2/preferences/editor/tabs/tabs_size", self.new_tabs_size)
client.notify_add("/apps/gedit-2/preferences/editor/tabs/insert_spaces", self.new_insert_spaces)
for view in window.get_views():
self.connect_handlers(view)
self.auto_tab(view.get_buffer(), None, view)
tab_added_id = window.connect("tab_added", lambda w, t: self.connect_handlers(t.get_view()))
window.set_data("AutoTabPluginHandlerId", tab_added_id)
def __init__(self, guake):
"""Constructor of Keyboard, only receives the guake instance
to be used in internal methods.
"""
self.guake = guake
self.accel_group = None # see reload_accelerators
self.client = gconf.client_get_default()
notify_add = self.client.notify_add
# Setup global keys
self.globalhotkeys = {}
globalkeys = ['show_hide']
for key in globalkeys:
notify_add(GKEY(key), self.reload_global)
self.client.notify(GKEY(key))
# Setup local keys
keys = ['toggle_fullscreen', 'new_tab', 'close_tab', 'rename_current_tab',
'previous_tab', 'next_tab', 'clipboard_copy', 'clipboard_paste',
'quit', 'zoom_in', 'zoom_out', 'increase_height', 'decrease_height',
'increase_transparency', 'decrease_transparency',
"search_on_web", 'move_tab_left', 'move_tab_right',
'switch_tab1', 'switch_tab2', 'switch_tab3', 'switch_tab4', 'switch_tab5',
'switch_tab6', 'switch_tab7', 'switch_tab8', 'switch_tab9', 'switch_tab10'
]
for key in keys:
notify_add(LKEY(key), self.reload_accelerators)
self.client.notify(LKEY(key))
def __init__(self):
"""
Constructor.
"""
self.dir = "/apps/textflow/preferences/"
#default preferences values
self.preferences = {"interface/show_toolbar" : True,
"interface/show_sidepanel" : True,
"interface/width" : 700,
"interface/height" : 650,
"font" : "Bitstream Vera Sans Mono 10",
"indentation/tab_width" : 4,
"indentation/use_spaces" : False,
"indentation/automatic" : True,
"right_margin/display" : False,
"right_margin/position" : 72,
"line_numbers" : True,
"highlight_current_line" : True,
"text_wrapping" : True,
"brackets_matching" : True,
"filebrowser_dir" : "",
"color_style": "classic",
"open_save/encoding" : "utf-8",
"open_save/line_ending" : "LF",
"open_save/auto_save" : False,
"open_save/auto_save_minutes" : 10,
"open_save/reopen_tabs" : True,
"open_save/save_copy" : False,
"open_save/recent" : False }
self.client = gconf.client_get_default()
self.__check_values()
def __init__(self):
BaseBuddy.__init__(self)
client = gconf.client_get_default()
self.props.nick = client.get_string('/desktop/sugar/user/nick')
self.props.color = client.get_string('/desktop/sugar/user/color')
def __init__(self):
gedit.Plugin.__init__(self)
gconf.client_get_default().notify_add(GCONF_KEY_BASE, self.on_gconf_notify)
def __init__(self):
"""Setup the preferences dialog interface, loading images,
adding filters to file choosers and connecting some signals.
"""
super(PrefsDialog, self).__init__(gladefile('prefs.glade'),
root='config-window')
self.add_callbacks(PrefsCallbacks())
self.client = gconf.client_get_default()
# setting evtbox title bg
eventbox = self.get_widget('eventbox-title')
eventbox.modify_bg(gtk.STATE_NORMAL,
eventbox.get_colormap().alloc_color("#ffffff"))
# images
ipath = pixmapfile('guake-notification.png')
self.get_widget('image_logo').set_from_file(ipath)
ipath = pixmapfile('quick-open.png')
self.get_widget('image_quick_open').set_from_file(ipath)
# the first position in tree will store the keybinding path in gconf,
# and the user doesn't worry with this, let's hide that =D
model = gtk.TreeStore(str, str, object, bool)
treeview = self.get_widget('treeview-keys')
treeview.set_model(model)
treeview.set_rules_hint(True)
treeview.connect('button-press-event', self.start_editing)
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn('keypath', renderer, text=0)
column.set_visible(False)
treeview.append_column(column)
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn(_('Action'), renderer, text=1)
column.set_property('expand', True)
treeview.append_column(column)
renderer = gtk.CellRendererAccel()
renderer.set_property('editable', True)
renderer.connect('accel-edited', self.on_key_edited, model)
renderer.connect('accel-cleared', self.on_key_cleared, model)
column = gtk.TreeViewColumn(_('Shortcut'), renderer)
column.set_cell_data_func(renderer, self.cell_data_func)
column.set_property('expand', False)
treeview.append_column(column)
self.demo_terminal = GuakeTerminal()
demo_terminal_box = self.get_widget('demo_terminal_box')
demo_terminal_box.add(self.demo_terminal)
default_params = {}
pid = self.demo_terminal.fork_command(**default_params)
self.demo_terminal.pid = pid
self.populate_shell_combo()
self.populate_keys_tree()
self.populate_display_n()
self.load_configs()
self.get_widget('config-window').hide()
# Preview when selecting a bgimage
self.selection_preview = gtk.Image()
self.file_filter = gtk.FileFilter()
self.file_filter.add_pattern("*.jpg")
self.file_filter.add_pattern("*.png")
self.file_filter.add_pattern("*.svg")
self.file_filter.add_pattern("*.jpeg")
self.bgfilechooser = self.get_widget('background_image')
self.bgfilechooser.set_preview_widget(self.selection_preview)
self.bgfilechooser.set_filter(self.file_filter)
self.bgfilechooser.connect('update-preview', self.update_preview,
self.selection_preview)
class EdMainWindow():
def __init__(self, fname, parent, names):
self.full = False
self.statuscount = 0
self.alt = False
register_stock_icons()
global mained
mained = self
# Create the toplevel window
window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window = window
www = gtk.gdk.screen_width()
hhh = gtk.gdk.screen_height()
if pedconfig.conf.full_screen:
window.set_default_size(www, hhh)
else:
xx = gconf.client_get_default().get_int(pedconfig.conf.config_reg +
"/xx")
yy = gconf.client_get_default().get_int(pedconfig.conf.config_reg +
"/yy")
ww = gconf.client_get_default().get_int(pedconfig.conf.config_reg +
"/ww")
hh = gconf.client_get_default().get_int(pedconfig.conf.config_reg +
"/hh")
if ww == 0 or hh == 0:
window.set_position(gtk.WIN_POS_CENTER)
window.set_default_size(7 * www / 8, 5 * hhh / 8)
window.move(www / 32, hhh / 10)
else:
window.set_default_size(ww, hh)
window.move(xx, yy)
window.set_icon_from_file(get_img_path("pyedit.png"))
merge = gtk.UIManager()
window.set_data("ui-manager", merge)
merge.insert_action_group(create_action_group(self), 0)
window.add_accel_group(merge.get_accel_group())
try:
mergeid = merge.add_ui_from_string(ui_info)
except gobject.GError, msg:
print "Building menus failed: %s" % msg
bar = merge.get_widget("/MenuBar")
bar.show()
window.set_events(gtk.gdk.POINTER_MOTION_MASK
| gtk.gdk.POINTER_MOTION_HINT_MASK
| gtk.gdk.BUTTON_PRESS_MASK
| gtk.gdk.BUTTON_RELEASE_MASK
| gtk.gdk.KEY_PRESS_MASK | gtk.gdk.KEY_RELEASE_MASK
| gtk.gdk.FOCUS_CHANGE_MASK)
#window.set_events( gtk.gdk.ALL_EVENTS_MASK)
window.connect("window_state_event", self.update_resize_grip)
window.connect("destroy", OnExit)
window.connect("key-press-event", self.area_key)
window.connect("key-release-event", self.area_key)
#window.connect("set-focus", self.area_focus)
window.connect("focus-in-event", self.area_focus_in)
window.connect("focus-out-event", self.area_focus_out)
window.connect("window-state-event", self.area_winstate)
#window.connect("area-focus-event", self.area_focus_in)
#window.connect("event", self.area_event)
#window.connect("enter-notify-event", self.area_enter)
#window.connect("leave-notify-event", self.area_leave)
#window.connect("event", self.unmap)
global notebook
# Create note for the main window, give access to it for all
notebook = gtk.Notebook()
self.notebook = notebook
notebook.popup_enable()
notebook.set_scrollable(True)
#notebook.add_events(gtk.gdk.FOCUS_CHANGE_MASK)
notebook.add_events(gtk.gdk.ALL_EVENTS_MASK)
notebook.connect("switch-page", self.note_swpage_cb)
notebook.connect("focus-in-event", self.note_focus_in)
# Futile attempts
#notebook.connect("change-current-page", self.note_page_cb)
#notebook.connect("grab-focus", self.note_grab_focus_cb)
#notebook.connect("focus", self.note_focus_cb)
#notebook.connect("create-window", self.note_create_cb)
#notebook.connect("enter-notify-event", self.note_enter_notify)
table = gtk.Table(2, 4, False)
window.add(table)
table.attach(
bar,
# X direction # # Y direction
0,
1,
0,
1,
gtk.EXPAND | gtk.FILL,
0,
0,
0)
bar = merge.get_widget("/ToolBar")
bar.set_tooltips(True)
bar.show()
table.attach(
bar,
# X direction # # Y direction
0,
1,
1,
2,
gtk.EXPAND | gtk.FILL,
0,
0,
0)
hpaned = gtk.HPaned()
hpaned.set_border_width(5)
scroll = gtk.ScrolledWindow()
treeview = self.create_tree()
treeview.connect("row-activated", self.tree_sel)
treeview.connect("cursor-changed", self.tree_sel_row)
self.treeview = treeview
scroll.add(treeview)
frame2 = gtk.Frame()
frame2.add(scroll)
hpaned.add(frame2)
self.hpanepos = gconf.client_get_default(). \
get_int(pedconfig.conf.config_reg + "/hpaned")
if self.hpanepos == 0: self.hpanepos = 200
hpaned.set_position(self.hpanepos)
hpaned.pack2(notebook)
self.hpaned = hpaned
# Create statusbars
self.statusbar = gtk.Statusbar()
self.statusbar2 = gtk.Statusbar()
hpane2 = gtk.HPaned()
hpane2.set_position(self.get_width() - 200)
hpane2.pack2(self.statusbar2)
hpane2.pack1(self.statusbar)
cnt = 0
# Read in buffers
for aa in names:
#print "loading file: ", aa
try:
buff = readfile(aa)
cnt += 1
except:
print "Cannot read file '" + aa, "'"
continue
vpaned = edPane(buff)
vpaned.area.fname = os.path.realpath(aa)
# Create backup
hhh = hash_name(vpaned.area.fname) + ".org"
xfile = pedconfig.conf.config_dir + "/" + hhh
if not os.path.isfile(xfile):
try:
writefile(xfile, buff)
except:
print "Cannot create backup file"
notebook.append_page(vpaned)
vpaned.area.set_tablabel()
if cnt == 0:
#print "No valid file on command line, creating new", os.getcwd()
aa = pedconfig.conf.UNTITLED
vpaned = edPane([])
vpaned.area.fname = os.path.realpath(aa)
notebook.append_page(vpaned)
vpaned.area.set_tab_label()
# Main Pane
table.attach(
hpaned,
# X direction Y direction
0,
1,
2,
3,
gtk.EXPAND | gtk.FILL,
gtk.EXPAND | gtk.FILL,
0,
0)
table.attach(
hpane2,
#table.attach(self.statusbar,
# X direction Y direction
0,
1,
3,
4,
gtk.EXPAND | gtk.FILL,
0,
0,
0)
window.show_all()
# Set the signal handler for 1s tick
signal.signal(signal.SIGALRM, handler)
signal.alarm(1)
self.update_statusbar("Initial")
ART_DATA_DIR = SHARED_DATA_DIR
USER_INVEST_DIR = expanduser("~/.gnome2/invest-applet")
if not exists(USER_INVEST_DIR):
try:
os.makedirs(USER_INVEST_DIR, 0744)
except Exception, msg:
error('Could not create user dir (%s): %s' % (USER_INVEST_DIR, msg))
# ------------------------------------------------------------------------------
# Set the cwd to the home directory so spawned processes behave correctly
# when presenting save/open dialogs
os.chdir(expanduser("~"))
#Gconf client
GCONF_CLIENT = gconf.client_get_default()
# GConf directory for invest in window mode and shared settings
GCONF_DIR = "/apps/invest"
# GConf key for list of enabled handlers, when uninstalled, use a debug key to not conflict
# with development version
#GCONF_ENABLED_HANDLERS = GCONF_DIR + "/enabled_handlers"
# Preload gconf directories
#GCONF_CLIENT.add_dir(GCONF_DIR, gconf.CLIENT_PRELOAD_RECURSIVE)
# tests whether the given stocks are in the old format
def old_stock_format(stocks):
if len(stocks) == 0:
def button_press(self, terminal, event):
"""Handles the button press event in the terminal widget. If
any match string is caught, another application is open to
handle the matched resource uri.
"""
self.matched_value = ''
matched_string = self.match_check(
int(event.x / self.get_char_width()),
int(event.y / self.get_char_height()))
if (event.button == 1 and event.get_state() & gtk.gdk.CONTROL_MASK and
matched_string):
print "matched string:", matched_string
value, tag = matched_string
# First searching in additional matchers
found = False
client = gconf.client_get_default()
use_quick_open = client.get_bool(KEY("/general/quick_open_enable"))
quick_open_in_current_terminal = client.get_bool(
KEY("/general/quick_open_in_current_terminal"))
cmdline = client.get_string(KEY("/general/quick_open_command_line"))
if use_quick_open:
for _useless, _otheruseless, extractor in QUICK_OPEN_MATCHERS:
g = re.compile(extractor).match(value)
if g and len(g.groups()) == 2:
filename = g.group(1)
line_number = g.group(2)
filepath = filename
if not quick_open_in_current_terminal:
curdir = self.get_current_directory()
filepath = os.path.join(curdir, filename)
if not os.path.exists(filepath):
logging.info("Cannot open file %s, it doesn't exists locally"
"(current dir: %s)", filepath,
os.path.curdir)
continue
# for quick_open_in_current_terminal, we run the command line directly in
# the tab so relative path is enough.
#
# We do not test for file existence, because it doesn't work in ssh
# sessions.
logging.debug("Opening file %s at line %s", filepath, line_number)
resolved_cmdline = cmdline % {"file_path": filepath,
"line_number": line_number}
logging.debug("Command line: %s", resolved_cmdline)
if quick_open_in_current_terminal:
logging.debug("Executing it in current tab")
if resolved_cmdline[-1] != '\n':
resolved_cmdline += '\n'
self.feed_child(resolved_cmdline)
else:
logging.debug("Executing it independently")
subprocess.call(resolved_cmdline, shell=True)
found = True
break
if not found:
print "found tag:", tag
print "found item:", value
print "TERMINAL_MATCH_TAGS", TERMINAL_MATCH_TAGS
if tag in TERMINAL_MATCH_TAGS:
if TERMINAL_MATCH_TAGS[tag] == 'schema':
# value here should not be changed, it is right and
# ready to be used.
pass
elif TERMINAL_MATCH_TAGS[tag] == 'http':
value = 'http://%s' % value
elif TERMINAL_MATCH_TAGS[tag] == 'https':
value = 'https://%s' % value
elif TERMINAL_MATCH_TAGS[tag] == 'ftp':
value = 'ftp://%s' % value
elif TERMINAL_MATCH_TAGS[tag] == 'email':
value = 'mailto:%s' % value
if value:
cmd = ["xdg-open", value]
print "Opening link: {}".format(cmd)
subprocess.Popen(cmd, shell=False)
# gtk.show_uri(self.window.get_screen(), value,
# gtk.gdk.x11_get_server_time(self.window))
elif event.button == 3 and matched_string:
self.matched_value = matched_string[0]
def __init__(self):
gedit.Plugin.__init__(self)
def activate(self, window):
helper = TerminalWindowHelper(window)
window.set_data(self.WINDOW_DATA_KEY, helper)
def deactivate(self, window):
window.get_data(self.WINDOW_DATA_KEY).deactivate()
window.set_data(self.WINDOW_DATA_KEY, None)
def update_ui(self, window):
window.get_data(self.WINDOW_DATA_KEY).update_ui()
gconf_client = gconf.client_get_default()
def gconf_get_bool(key, default = False):
val = gconf_client.get(key)
if val is not None and val.type == gconf.VALUE_BOOL:
return val.get_bool()
else:
return default
def gconf_get_str(key, default = ""):
val = gconf_client.get(key)
if val is not None and val.type == gconf.VALUE_STRING:
return val.get_string()
else:
return default
def test_gconf():
c = gconf.client_get_default()
return c.dir_exists('/apps/guake')
def __init__(self, directory):
# Get the GConf object
self.client = gconf.client_get_default()
self.client.add_dir(directory, gconf.CLIENT_PRELOAD_NONE)
self.directory = directory
self.org_directory = directory
def __init__(self, filename, imported=False):
super(LabyrinthWindow, self).__init__()
# FIXME: This can go when we move entirely to gtk 2.10
# pygtk 2.8 doesn't have the correct function :(
self.set_val = gtk.gtk_version[1] > 8
# First, construct the MainArea and connect it all up
self.undo = UndoManager.UndoManager(self)
self.undo.block()
self.MainArea = MMapArea.MMapArea(self.undo)
self.MainArea.connect("title_changed", self.title_changed_cb)
self.MainArea.connect("doc_save", self.doc_save_cb)
self.MainArea.connect("doc_delete", self.doc_del_cb)
self.MainArea.connect("change_mode", self.mode_request_cb)
self.MainArea.connect("button-press-event", self.main_area_focus_cb)
self.MainArea.connect("change_buffer", self.switch_buffer_cb)
self.MainArea.connect("thought_selection_changed",
self.thought_selected_cb)
self.MainArea.connect("set_focus", self.main_area_focus_cb)
self.MainArea.connect("set_attrs", self.attrs_cb)
if os.name != 'nt':
self.MainArea.connect("text_selection_changed",
self.selection_changed_cb)
self.config_client = gconf.client_get_default()
glade = gtk.glade.XML(utils.get_data_file_name('labyrinth.glade'))
self.main_window = glade.get_widget('MapWindow')
self.main_window.set_focus_child(self.MainArea)
if os.name != 'nt':
try:
self.main_window.set_icon_name('labyrinth')
except:
self.main_window.set_icon_from_file(
utils.get_data_file_name('labyrinth.svg'))
else:
self.main_window.set_icon_from_file('images\\labyrinth-24.png')
# insert menu, toolbar and map
self.create_menu()
glade.get_widget('main_area_insertion').pack_start(self.MainArea)
vbox = glade.get_widget('map_window_vbox')
menubar = self.ui.get_widget('/MenuBar')
menubar.show_all()
vbox.pack_start(menubar)
vbox.reorder_child(menubar, 0)
vbox.set_child_packing(menubar, 0, 0, 0, gtk.PACK_START)
toolbar = self.ui.get_widget('/ToolBar')
toolbar.show_all()
vbox.pack_start(toolbar)
vbox.reorder_child(toolbar, 1)
vbox.set_child_packing(toolbar, 0, 0, 0, gtk.PACK_START)
# TODO: Bold, Italics etc.
self.bold_widget = glade.get_widget('tool_bold')
self.bold_widget.connect('toggled', self.bold_toggled)
self.bold_block = False
self.bold_state = False
self.italic_widget = glade.get_widget('tool_italic')
self.italic_widget.connect('toggled', self.italic_toggled)
self.italic_block = False
self.italic_state = False
self.underline_widget = glade.get_widget('tool_underline')
self.underline_widget.connect('toggled', self.underline_toggled)
self.underline_block = False
self.underline_state = False
self.font_widget = glade.get_widget('font_button')
self.font_widget.connect("font-set", self.font_change_cb)
self.background_widget = glade.get_widget('background_color_button')
self.background_widget.connect("color-set", self.background_change_cb)
self.foreground_widget = glade.get_widget('foreground_color_button')
self.foreground_widget.connect("color-set", self.foreground_change_cb)
self.cut = self.ui.get_widget('/MenuBar/EditMenu/Cut')
self.copy = self.ui.get_widget('/MenuBar/EditMenu/Copy')
self.paste = self.ui.get_widget('/MenuBar/EditMenu/Paste')
self.link = self.ui.get_widget('/MenuBar/EditMenu/LinkThoughts')
self.delete = self.ui.get_widget('/MenuBar/EditMenu/DeleteNodes')
self.ui.get_widget('/MenuBar/EditMenu').connect(
'activate', self.edit_activated_cb)
self.cut.set_sensitive(False)
self.copy.set_sensitive(False)
# get toolbars and activate corresponding menu entries
self.main_toolbar = self.ui.get_widget('/ToolBar')
self.format_toolbar = glade.get_widget('format_toolbar')
self.ui.get_widget(
'/MenuBar/ViewMenu/ShowToolbars/ShowMainToolbar').set_active(True)
self.ui.get_widget('/MenuBar/ViewMenu/ShowToolbars/ShowFormatToolbar'
).set_active(True)
self.ui.get_widget('/MenuBar/ViewMenu/UseBezier').set_active(
utils.use_bezier_curves)
# Add in the extended info view
self.extended_window = glade.get_widget('extended_window')
self.extended = glade.get_widget('extended')
self.invisible_buffer = gtk.TextBuffer()
# Connect all our signals
self.main_window.connect("configure_event", self.configure_cb)
self.main_window.connect("window-state-event", self.window_state_cb)
self.main_window.connect("destroy", self.close_window_cb)
# Deal with loading the map
if not filename:
self.MainArea.set_size_request(400, 400)
# TODO: This shouldn't be set to a hard-coded number. Fix.
self.pane_pos = 500
self.title_cp = _("Untitled Map")
self.mode = MMapArea.MODE_EDITING
self.extended_visible = False
else:
self.parse_file(filename)
up_box = glade.get_widget('up_box')
up_box.connect("button-press-event", self.translate, "Up")
up_box.connect("button-release-event", self.finish_translate)
down_box = glade.get_widget('down_box')
down_box.connect("button-press-event", self.translate, "Down")
down_box.connect("button-release-event", self.finish_translate)
right_box = glade.get_widget('right_box')
right_box.connect("button-press-event", self.translate, "Right")
right_box.connect("button-release-event", self.finish_translate)
left_box = glade.get_widget('left_box')
left_box.connect("button-press-event", self.translate, "Left")
left_box.connect("button-release-event", self.finish_translate)
panes = glade.get_widget('vpaned1')
panes.connect("button-release-event", self.pos_changed)
panes.set_position(self.pane_pos)
# Other stuff
self.width, self.height = self.main_window.get_size()
# if we import, we dump the old filename to create a new hashed one
self.save_file = None
if not imported:
self.save_file = filename
self.maximised = False
self.view_type = 0
if self.set_val:
self.act.set_current_value(self.mode)
self.undo.unblock()
self.start_timer()
def __init__(self):
self.gconf = gconf.client_get_default()
def main(argv):
# Set default durations
picture_duration = 300.0
transition_duration = 5.0
# Parse the command line arguments
try:
opts, args = getopt.getopt(argv, "hp:t:", ["help", "picture-duration=", "transition-duration="])
for opt, arg in opts:
if opt in ("-h", "--help"):
usage()
sys.exit(0)
elif opt in ("-p", "--picture-duration"):
if arg.isdigit():
picture_duration = float(arg)
else:
usage()
sys.exit(1)
elif opt in ("-t", "--transition-duration"):
if arg.isdigit():
transition_duration = float(arg)
else:
usage()
sys.exit(1)
except getopt.GetoptError:
usage()
sys.exit(2)
# Make sure folder exists before continuing
folder = "".join(args)
if not os.path.isdir(folder):
print "Folder '" + folder + "' does not exist."
sys.exit(1)
# Search for valid files
files = []
accepted = ('.jpg', '.jpeg', '.gif', '.png')
for file in os.listdir(folder):
if os.path.splitext(file)[1].lower() in accepted:
files.append(os.path.join(folder, file))
files = sorted(files)
# Exit if no images found
nfiles = len(files)
if nfiles < 1:
print "Folder '" + folder + "' contains no images."
sys.exit(1)
# Create wallpaper xml
doc = libxml2.parseDoc("""<background><starttime><year>2010</year><month>01</month><day>01</day><hour>00</hour><minute>00</minute><second>00</second></starttime></background>""")
root = doc.getRootElement()
for i in range(0, nfiles):
static = root.newChild(None, "static", None)
static.addChild(static.newChild(None, "duration", str(picture_duration)))
static.addChild(static.newChild(None, "file", files[i]))
root.addChild(static)
if transition_duration <= 0: continue
transition = root.newChild(None, "transition", None)
transition.addChild(transition.newProp("type", "overlay"))
transition.addChild(transition.newChild(None, "duration", str(transition_duration)))
transition.addChild(transition.newChild(None, "from", files[i]))
if i < nfiles-1:
transition.addChild(transition.newChild(None, "to", files[i+1]))
else:
transition.addChild(transition.newChild(None, "to", files[0]))
root.addChild(transition)
# Write XML file
if not os.path.exists(os.path.expanduser("~/.gnome-wallpaper-slideshow")):
os.mkdir(os.path.expanduser("~/.gnome-wallpaper-slideshow"), 0755)
xml_file_path = os.path.expanduser("~/.gnome-wallpaper-slideshow/gnome-wallpaper-slideshow.xml")
try:
doc.saveFormatFileEnc(xml_file_path, "utf-8", 1)
except IOError:
print "Failed to write file."
sys.exit(2)
# Parse gnome backgrounds.xml file
backgrounds_file = os.path.expanduser("~/.gnome2/backgrounds.xml")
doc = libxml2.parseFile(backgrounds_file)
root = doc.getRootElement()
# Look for existing wallpaper entry
ctxt = doc.xpathNewContext()
res = ctxt.xpathEval("/wallpapers/wallpaper[filename=\""+xml_file_path+"\"]")
# If no entry exists, add one
if len(res) == 0:
wallpaper = root.newChild(None, "wallpaper", None)
wallpaper.addChild(wallpaper.newProp("deleted", "false"))
wallpaper.addChild(wallpaper.newChild(None, "name", "gnome-wallpaper-slideshow"))
wallpaper.addChild(wallpaper.newChild(None, "filename", xml_file_path))
wallpaper.addChild(wallpaper.newChild(None, "options", "stretched"))
wallpaper.addChild(wallpaper.newChild(None, "shade_type", "solid"))
wallpaper.addChild(wallpaper.newChild(None, "pcolor", "#2c2c00001e1e"))
wallpaper.addChild(wallpaper.newChild(None, "scolor", "#2c2c00001e1e"))
root.addChild(wallpaper)
try:
doc.saveFormatFileEnc(backgrounds_file, "utf-8", 1)
except IOError:
print "Failed to write file."
sys.exit(2)
# Set xml file as current background
conf_client = gconf.client_get_default()
conf_client.add_dir("/desktop/gnome/background", gconf.CLIENT_PRELOAD_NONE)
conf_client.set_string("/desktop/gnome/background/picture_filename", xml_file_path)
conf_client.set_string("/desktop/gnome/background/picture_options", "stretched")
def __init__(self, namespace={}, quit_handler=None):
""" Initialize console
"""
# Get font from gedit's entries in gconf
client = gconf.client_get_default()
default_question = client.get_bool(
'/apps/%s/preferences/editor/font/use_default_font' % APP_KEY)
if default_question == True:
userfont = client.get_string('/desktop/%s/interface/font_name' %
DE_KEY)
else:
userfont = client.get_string(
'/apps/%s/preferences/editor/font/editor_font' % APP_KEY)
# Setup scrolled window
gtk.ScrolledWindow.__init__(self)
self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.set_shadow_type(gtk.SHADOW_ETCHED_IN)
self.set_border_width(0)
# Setup text view
self.text = gtk.TextView()
self.text.set_property('can-focus', True)
self.text.modify_font(pango.FontDescription(userfont))
self.text.set_editable(True)
self.text.set_wrap_mode(True)
self.text.set_left_margin(1)
self.text.set_right_margin(1)
self.text.set_size_request(0, 0)
# Setup text buffer
self.buffer = self.text.get_buffer()
self.buffer.create_tag('prompt', weight=pango.WEIGHT_BOLD)
self.buffer.create_tag('script',
foreground='darkgrey',
style=pango.STYLE_OBLIQUE)
self.buffer.create_tag('normal', foreground='blue')
self.buffer.create_tag('error',
foreground='red',
style=pango.STYLE_OBLIQUE)
self.buffer.create_tag('extern', foreground='orange')
self.buffer.create_tag('center', justification=gtk.JUSTIFY_CENTER)
# Setup event handlers
self.text.add_events(gtk.gdk.KEY_PRESS_MASK)
self.text.connect('button-press-event', self.on_button_press)
self.text.connect('key-press-event', self.on_key_pressed)
self.text.connect('drag-data-received', self.on_drag_data_received)
self.add(self.text)
# Internal setup
self.namespace = namespace
self.cmd = ''
self.input = ''
self.input_mode = False
self.linestart = 0
self.quit_handler = self.quit
if quit_handler:
self.quit_handler = quit_handler
# Setup hooks for standard output.
self.stdout = gtkoutfile(self, sys.stdout.fileno(), 'normal')
self.stderr = gtkoutfile(self, sys.stderr.fileno(), 'error')
self.stdin = gtkinfile(self, sys.stdin.fileno())
# Setup command history
self.history = History()
self.namespace['__history__'] = self.history
self.show_all()
from serpentine.common import SerpentineNotSupportedError
from serpentine.common import SerpentineCacheError
from gettext import gettext as _
D_G_INTERFACE = "/desktop/gnome/interface"
# Make sure the URLs are clickable
def open_url(dlg, url):
webbrowser.open_new(url)
gtk.about_dialog_set_url_hook(open_url)
for gconf_dir in (D_G_INTERFACE, ):
gconf.client_get_default().add_dir(gconf_dir, gconf.CLIENT_PRELOAD_NONE)
class GladeComponent(Component):
def _setup_glade(self, g):
"""This method is called when the SerpentineWindow object is created."""
class FileDialogComponent(GladeComponent):
def __init__(self, parent):
super(FileDialogComponent, self).__init__(parent)
# Open playlist file dialog
self.file_dlg = gtk.FileChooserDialog(
parent=self.parent,
buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN,
def _get_gconf_settings(self):
try:
import gconf
self.client = gconf.client_get_default()
except ImportError:
pass
def get_icon_color(metadata):
if metadata is None or not 'icon-color' in metadata:
client = gconf.client_get_default()
return XoColor(client.get_string('/desktop/sugar/user/color'))
else:
return XoColor(metadata['icon-color'])
def __init__(self, prefDlg):
self.client = gconf.client_get_default()
self.prefDlg = prefDlg
def find(self, self2, replace = False):
self.treestore = None
self.reptxt = ""
if replace:
head = "pyedit: Find / Replace"
else:
head = "pyedit: Find in text"
dialog = gtk.Dialog(head,
None,
gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT,
gtk.STOCK_OK, gtk.RESPONSE_ACCEPT))
dialog.set_default_response(gtk.RESPONSE_ACCEPT)
dialog.replace = replace
dialog.set_icon_from_file(get_img_path("pyedit_sub.png"))
self.dialog = dialog
# Spacers
label1 = gtk.Label(" "); label2 = gtk.Label(" ")
label3 = gtk.Label(" "); label4 = gtk.Label(" ")
label5 = gtk.Label(" "); label6 = gtk.Label(" ")
label7 = gtk.Label(" "); label8 = gtk.Label(" ")
entry = gtk.Entry(); entry.set_activates_default(True)
if self2.oldsearch == "":
self2.oldsearch = gconf.client_get_default().\
get_string(config_reg + "/src")
if self2.oldsearch == None:
self2.oldsearch = ""
if self2.oldrep == "":
self2.oldrep = gconf.client_get_default().\
get_string(config_reg + "/rep")
if self2.oldrep == None:
self2.oldrep = ""
# See if we have a selection for search
if self2.xsel != -1:
xssel = min(self2.xsel, self2.xsel2)
xesel = max(self2.xsel, self2.xsel2)
yssel = min(self2.ysel, self2.ysel2)
yesel = max(self2.ysel, self2.ysel2)
if yssel == yesel:
self2.oldsearch = self2.text[yssel][xssel:xesel]
entry.set_text(self2.oldsearch)
dialog.vbox.pack_start(label4)
hbox2 = gtk.HBox()
hbox2.pack_start(label6, False)
hbox2.pack_start(entry)
hbox2.pack_start(label7, False)
dialog.vbox.pack_start(hbox2)
dialog.checkbox = gtk.CheckButton("Use _regular expression")
dialog.checkbox2 = gtk.CheckButton("Case In_sensitive")
dialog.checkbox.set_active(gconf.client_get_default().\
get_int(config_reg + "/regex"))
dialog.checkbox2.set_active(gconf.client_get_default().\
get_int(config_reg + "/nocase"))
dialog.vbox.pack_start(label5)
hbox = gtk.HBox()
hbox.pack_start(label1); hbox.pack_start(dialog.checkbox)
hbox.pack_start(label2); hbox.pack_start(dialog.checkbox2)
hbox.pack_start(label3);
dialog.vbox.pack_start(hbox)
dialog.vbox.pack_start(label8)
label30 = gtk.Label(" "); label31 = gtk.Label(" ")
label32 = gtk.Label(" "); label33 = gtk.Label(" ")
label34 = gtk.Label(" "); label35 = gtk.Label(" ")
dialog.checkbox3 = gtk.CheckButton("Search _All Buffers")
#dialog.checkbox4 = gtk.CheckButton("Hello")
hbox4 = gtk.HBox()
hbox4.pack_start(label30); hbox4.pack_start(dialog.checkbox3)
#hbox4.pack_start(label31); hbox4.pack_start(dialog.checkbox4)
hbox4.pack_start(label32);
dialog.vbox.pack_start(hbox4)
dialog.vbox.pack_start(label33)
if replace:
dialog.repl = gtk.Entry(); dialog.repl.set_text(self2.oldrep)
dialog.repl.set_activates_default(True)
label10 = gtk.Label(" "); label11 = gtk.Label(" ")
label12 = gtk.Label(" "); label13 = gtk.Label(" ")
hbox3 = gtk.HBox()
hbox3.pack_start(label10, False)
hbox3.pack_start(dialog.repl)
hbox3.pack_start(label11, False)
dialog.vbox.pack_start(hbox3)
dialog.vbox.pack_start(label12)
dialog.show_all()
response = dialog.run()
self2.oldsearch = entry.get_text()
self.srctxt = entry.get_text()
if replace:
self.reptxt = dialog.repl.get_text()
dialog.destroy()
if response != gtk.RESPONSE_ACCEPT:
return
if dialog.checkbox3.get_active():
nn = self2.mained.notebook.get_n_pages();
cnt = 0; cnt2 = 0
while True:
if cnt >= nn: break
ppp = self2.mained.notebook.get_nth_page(cnt)
self.xnum = cnt * 4
find_show(self, ppp.area)
cnt += 1
else:
self.xnum = 0
find_show(self, self2)
def _set_value(self, value):
self._value = value
gconf.client_get_default().set_string(self._key, value)
return
def gconf_set_bool(key, value):
v = gconf.Value(gconf.VALUE_BOOL)
v.set_bool(value)
gconf.client_get_default().set(key, v)
def OnExit(arg, prompt=True):
#print "onexit"
arg.set_title("Exiting ...")
# Save UI related data
pos = mained.hpaned.get_position()
pos = max(pos, 1)
gconf.client_get_default().set_int\
(pedconfig.conf.config_reg + "/hpaned", pos)
firstpage = notebook.get_nth_page(0)
if firstpage:
pos = firstpage.get_position()
pos = max(pos, 1)
gconf.client_get_default().set_int\
(pedconfig.conf.config_reg + "/vpaned", pos)
# Do not save ful screen coordinates (use F11)
if not mained.full:
xx, yy = mained.window.get_position()
gconf.client_get_default().set_int\
(pedconfig.conf.config_reg + "/xx", xx)
gconf.client_get_default().set_int\
(pedconfig.conf.config_reg + "/yy", yy)
ww, hh = mained.window.get_size()
gconf.client_get_default().set_int\
(pedconfig.conf.config_reg + "/ww", ww)
gconf.client_get_default().set_int\
(pedconfig.conf.config_reg + "/hh", hh)
# Prompt for save files
nn = notebook.get_n_pages()
cnt = 0
while True:
if cnt >= nn: break
ppp = notebook.get_nth_page(cnt)
#print "page:", ppp.area
if prompt:
ppp.area.prompt_save(False)
else:
# Rescue to temporary:
if ppp.area.changed:
hhh = hash_name(ppp.area.fname) + ".txt"
xfile = pedconfig.conf.config_dir + "/" + hhh
writefile(xfile, ppp.area.text)
cnt += 1
# Exit here
gtk.main_quit()
def gconf_get_str(key, default = ''):
val = gconf.client_get_default().get(key)
if val is not None and val.type == gconf.VALUE_STRING:
return val.get_string()
else:
return default
win2.set_events(
gtk.gdk.POINTER_MOTION_MASK |
gtk.gdk.POINTER_MOTION_HINT_MASK |
gtk.gdk.BUTTON_PRESS_MASK |
gtk.gdk.BUTTON_RELEASE_MASK |
gtk.gdk.KEY_PRESS_MASK |
gtk.gdk.KEY_RELEASE_MASK |
gtk.gdk.FOCUS_CHANGE_MASK )
win2.connect("key-press-event", area_key, self)
win2.connect("key-release-event", area_key, self)
win2.connect("focus-in-event", area_focus, self, self2)
win2.connect("unmap", area_destroy, self)
oldxx = gconf.client_get_default().get_int(config_reg + "/srcx")
oldyy = gconf.client_get_default().get_int(config_reg + "/srcy")
oldww = gconf.client_get_default().get_int(config_reg + "/srcw")
oldhh = gconf.client_get_default().get_int(config_reg + "/srch")
#print "win2", oldxx, oldyy, oldww, oldhh
if oldww == 0 and oldhh == 0:
# Position it out of the way
sxx, syy = self2.mained.window.get_position()
wxx, wyy = self2.mained.window.get_size()
myww = 2 * wxx / 4; myhh = 2 * wyy / 4
win2.set_default_size(myww, myhh)
win2.move(sxx + wxx - myww - 25 + self.xnum, \
syy + 25 + self.xnum)
else:
def gconf_get_bool(key, default = False):
val = gconf.client_get_default().get(key)
if val is not None and val.type == gconf.VALUE_BOOL:
return val.get_bool()
else:
return default
def __init__(self):
# By default use burnproof
self.__write_flags = nautilusburn.RECORDER_WRITE_BURNPROOF
# Sets up data dir and version
if release:
self.version = release.version
else:
self.version = "testing"
# setup ui
g = gtk.glade.XML(os.path.join(constants.data_dir, "serpentine.glade"),
"preferences_dialog")
self.__dialog = g.get_widget("preferences_dialog")
self.dialog.connect("destroy-event", self.__on_destroy)
# Drive selection
drv = g.get_widget("drive")
cmb_drv = nautilusburn.DriveSelection()
cmb_drv.set_property("show-recorders-only", True)
cmb_drv.show()
self.__drive_selection = cmb_drv
drv.pack_start(cmb_drv, False, False)
# Speed selection
self.__speed = gaw.data_spin_button(g.get_widget("speed"),
GCONF_DIR + "/write_speed")
self.__specify_speed = g.get_widget("specify_speed_wrapper")
specify_speed = g.get_widget("specify_speed")
self.__speed_select = gaw.RadioButtonData(
widgets=dict(specify_speed=specify_speed,
use_max_speed=g.get_widget("use_max_speed")),
key=GCONF_DIR + "/speed_select")
self.__speed_select.seleted_by_default = "use_max_speed"
specify_speed.connect("toggled", self.__on_specify_speed)
# init specify speed box sensitivity
self.__on_specify_speed(specify_speed)
# No default value set, set it to 99
if self.__speed.data == 0:
self.__speed.data = 99
self.__update_speed()
self.__speed.sync_widget()
self.__speed.widget.set_sensitive(specify_speed.get_active())
# eject checkbox
self.__eject = gaw.data_toggle_button(g.get_widget("eject"),
GCONF_DIR + "/eject")
g.get_widget("refresh_speed").connect("clicked",
self.__on_refresh_speed)
# use gap checkbox
self.__use_gap = gaw.data_toggle_button(g.get_widget("use_gap"),
GCONF_DIR + "/use_gap",
default=True)
# temp
ncb_temp_dir = "/apps/nautilus-cd-burner/temp_iso_dir"
gconf.client_get_default().add_dir(ncb_temp_dir,
gconf.CLIENT_PRELOAD_NONE)
self.__tmp = gaw.GConfValue(key=ncb_temp_dir,
data_spec=gaw.Spec.STRING,
default="file:///tmp")
# debug
self.__debug = gaw.GConfValue(key=GCONF_DIR + "/debug_mode",
data_spec=gaw.Spec.BOOL,
default=False)
# Pool
self.__pool = GvfsMusicPool()
# Close button
self.__close = g.get_widget("close_btn")
if len(n.childNodes
) != 1 or n.childNodes[0].nodeType != n.TEXT_NODE:
continue
valueString = n.childNodes[0].nodeValue
try:
value = valueTypes[valueType](valueString)
except KeyError:
continue
_values[name] = value
else:
haveGConfSupport = True
_GCONF_DIR = '/apps/glchess/'
_config = gconf.client_get_default()
try:
_config.add_dir(_GCONF_DIR[:-1], gconf.CLIENT_PRELOAD_NONE)
except gobject.GError:
pass
_gconfGetFunction = {
gconf.VALUE_BOOL: gconf.Value.get_bool,
gconf.VALUE_FLOAT: gconf.Value.get_float,
gconf.VALUE_INT: gconf.Value.get_int,
gconf.VALUE_STRING: gconf.Value.get_string
}
_gconfSetFunction = {
bool: _config.set_bool,
float: _config.set_float,
def __init__(self):
self.client = gconf.client_get_default()
try:
self.max_search_completion = \
self.client.get_int(MAX_SEARCH_COMPLETION_PREFERENCES)
self.initial_show_filter = \
self.client.get_int(INITIAL_SHOW_FILTER_PREFERENCES)
self.initial_section = \
self.client.get_int(INITIAL_SECTION_PREFERENCES)
self.last_export_selection_path = \
self.client.get_string(LAST_EXPORT_SELECTION_PATH)
self.last_add_pubcert_path = \
self.client.get_string(LAST_ADD_PUBCERT_PATH)
self.show_startpage = \
self.client.get_bool(SHOW_STARTPAGE_PREFERENCES)
self.save_state = \
self.client.get_bool(SAVE_STATE_PREFERENCES)
self.show_image_update = \
self.client.get_bool(SHOW_IMAGE_UPDATE_CONFIRMATION)
self.show_install = \
self.client.get_bool(SHOW_INSTALL_CONFIRMATION)
self.show_remove = \
self.client.get_bool(SHOW_REMOVE_CONFIRMATION)
self.start_insearch = \
self.client.get_bool(START_INSEARCH_PREFERENCES)
self.lastsource = \
self.client.get_string(LASTSOURCE_PREFERENCES)
self.not_show_repos = \
self.client.get_string(API_SEARCH_ERROR_PREFERENCES)
self.initial_app_width = \
self.client.get_int(INITIAL_APP_WIDTH_PREFERENCES)
self.initial_app_height = \
self.client.get_int(INITIAL_APP_HEIGHT_PREFERENCES)
self.initial_app_hpos = \
self.client.get_int(INITIAL_APP_HPOS_PREFERENCES)
self.initial_app_vpos = \
self.client.get_int(INITIAL_APP_VPOS_PREFERENCES)
self.client.add_dir(PACKAGEMANAGER_PREFERENCES,
gconf.CLIENT_PRELOAD_NONE)
self.client.notify_add(SHOW_IMAGE_UPDATE_CONFIRMATION,
self.__show_image_update_changed)
self.client.notify_add(SHOW_INSTALL_CONFIRMATION,
self.__show_install_changed)
self.client.notify_add(SHOW_REMOVE_CONFIRMATION,
self.__show_remove_changed)
self.client.notify_add(SAVE_STATE_PREFERENCES,
self.__save_state_changed)
self.details_expanded = \
self.client.get_bool(DETAILS_EXPANDED_PREFERENCES)
except GError:
# Default values - the same as in the
# packagemanager-preferences.schemas
self.max_search_completion = 20
self.initial_show_filter = 0
self.initial_section = 2
self.last_export_selection_path = ""
self.last_add_pubcert_path = ""
self.show_startpage = True
self.show_image_update = True
self.show_install = True
self.show_remove = True
self.save_state = True
self.start_insearch = True
self.lastsource = ""
self.not_show_repos = ""
self.initial_app_width = 800
self.initial_app_height = 600
self.initial_app_hpos = 200
self.initial_app_vpos = 320
self.details_expanded = True
self.show_startpage = False
self.__fix_initial_values()
def __init__(self):
self.client = gconf.client_get_default()
self.get_config()
def __init__(self, database):
self.conf_client = gconf.client_get_default()
self.thumbnailers = {}
self.database = database
self.thumbnails_dir = database + "_thumbs"
def gconf_set_str(key, value):
v = gconf.Value(gconf.VALUE_STRING)
v.set_string(value)
gconf.client_get_default().set(key, v)
