def configure(self, window):
"""
Configures the ZotoSink
"""
widget = Utils.dataprovider_glade_get_widget(
__file__,
"zoto.glade",
"ZotoSinkConfigDialog")
# Get configuration widgets
username = widget.get_widget("username")
password = widget.get_widget("password")
album = widget.get_widget("album")
# Load the widgets with presets
username.set_text(self.username)
password.set_text(self.password)
album.set_text(self.albumName)
dlg = widget.get_widget("ZotoSinkConfigDialog")
response = Utils.run_dialog(dlg, window)
if response == True:
self.username = username.get_text()
self.password = password.get_text()
self.albumName = album.get_text()
dlg.destroy()
def configure( self, window ):
# thanks to the evolution module for some of this
import gtk
tree = Utils.dataprovider_glade_get_widget(
__file__,
"config.glade",
"Firefox3ConfigDialog"
)
sourceComboBox = tree.get_widget("profileComboBox")
store = gtk.ListStore( str, str )
sourceComboBox.set_model(store)
cell = gtk.CellRendererText()
sourceComboBox.pack_start(cell, True)
sourceComboBox.add_attribute(cell, 'text', 0)
sourceComboBox.set_active(0)
for profilename, profilepath in self.get_profiles():
rowref = store.append( ( profilename, profilepath ) )
if profilepath == self.ProfilePath:
sourceComboBox.set_active_iter(rowref)
dlg = tree.get_widget("Firefox3ConfigDialog")
response = Utils.run_dialog (dlg, window)
if response == True:
self.ProfilePath = store.get_value(sourceComboBox.get_active_iter(), 1)
dlg.destroy()
def configure(self, window):
"""
Configures the RTM Backend
"""
import gtk
import gobject
def on_login_finish(*args):
Utils.dialog_reset_cursor(dlg)
def on_response(sender, responseID):
if responseID == gtk.RESPONSE_OK:
self.username = str(tree.get_widget('user_entry').get_text())
self.password = str(tree.get_widget('pass_entry').get_text())
def load_button_clicked(button):
Utils.dialog_set_busy_cursor(dlg)
conduit.GLOBALS.syncManager.run_blocking_dataprovider_function_calls(
self, on_login_finish, self._login)
tree = Utils.dataprovider_glade_get_widget(__file__, "config.glade",
"RTMConfigDialog")
#get a whole bunch of widgets
load_button = tree.get_widget("load_button")
dlg = tree.get_widget("RTMConfigDialog")
# load button
load_button.connect('clicked', load_button_clicked)
# run the dialog
Utils.run_dialog_non_blocking(dlg, on_response, window)
def configure(self, window, name):
import gtk
tree = Utils.dataprovider_glade_get_widget(
__file__,
"config.glade",
"EvolutionConfigDialog"
)
#get a whole bunch of widgets
sourceComboBox = tree.get_widget("sourceComboBox")
sourceLabel = tree.get_widget("sourceLabel")
sourceLabel.set_text(_("Select %s:") % name)
#make a combobox with the addressbooks
store = gtk.ListStore(gobject.TYPE_STRING,gobject.TYPE_STRING)
sourceComboBox.set_model(store)
cell = gtk.CellRendererText()
sourceComboBox.pack_start(cell, True)
sourceComboBox.add_attribute(cell, 'text', 0)
sourceComboBox.set_active(0)
for name,uri in self.allSourceURIs:
rowref = store.append( (name, uri) )
if uri == self.selectedSourceURI:
sourceComboBox.set_active_iter(rowref)
dlg = tree.get_widget("EvolutionConfigDialog")
response = Utils.run_dialog (dlg, window)
if response == True:
self.selectedSourceURI = store.get_value(sourceComboBox.get_active_iter(), 1)
dlg.destroy()
def configure(self, window):
import gtk
import gobject
def on_login_finish(*args):
if self.fapi.uid:
build_album_store()
Utils.dialog_reset_cursor(dlg)
def on_response(sender, responseID):
if responseID == gtk.RESPONSE_OK:
self.albumname = albumnamecombo.child.get_text()
def load_button_clicked(button):
Utils.dialog_set_busy_cursor(dlg)
conduit.GLOBALS.syncManager.run_blocking_dataprovider_function_calls(
self,
on_login_finish,
self._login)
def build_album_store():
album_store.clear()
album_count = 0
album_iter = None
for album_name in self._get_albums().keys():
iter = album_store.append((album_name,))
if album_name != "" and album_name == self.albumname:
album_iter = iter
album_count += 1
if album_iter:
albumnamecombo.set_active_iter(album_iter)
elif self.albumname:
albumnamecombo.child.set_text(self.albumname)
elif album_count:
albumnamecombo.set_active(0)
tree = Utils.dataprovider_glade_get_widget(
__file__,
"config.glade",
"FacebookConfigDialog")
#get a whole bunch of widgets
albumnamecombo = tree.get_widget("albumnamecombo")
load_button = tree.get_widget("load_button")
dlg = tree.get_widget("FacebookConfigDialog")
# setup combobox
album_store = gtk.ListStore(gobject.TYPE_STRING)
albumnamecombo.set_model(album_store)
cell = gtk.CellRendererText()
albumnamecombo.pack_start(cell, True)
albumnamecombo.set_text_column(0)
# load button
load_button.connect('clicked', load_button_clicked)
albumnamecombo.child.set_text(self.albumname)
# run the dialog
Utils.run_dialog_non_blocking(dlg, on_response, window)
def configure(self, window):
import gobject
import gtk
def col1_toggled_cb(cell, path, model ):
#not because we get this cb before change state
checked = not cell.get_active()
model[path][2] = checked
val = model[path][FILENAME_IDX]
if checked and val not in self.enabledAlbums:
self.enabledAlbums.append(val)
elif not checked and val in self.enabledAlbums:
self.enabledAlbums.remove(val)
tree = Utils.dataprovider_glade_get_widget(
__file__,
"config.glade",
"PicasaDesktopConfigDialog"
)
tagtreeview = tree.get_widget("albumtreeview")
#Build a list of all the tags
list_store = gtk.ListStore( gobject.TYPE_STRING, #FILENAME_IDX
gobject.TYPE_STRING, #DISLAYNAME_IDX
gobject.TYPE_BOOLEAN, #active
)
#Fill the list store
for t in self._get_all_albums():
list_store.append((
t[FILENAME_IDX],
t[DISPLAYNAME_IDX],
t[FILENAME_IDX] in self.enabledAlbums)
)
#Set up the treeview
tagtreeview.set_model(list_store)
#column 1 is the album name
tagtreeview.append_column( gtk.TreeViewColumn(_("Album Name"),
gtk.CellRendererText(),
text=DISPLAYNAME_IDX)
)
#column 2 is a checkbox for selecting the album to sync
renderer1 = gtk.CellRendererToggle()
renderer1.set_property('activatable', True)
renderer1.connect( 'toggled', col1_toggled_cb, list_store )
tagtreeview.append_column( gtk.TreeViewColumn(_("Enabled"),
renderer1,
active=2)
)
dlg = tree.get_widget("PicasaDesktopConfigDialog")
response = Utils.run_dialog (dlg, window)
dlg.destroy()
print self.enabledAlbums
def configure(self, window):
import gobject
import gtk
def build_album_model(albumCombo):
self.album_store.clear()
album_count = 0
album_iter = None
for name in self._get_photo_albums():
iter = self.album_store.append((name,))
if name == self.albumName:
album_iter = iter
album_count += 1
if album_iter:
albumCombo.set_active_iter(album_iter)
elif self.albumName:
albumCombo.child.set_text(self.albumName)
elif album_count:
albumCombo.set_active(0)
def delete_click(sender, albumCombo):
albumName = albumCombo.get_active_text()
if albumName:
self._delete_album(albumName)
build_album_model(albumCombo)
# get a whole bunch of widgets
tree = Utils.dataprovider_glade_get_widget(__file__, "config.glade", "PhotoConfigDialog")
albumCombo = tree.get_widget("album_combobox")
delete_button = tree.get_widget("delete_button")
# setup album store
self.album_store = gtk.ListStore(gobject.TYPE_STRING)
albumCombo.set_model(self.album_store)
cell = gtk.CellRendererText()
albumCombo.pack_start(cell, True)
albumCombo.set_text_column(0)
# setup widgets
build_album_model(albumCombo)
delete_button.connect("clicked", delete_click, albumCombo)
# run dialog
dlg = tree.get_widget("PhotoConfigDialog")
response = Utils.run_dialog(dlg, window)
if response == True:
# get the values from the widgets
self.albumName = albumCombo.get_active_text()
dlg.destroy()
del self.album_store
def configure(self, window):
import gtk
import gobject
def col1_toggled_cb(cell, path, model ):
#not because we get this cb before change state
checked = not cell.get_active()
model[path][CHECK_IDX] = checked
val = model[path][NAME_IDX]
if checked and val not in self.playlists:
self.playlists.append(val)
elif not checked and val in self.playlists:
self.playlists.remove(val)
log.debug("Toggle '%s' to: %s" % (val, checked))
return
#FIXME: This should not run here, it should run in initialize() instead
self.allPlaylists = self._parse_playlists(RhythmboxSource.PLAYLIST_PATH)
tree = Utils.dataprovider_glade_get_widget(
__file__,
"config.glade",
"RBConfigDialog"
)
tagtreeview = tree.get_widget("tagtreeview")
#Build a list of all the playlists
list_store = gtk.ListStore( gobject.TYPE_STRING, #name
gobject.TYPE_BOOLEAN, #active
)
#Fill the list store, preselect some playlists
for p in self.allPlaylists:
list_store.append( (p[0],p[0] in self.playlists) )
#Set up the treeview
tagtreeview.set_model(list_store)
#column 1 is the tag name
tagtreeview.append_column( gtk.TreeViewColumn(_("Tag Name"),
gtk.CellRendererText(),
text=NAME_IDX)
)
#column 2 is a checkbox for selecting the tag to sync
renderer1 = gtk.CellRendererToggle()
renderer1.set_property('activatable', True)
renderer1.connect( 'toggled', col1_toggled_cb, list_store )
tagtreeview.append_column( gtk.TreeViewColumn(_("Enabled"),
renderer1,
active=CHECK_IDX)
)
dlg = tree.get_widget("RBConfigDialog")
response = Utils.run_dialog (dlg, window)
dlg.destroy()
def configure(self, window):
import gobject
import gtk
def col1_toggled_cb(cell, path, model):
#not because we get this cb before change state
checked = not cell.get_active()
model[path][2] = checked
val = model[path][FILENAME_IDX]
if checked and val not in self.enabledAlbums:
self.enabledAlbums.append(val)
elif not checked and val in self.enabledAlbums:
self.enabledAlbums.remove(val)
tree = Utils.dataprovider_glade_get_widget(
__file__, "config.glade", "PicasaDesktopConfigDialog")
tagtreeview = tree.get_widget("albumtreeview")
#Build a list of all the tags
list_store = gtk.ListStore(
gobject.TYPE_STRING, #FILENAME_IDX
gobject.TYPE_STRING, #DISLAYNAME_IDX
gobject.TYPE_BOOLEAN, #active
)
#Fill the list store
for t in self._get_all_albums():
list_store.append(
(t[FILENAME_IDX], t[DISPLAYNAME_IDX], t[FILENAME_IDX]
in self.enabledAlbums))
#Set up the treeview
tagtreeview.set_model(list_store)
#column 1 is the album name
tagtreeview.append_column(
gtk.TreeViewColumn(_("Album Name"),
gtk.CellRendererText(),
text=DISPLAYNAME_IDX))
#column 2 is a checkbox for selecting the album to sync
renderer1 = gtk.CellRendererToggle()
renderer1.set_property('activatable', True)
renderer1.connect('toggled', col1_toggled_cb, list_store)
tagtreeview.append_column(
gtk.TreeViewColumn(_("Enabled"), renderer1, active=2))
dlg = tree.get_widget("PicasaDesktopConfigDialog")
response = Utils.run_dialog(dlg, window)
dlg.destroy()
print self.enabledAlbums
def configure(self, window):
import gtk
import gobject
def col1_toggled_cb(cell, path, model):
#not because we get this cb before change state
checked = not cell.get_active()
model[path][CHECK_IDX] = checked
val = model[path][NAME_IDX]
if checked and val not in self.playlists:
self.playlists.append(val)
elif not checked and val in self.playlists:
self.playlists.remove(val)
log.debug("Toggle '%s' to: %s" % (val, checked))
return
self.allPlaylists = self._get_playlists()
tree = Utils.dataprovider_glade_get_widget(__file__, "config.glade",
"RBConfigDialog")
tagtreeview = tree.get_widget("tagtreeview")
#Build a list of all the playlists
list_store = gtk.ListStore(
gobject.TYPE_STRING, #name
gobject.TYPE_BOOLEAN, #active
)
#Fill the list store, preselect some playlists
for p in self.allPlaylists:
list_store.append((p, p in self.playlists))
#Set up the treeview
tagtreeview.set_model(list_store)
#column 1 is the tag name
tagtreeview.append_column(
gtk.TreeViewColumn(_("Tag Name"),
gtk.CellRendererText(),
text=NAME_IDX))
#column 2 is a checkbox for selecting the tag to sync
renderer1 = gtk.CellRendererToggle()
renderer1.set_property('activatable', True)
renderer1.connect('toggled', col1_toggled_cb, list_store)
tagtreeview.append_column(
gtk.TreeViewColumn(_("Enabled"), renderer1, active=CHECK_IDX))
dlg = tree.get_widget("RBConfigDialog")
response = Utils.run_dialog(dlg, window)
dlg.destroy()
def __init__(self, mainWindow, db):
Vfs.FolderScannerThreadManager.__init__(self)
self.tree = Utils.dataprovider_glade_get_widget(
__file__,
"config.glade",
"FileSourceConfigDialog"
)
dic = { "on_addfile_clicked" : self.on_addfile_clicked,
"on_adddir_clicked" : self.on_adddir_clicked,
"on_remove_clicked" : self.on_remove_clicked,
None : None
}
self.tree.signal_autoconnect(dic)
self.mainWindow = mainWindow
self.db = db
self.model = Database.GenericDBListStore("config", self.db)
self._make_view()
#setup dnd onto the file list
targets = [ ( "text/uri-list", 0, 0 ) ]
f = self.tree.get_widget("filesscrolledwindow")
f.drag_dest_set(
gtk.DEST_DEFAULT_MOTION | gtk.DEST_DEFAULT_HIGHLIGHT | gtk.DEST_DEFAULT_DROP,
targets,
gtk.gdk.ACTION_COPY
)
f.connect("drag_data_received", self._dnd_data_get)
self.dlg = self.tree.get_widget("FileSourceConfigDialog")
#connect to dialog response signal because we want to validate that
#the user has named all the groups before we let them quit
self.dlg.connect("response",self.on_response)
self.dlg.set_transient_for(self.mainWindow)
self.dlg.show_all()
#Now go an background scan some folders to populate the UI estimates.
for oid,uri in self.db.select("SELECT oid,URI FROM config WHERE TYPE=? and SCAN_COMPLETE=?",(FileDataProvider.TYPE_FOLDER,False,)):
self.make_thread(
uri,
False, #include hidden
False, #follow symlinks
self._on_scan_folder_progress,
self._on_scan_folder_completed,
oid
)
def configure(self, window):
"""
Show configuration dialog for this module.
@param window: The parent window (used for modal dialogs)
@type window: C{gtk.Window}
"""
# lazily import gtk so if conduit is run from command line or a non
# gtk system, this module will still load. There should be no need
# to use gtk outside of this function
import gtk
def on_dialog_response(sender, response_id):
"""
Response handler for configuration dialog.
"""
if response_id == gtk.RESPONSE_OK:
self._set_aws_access_key(access_key_entry.get_text())
self._set_aws_secret_access_key(
secret_access_key_entry.get_text())
self._set_bucket_name(bucket_name_entry.get_text())
self._set_use_ssl((True, False)[ssl_combo_box.get_active()])
tree = Utils.dataprovider_glade_get_widget(__file__,
"config.glade",
"AmazonS3ConfigDialog")
# get widgets
dialog = tree.get_widget("AmazonS3ConfigDialog")
access_key_entry = tree.get_widget("accessKey")
secret_access_key_entry = tree.get_widget("secretAccessKey")
bucket_name_entry = tree.get_widget("bucketName")
ssl_combo_box = tree.get_widget("useSsl")
# set values of widgets
access_key_entry.set_text(
(self.aws_access_key, "")[self.aws_access_key == None])
secret_access_key_entry.set_text((self.aws_secret_access_key, "")
[self.aws_secret_access_key == None])
bucket_name_entry.set_text(self.bucket_name)
ssl_combo_box.set_active((1, 0)[self.use_ssl])
# show dialog
Utils.run_dialog_non_blocking(dialog, on_dialog_response, window)
def configure(self, window):
"""
Show configuration dialog for this module.
@param window: The parent window (used for modal dialogs)
@type window: C{gtk.Window}
"""
# lazily import gtk so if conduit is run from command line or a non
# gtk system, this module will still load. There should be no need
# to use gtk outside of this function
import gtk
def on_dialog_response(sender, response_id):
"""
Response handler for configuration dialog.
"""
if response_id == gtk.RESPONSE_OK:
self._set_aws_access_key(access_key_entry.get_text())
self._set_aws_secret_access_key(
secret_access_key_entry.get_text())
self._set_bucket_name(bucket_name_entry.get_text())
self._set_use_ssl((True, False)[ssl_combo_box.get_active()])
tree = Utils.dataprovider_glade_get_widget(__file__, "config.glade",
"AmazonS3ConfigDialog")
# get widgets
dialog = tree.get_widget("AmazonS3ConfigDialog")
access_key_entry = tree.get_widget("accessKey")
secret_access_key_entry = tree.get_widget("secretAccessKey")
bucket_name_entry = tree.get_widget("bucketName")
ssl_combo_box = tree.get_widget("useSsl")
# set values of widgets
access_key_entry.set_text(
(self.aws_access_key, "")[self.aws_access_key == None])
secret_access_key_entry.set_text(
(self.aws_secret_access_key,
"")[self.aws_secret_access_key == None])
bucket_name_entry.set_text(self.bucket_name)
ssl_combo_box.set_active((1, 0)[self.use_ssl])
# show dialog
Utils.run_dialog_non_blocking(dialog, on_dialog_response, window)
def configure(self, window):
tree = Utils.dataprovider_glade_get_widget(
__file__,
"config.glade",
"RSSSourceConfigDialog"
)
#get a whole bunch of widgets
url = tree.get_widget("url")
limitCb = tree.get_widget("limitdownloads")
limitSb = tree.get_widget("limitnumber")
randomize = tree.get_widget("randomize")
photosCb = tree.get_widget("downloadphotos")
audioCb = tree.get_widget("downloadaudio")
videoCb = tree.get_widget("downloadvideo")
#preload the widgets
if self.limit > 0:
limitCb.set_active(True)
limitSb.set_value(self.limit)
else:
limitCb.set_active(False)
url.set_text(self.feedUrl)
randomize.set_active(self.randomize)
photosCb.set_active(self.downloadPhotos)
audioCb.set_active(self.downloadAudio)
videoCb.set_active(self.downloadVideo)
dlg = tree.get_widget("RSSSourceConfigDialog")
response = Utils.run_dialog (dlg, window)
if response == True:
self.feedUrl = url.get_text()
if limitCb.get_active():
self.limit = int(limitSb.get_value())
self.randomize = randomize.get_active()
self.downloadPhotos = photosCb.get_active()
self.downloadAudio = audioCb.get_active()
self.downloadVideo = videoCb.get_active()
dlg.destroy()
def configure(self, window):
tree = Utils.dataprovider_glade_get_widget(__file__, "config.glade", "BackpackNotesSinkConfigDialog")
# get a whole bunch of widgets
usernameEntry = tree.get_widget("username")
apikeyEntry = tree.get_widget("apikey")
pagenameEntry = tree.get_widget("pagename")
# preload the widgets
usernameEntry.set_text(self.username)
apikeyEntry.set_text(self.apikey)
pagenameEntry.set_text(self.storeInPage)
dlg = tree.get_widget("BackpackNotesSinkConfigDialog")
response = Utils.run_dialog(dlg, window)
if response == True:
self.username = usernameEntry.get_text()
self.storeInPage = pagenameEntry.get_text()
if apikeyEntry.get_text() != self.apikey:
self.apikey = apikeyEntry.get_text()
dlg.destroy()
def __init__(self, mainWindow, folder, includeHidden, compareIgnoreMtime, followSymlinks):
log.debug("Starting new folder chooser at %s" % folder)
self.folder = folder
self.includeHidden = includeHidden
self.compareIgnoreMtime = compareIgnoreMtime
self.followSymlinks = followSymlinks
tree = Utils.dataprovider_glade_get_widget(
__file__,
"config.glade",
"FolderTwoWayConfigDialog"
)
self.folderChooser = tree.get_widget("filechooserbutton1")
self.folderChooser.set_current_folder_uri(self.folder)
self.hiddenCb = tree.get_widget("hidden")
self.hiddenCb.set_active(includeHidden)
self.mtimeCb = tree.get_widget("ignoreMtime")
self.mtimeCb.set_active(self.compareIgnoreMtime)
self.followSymlinksCb = tree.get_widget("followSymlinks")
self.followSymlinksCb.set_active(self.followSymlinks)
self.dlg = tree.get_widget("FolderTwoWayConfigDialog")
self.dlg.connect("response",self.on_response)
self.dlg.set_transient_for(mainWindow)
def configure(self, window):
"""
Configures the RTM Backend
"""
import gtk
import gobject
def on_login_finish(*args):
Utils.dialog_reset_cursor(dlg)
def on_response(sender, responseID):
if responseID == gtk.RESPONSE_OK:
self.username = str(tree.get_widget('user_entry').get_text())
self.password = str(tree.get_widget('pass_entry').get_text())
def load_button_clicked(button):
Utils.dialog_set_busy_cursor(dlg)
conduit.GLOBALS.syncManager.run_blocking_dataprovider_function_calls(
self,
on_login_finish,
self._login)
tree = Utils.dataprovider_glade_get_widget(
__file__,
"config.glade",
"RTMConfigDialog")
#get a whole bunch of widgets
load_button = tree.get_widget("load_button")
dlg = tree.get_widget("RTMConfigDialog")
# load button
load_button.connect('clicked', load_button_clicked)
# run the dialog
Utils.run_dialog_non_blocking(dlg, on_response, window)
def configure(self, window):
import gtk
def create_tags_clicked_cb(button):
text = self.tags_entry.get_text()
if not text:
return
tags = text.split(',')
for tag in tags:
self._create_tag (tag.strip ())
refresh_list_store()
def col1_toggled_cb(cell, path, model ):
#not because we get this cb before change state
checked = not cell.get_active()
model[path][1] = checked
val = model[path][NAME_IDX]
if checked and val not in self.enabledTags:
self.enabledTags.append(val)
elif not checked and val in self.enabledTags:
self.enabledTags.remove(val)
log.debug("Toggle '%s'(%s) to: %s" % (model[path][NAME_IDX], val, checked))
return
def refresh_list_store ():
#Build a list of all the tags
if not self.list_store:
self.list_store = gtk.ListStore(gobject.TYPE_STRING, #NAME_IDX
gobject.TYPE_BOOLEAN, #active
)
else:
self.list_store.clear ()
#Fill the list store
i = 0
for tag in self._get_all_tags():
self.list_store.append((tag,tag in self.enabledTags))
i += 1
#Fspot must be running
if not self._connect_to_fspot():
return
tree = Utils.dataprovider_glade_get_widget(
__file__,
"config.glade",
"FspotConfigDialog"
)
tagtreeview = tree.get_widget("tagtreeview")
refresh_list_store()
tagtreeview.set_model(self.list_store)
#column 1 is the tag name
tagtreeview.append_column( gtk.TreeViewColumn(_("Tag Name"),
gtk.CellRendererText(),
text=NAME_IDX)
)
#column 2 is a checkbox for selecting the tag to sync
renderer1 = gtk.CellRendererToggle()
renderer1.set_property('activatable', True)
renderer1.connect( 'toggled', col1_toggled_cb, self.list_store )
tagtreeview.append_column( gtk.TreeViewColumn(_("Enabled"),
renderer1,
active=1)
)
# Area for creating additional tags
create_button = tree.get_widget ('create_button')
self.tags_entry = tree.get_widget ('tags_entry')
create_button.connect('clicked', create_tags_clicked_cb)
dlg = tree.get_widget("FspotConfigDialog")
dlg.set_transient_for(window)
response = Utils.run_dialog (dlg, window)
dlg.destroy()
def configure(self, window):
"""
Configures the BoxDotNet sink
"""
import gtk
import gobject
def on_login_finish(*args):
if self.token:
build_folder_store()
Utils.dialog_reset_cursor(dlg)
def on_response(sender, responseID):
if responseID == gtk.RESPONSE_OK:
self.foldername = foldernamecombo.child.get_text()
def load_button_clicked(button):
Utils.dialog_set_busy_cursor(dlg)
conduit.GLOBALS.syncManager.run_blocking_dataprovider_function_calls(
self,
on_login_finish,
self._login)
def build_folder_store():
folder_store.clear()
folder_count = 0
folder_iter = None
for folder_name in self._get_folders().keys():
iter = folder_store.append((folder_name,))
if folder_name != "" and folder_name == self.foldername:
folder_iter = iter
folder_count += 1
if folder_iter:
foldernamecombo.set_active_iter(folder_iter)
elif self.foldername:
foldernamecombo.child.set_text(self.foldername)
elif folder_count:
foldernamecombo.set_active(0)
tree = Utils.dataprovider_glade_get_widget(
__file__,
"config.glade",
"BoxDotNetConfigDialog")
#get a whole bunch of widgets
foldernamecombo = tree.get_widget("foldernamecombo")
load_button = tree.get_widget("load_button")
dlg = tree.get_widget("BoxDotNetConfigDialog")
# setup combobox
folder_store = gtk.ListStore(gobject.TYPE_STRING)
foldernamecombo.set_model(folder_store)
cell = gtk.CellRendererText()
foldernamecombo.pack_start(cell, True)
foldernamecombo.set_text_column(0)
# load button
load_button.connect('clicked', load_button_clicked)
foldernamecombo.child.set_text(self.foldername)
# run the dialog
Utils.run_dialog_non_blocking(dlg, on_response, window)
def configure(self, window):
import gtk
def col1_toggled_cb(cell, path, model ):
#not because we get this cb before change state
checked = not cell.get_active()
model[path][CHECKED_IDX] = checked
( Name, Id, Type ) = ( model[path][NAME_IDX], model[path][ID_IDX], model[path][TYPE_IDX] )
if Type == NORMAL_PLAYLIST:
if checked and Name not in self.playlists:
self.playlists.append(Id)
elif not checked and Name in self.playlists:
self.playlists.remove(Id)
elif Type == SMART_PLAYLIST:
if checked and Name not in self.smart_playlists:
self.smart_playlists.append(Id)
elif not checked and Name in self.smart_playlists:
self.smart_playlists.remove(Id)
elif Type == VIDEO_PLAYLIST:
if checked and Name not in self.video_playlists:
self.video_playlists.append(Id)
elif not checked and Name in self.video_playlists:
self.video_playlists.remove(Id)
log.debug("Toggle name: '%s', type: '%s', id: '%s' to: %s" % (Name, Type, Id, checked))
return
tree = Utils.dataprovider_glade_get_widget(
__file__,
"config.glade",
"BansheeConfigDialog"
)
tagtreeview = tree.get_widget("tagtreeview")
#Build a list of all the tags
list_store = gtk.ListStore( gobject.TYPE_STRING, #ID_IDX - 0
gobject.TYPE_STRING, #NAME_IDX - 1
gobject.TYPE_BOOLEAN, #CHECKED_IDX - 2
gobject.TYPE_INT, #TYPE_IDX - 3
)
#Fill the list store
for playlist in self._get_all_playlists():
if playlist["type"] == NORMAL_PLAYLIST and playlist["id"] in self.playlists:
checked = True
elif playlist["type"] == SMART_PLAYLIST and playlist["id"] in self.smart_playlists:
checked = True
elif playlist["type"] == VIDEO_PLAYLIST and playlist["id"] in self.video_playlists:
checked = True
else:
checked = False
# Make video playlists more obvious
if playlist["type"] == VIDEO_PLAYLIST:
playlist["name"] += " (Video)"
list_store.append( ( playlist["id"], playlist["name"], checked, playlist["type"] ) )
#Set up the treeview
tagtreeview.set_model(list_store)
#column 1 is the tag name
tagtreeview.append_column( gtk.TreeViewColumn(_("Playlist Name"), # Tag name is confusing?
gtk.CellRendererText(),
text=NAME_IDX)
)
#column 2 is a checkbox for selecting the tag to sync
renderer1 = gtk.CellRendererToggle()
renderer1.set_property('activatable', True)
renderer1.connect( 'toggled', col1_toggled_cb, list_store )
tagtreeview.append_column( gtk.TreeViewColumn(_("Enabled"),
renderer1,
active=CHECKED_IDX)
)
dlg = tree.get_widget("BansheeConfigDialog")
response = Utils.run_dialog (dlg, window)
dlg.destroy()