private void BuildPreferences()
{
conf_ns = "sync";
manually_manage = dap.CreateSchema <bool> (conf_ns, "enabled", true,
Catalog.GetString("Manually manage this device"),
Catalog.GetString("Manually managing your device means you can drag and drop items onto the device, and manually remove them.")
);
auto_sync = dap.CreateSchema <bool> (conf_ns, "auto_sync", false,
Catalog.GetString("Automatically sync the device when plugged in or when the libraries change"),
Catalog.GetString("Begin synchronizing the device as soon as the device is plugged in or the libraries change.")
);
dap_prefs_section = new Section("dap", Catalog.GetString("Sync Preferences"), 0);
pref_sections.Add(dap_prefs_section);
manually_manage_pref = dap_prefs_section.Add(manually_manage);
manually_manage_pref.ShowDescription = true;
manually_manage_pref.ShowLabel = false;
manually_manage_pref.ValueChanged += OnManuallyManageChanged;
auto_sync_pref = dap_prefs_section.Add(auto_sync);
auto_sync_pref.ValueChanged += OnAutoSyncChanged;
//manually_manage_pref.Changed += OnEnabledChanged;
//auto_sync_pref.Changed += delegate { OnUpdated (); };
//OnEnabledChanged (null);
}
private void AddWidget(PreferenceBase preference, Widget widget, Widget mnemonic_widget)
{
uint start_row = NRows;
uint start_col = 0;
Label label = null;
if (!(widget is CheckButton) && preference.ShowLabel)
{
label = AttachLabel(preference.Name, start_row);
start_col++;
}
widget.Show();
Attach(widget, start_col, 2, start_row, start_row + 1,
AttachOptions.Expand | AttachOptions.Fill,
AttachOptions.Expand | AttachOptions.Fill, 0, 0);
if (label != null)
{
label.MnemonicWidget = mnemonic_widget ?? widget;
}
if (!String.IsNullOrEmpty(preference.Description))
{
widget.TooltipText = preference.Description;
if (label != null)
{
label.TooltipText = preference.Description;
}
}
}
// private PreferenceBase logout_pref;
public StoreSourcePreferences(StoreSource source)
{
var service = ServiceManager.Get <PreferenceService> ();
if (service == null)
{
return;
}
this.source = source;
service.InstallWidgetAdapters += OnPreferencesServiceInstallWidgetAdapters;
source_page = new SourcePage(source);
var country_section = source_page.Add(new Section("country", Catalog.GetString("Country"), 20));
country_section.Add(country_pref = new SchemaPreference <string> (StoreCountry,
null,
Catalog.GetString("Which Amazon MP3 storefront to use by default.")));
/*var session_section = source_page.Add (new Section ("session", Catalog.GetString ("Session"), 30));
* session_section.Add (new SchemaPreference<bool> (PersistLogin,
* Catalog.GetString ("_Keep me logged in"),
* Catalog.GetString ("Keep any session cookies that Amazon MP3 may set across instances.")));
* session_section.Add (logout_pref = new VoidPreference ("log-out-button"));*/
Hyena.Log.InformationFormat("AmazonMP3 store redirect URL: {0}", RedirectUrl.Get());
}
public static void Load(PreferenceService service)
{
Page music = ServiceManager.SourceManager.MusicLibrary.PreferencesPage;
foreach (LibrarySource source in ServiceManager.SourceManager.FindSources <LibrarySource> ())
{
new LibraryLocationButton(source);
}
PreferenceBase folder_pattern = music["file-system"]["folder_pattern"];
folder_pattern.DisplayWidget = new PatternComboBox(folder_pattern, FileNamePattern.SuggestedFolders);
PreferenceBase file_pattern = music["file-system"]["file_pattern"];
file_pattern.DisplayWidget = new PatternComboBox(file_pattern, FileNamePattern.SuggestedFiles);
PreferenceBase pattern_display = music["file-system"].FindOrAdd(new VoidPreference("file_folder_pattern"));
pattern_display.DisplayWidget = new PatternDisplay(folder_pattern.DisplayWidget, file_pattern.DisplayWidget);
// Set up the extensions tab UI
Banshee.Addins.Gui.AddinView view = new Banshee.Addins.Gui.AddinView();
view.Show();
Gtk.ScrolledWindow scroll = new Gtk.ScrolledWindow();
scroll.HscrollbarPolicy = PolicyType.Never;
scroll.AddWithViewport(view);
scroll.Show();
service["extensions"].DisplayWidget = scroll;
}
private void InstallPreferences()
{
music_lib = ServiceManager.SourceManager.MusicLibrary;
disable_album_grid = music_lib.PreferencesPage["misc"].FindOrAdd(DisableAlbumGridPref);
ServiceManager.SourceManager.SourceAdded -= InstallPreferences;
}
public PreferenceCheckButton(PreferenceBase preference)
{
this.preference = preference;
Label = preference.Name;
UseUnderline = true;
Active = (bool)preference.BoxedValue;
sync = true;
}
public PreferenceEntry(PreferenceBase preference)
{
this.preference = preference;
string value = (string)preference.BoxedValue;
Text = value ?? String.Empty;
sync = true;
}
public static Widget GetMnemonicWidget(PreferenceBase preference)
{
if (preference == null)
{
return(null);
}
return(preference.MnemonicWidget as Widget);
}
private void UninstallPreferences()
{
PreferenceService service = ServiceManager.Get <PreferenceService> ();
if (service == null)
{
return;
}
service["general"]["misc"].Remove(replaygain_preference);
replaygain_preference = null;
}
private void UninstallPreferences()
{
PreferenceService service = ServiceManager.Get <PreferenceService> ();
if (service == null)
{
return;
}
service["general"]["misc"].Remove(disable_internet_access_preference);
disable_internet_access_preference = null;
}
public static Widget GetWidget(PreferenceBase preference)
{
if (preference == null)
{
return(null);
}
Widget widget = preference.DisplayWidget as Widget;
//OnPreferenceChanged (preference);
return(widget ?? GetWidget(preference, preference.GetType().GetProperty("Value").PropertyType));
}
private void InstallPreferences ()
{
PreferenceService service = ServiceManager.Get<PreferenceService> ();
if (service == null) {
return;
}
enabled_pref = ServiceManager.SourceManager.MusicLibrary.PreferencesPage["misc"].Add (
new SchemaPreference<bool> (EnabledSchema,
Catalog.GetString ("_Automatically detect BPM for all songs"),
Catalog.GetString ("Detect BPM for all songs that don't already have a value set"),
delegate { Enabled = EnabledSchema.Get (); })
);
}
private void InstallPreferences()
{
PreferenceService service = ServiceManager.Get <PreferenceService> ();
if (service == null)
{
return;
}
replaygain_preference = service["general"]["misc"].Add(new SchemaPreference <bool> (ReplayGainEnabledSchema,
Catalog.GetString("_Enable ReplayGain correction"),
Catalog.GetString("For tracks that have ReplayGain data, automatically scale (normalize) playback volume"),
delegate { audio_sink.ReplayGainEnabled = ReplayGainEnabledSchema.Get(); }
));
}
public PreferenceSpinButton(PreferenceBase preference, int min_value, int max_value)
{
var spin_button = new SpinButton(min_value, max_value, 1);
spin_button.ValueChanged += delegate {
if (sync)
{
this.preference.BoxedValue = (int)spin_button.Value;
}
};
spin_button.Show();
PackEnd(spin_button, false, false, 0);
this.preference = preference;
spin_button.Value = (int)preference.BoxedValue;
sync = true;
}
private void InstallPreferences()
{
PreferenceService service = ServiceManager.Get <PreferenceService> ();
if (service == null)
{
return;
}
enabled_pref = service["general"]["misc"].Add(
new SchemaPreference <bool> (EnabledSchema,
Catalog.GetString("_Show Banshee in the sound menu"),
Catalog.GetString("Control Banshee through the sound menu"),
delegate { Enabled = EnabledSchema.Get(); })
);
}
void IExtensionService.Initialize()
{
_prefs = ServiceManager.Get <PreferenceService>();
if (_prefs == null)
{
return;
}
Page remoteControlPage = new Page("RemoteControl", "Remote Control", 3);
_prefs.FindOrAdd(remoteControlPage);
Section BansheeRemotePrefs = remoteControlPage.FindOrAdd(
new Section("BansheeRemote", "Banshee Remote", 0));
_portPref = BansheeRemotePrefs.Add(new SchemaPreference <int>(
RemotePortSchema,
Catalog.GetString("Port"),
Catalog.GetString("Banshee will listen for remote control requests on this port")
));
_passIdPref = BansheeRemotePrefs.Add(new SchemaPreference <int>(
RemotePassIdSchema,
Catalog.GetString("Password ID"),
Catalog.GetString("\"Secret\" ID which is required to be specified in incoming requests")
));
_prefs["RemoteControl"]["BansheeRemote"]["remote_control_passid"].ValueChanged += delegate {
_passId = (int)_prefs["RemoteControl"]["BansheeRemote"]["remote_control_passid"].BoxedValue;
};
_prefs["RemoteControl"]["BansheeRemote"]["remote_control_port"].ValueChanged += delegate {
StartRemoteListener();
};
_disposed = false;
ServiceManager.SourceManager.SourceRemoved += OnSourceRemoved;
_passId = (int)_prefs["RemoteControl"]["BansheeRemote"]["remote_control_passid"].BoxedValue;
Helper.SetDbCompressTimeFromFile();
Helper.CompressDatabase();
StartRemoteListener();
}
private void UninstallPreferences()
{
PreferenceService service = ServiceManager.Get <PreferenceService> ();
if (service == null)
{
return;
}
service["general"]["misc"].Remove(replaygain_preference);
if (bp_supports_gapless(handle))
{
service["general"]["misc"].Remove(gapless_preference);
}
replaygain_preference = null;
gapless_preference = null;
}
private void InstallPreferences()
{
bansheePrefs = ServiceManager.Get <PreferenceService>();
if (bansheePrefs == null)
{
return;
}
Page remoteControlPage = new Page("RemoteControl", "Remote Control", 3);
bansheePrefs.FindOrAdd(remoteControlPage);
Section BansheeRemotePrefs = remoteControlPage.FindOrAdd(new Section("BansheeRemote", "Banshee Remote", 0));
port_pref = BansheeRemotePrefs.Add(new SchemaPreference <int>(
RemotePortSchema,
Catalog.GetString("Banshee Remote port"),
Catalog.GetString("Banshee will listen for the Android Banshee Remote app on this port")));
}
private void InstallPreferences()
{
PreferenceService service = ServiceManager.Get <PreferenceService> ();
if (service == null)
{
return;
}
replaygain_preference = service["general"]["misc"].Add(new SchemaPreference <bool> (ReplayGainEnabledSchema,
Catalog.GetString("_Enable ReplayGain correction"),
Catalog.GetString("For tracks that have ReplayGain data, automatically scale (normalize) playback volume"),
delegate { ReplayGainEnabled = ReplayGainEnabledSchema.Get(); }
));
gapless_preference = service["general"]["misc"].Add(new SchemaPreference <bool> (GaplessEnabledSchema,
Catalog.GetString("Enable _gapless playback"),
Catalog.GetString("Eliminate the small playback gap on track change. Useful for concept albums and classical music"),
delegate { GaplessEnabled = GaplessEnabledSchema.Get(); }
));
}
public PatternComboBox(PrimarySource source, PreferenceBase pref, string [] patterns)
{
preference = (Preference <string>)pref;
bool already_added = false;
string conf_pattern = preference.Value;
foreach (string pattern in patterns)
{
if (!already_added && pattern.Equals(conf_pattern))
{
already_added = true;
}
Add(source.PathPattern.CreatePatternDescription(pattern), pattern);
}
if (!already_added)
{
Add(source.PathPattern.CreatePatternDescription(conf_pattern), conf_pattern);
}
ActiveValue = conf_pattern;
}
private void InstallPreferences()
{
disable_internet_access = DisableInternetAccess.Get();
PreferenceService service = ServiceManager.Get <PreferenceService> ();
if (service == null)
{
return;
}
disable_internet_access_preference = service["general"]["misc"].Add(new SchemaPreference <bool> (DisableInternetAccess,
Catalog.GetString("_Disable features requiring Internet access"),
Catalog.GetString("Some features require a broadband Internet connection such as Last.fm or cover art fetching"),
delegate {
bool was_connected = Connected;
disable_internet_access = DisableInternetAccess.Get();
if (Connected != was_connected)
{
OnStateChanged();
}
}
));
}
private static Widget GetWidget(PreferenceBase preference, Type type)
{
Widget pref_widget = null;
Widget widget = null;
if (type == typeof(bool))
{
pref_widget = new PreferenceCheckButton(preference);
}
else if (type == typeof(string))
{
pref_widget = new PreferenceEntry(preference);
}
else if (type == typeof(int))
{
var schema_preference = preference as SchemaPreference <int>;
if (schema_preference == null)
{
pref_widget = new PreferenceSpinButton(preference);
}
else
{
pref_widget = new PreferenceSpinButton(preference, schema_preference.MinValue, schema_preference.MaxValue);
}
}
if (pref_widget != null)
{
pref_widget.Sensitive = preference.Sensitive;
pref_widget.Visible = preference.Visible;
DescriptionLabel label = null;
if (preference.ShowDescription)
{
VBox box = new VBox();
box.PackStart(pref_widget, false, false, 0);
label = new DescriptionLabel(preference.Description);
label.Visible = !String.IsNullOrEmpty(preference.Description);
label.PackInto(box, false);
widget = box;
}
preference.Changed += delegate(Root pref) {
Banshee.Base.ThreadAssist.ProxyToMain(delegate {
pref_widget.Sensitive = pref.Sensitive;
pref_widget.Visible = pref.Visible;
/*if (label != null) {
* label.Text = pref.Description;
* label.Visible = !String.IsNullOrEmpty (preference.Description);
* }*/
if (pref_widget is PreferenceCheckButton)
{
(pref_widget as PreferenceCheckButton).Label = pref.Name;
}
});
};
}
return(widget ?? pref_widget);
}
public PreferenceSpinButton(PreferenceBase preference) : this(preference, 0, 100)
{
}
