internal static bool GetFileDatesProperties
(ImporterProperties importerProperties,
int index, OptionSettings prop, ref int counter)
{
if (index == counter++)
{
//set the internal name
prop.Name = "ImportDateCreatedProp";
prop.GroupName = "AdditionalFileTags";
//set name shown to user
prop.Caption = "Import file Creation date?";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
prop.GroupCaption = " Additional Tags to Import";
//set the tool tip
prop.HelpText = "";
prop.DefaultValue = Settings.ImportDateCreated;
prop.DataType = "bool";
return true;
}
if (index == counter++)
{
//set the internal name
prop.Name = "ImportDateModifiedProp";
prop.GroupName = "AdditionalFileTags";
//set name shown to user
prop.Caption = "Import file Modification date?";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//Prop.GroupCaption = " Additional Tags to Import";
//set the tool tip
prop.HelpText = "";
prop.DefaultValue = Settings.ImportDateModified;
prop.DataType = "bool";
return true;
}
if (index == counter++)
{
//set the internal name
prop.Name = "ImportDateImportedProp";
prop.GroupName = "AdditionalFileTags";
//set name shown to user
prop.Caption = "Import Addition to library date?";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//Prop.GroupCaption = " Additional Tags to Import";
//set the tool tip
prop.HelpText = "";
prop.DefaultValue = Settings.ImportDateImported;
prop.DataType = "bool";
return true;
}
return false;
}
//draw the node window
//change this to edit node instead
void DrawOptionWindow(int id)
{
//edit the node
if (GUILayout.Button("Edit Info"))
{
//windowsToAttach.Add(id);
OptionSettings.OpenWindow(options[id], node);
}
GUI.DragWindow();
}
public OptionsDialog(OptionSettings options)
{
//
// Required for Windows Form Designer support
//
InitializeComponent();
//
// TODO: Add any constructor code after InitializeComponent call
//
this.options = options;
}
public async Task PostMentionPushNotifications(OptionSettings setting)
{
UserInfo user = await GetUserInfoAsync();
if (setting.IsEnabled)
{
user.MentionNotificationSettings |= NotifyOptions.PushNotification;
}
else
{
user.MentionNotificationSettings &= ~NotifyOptions.PushNotification;
}
await DbContext.SaveChangesAsync();
}
/// <summary>
/// <see cref="MainForm"/> classの初期化
/// </summary>
public MainForm(CommandLineArgs args)
{
if (args.UseConsole)
{
RenameLogger.ConsoleMode = true;
}
if (args.UseDebugMode)
{
RenameLogger.DebugMode = true;
}
_settings = new OptionSettingsSerializer().Load();
InitializeComponent();
}
//for opening the window for the first time
public static void OpenWindow(dialogueOption o = null, Node p = null)
{
option = o;
parent = p;
if (option != null)
{
//set values
text = option._text;
req = option._req;
dest = option._dest;
}
window = (OptionSettings)GetWindow(typeof(OptionSettings));
window.minSize = new Vector2(300, 300);
window.Show();
}
/// <summary>
///
/// </summary>
/// <param name="worker"></param>
/// <param name="optionSettings"></param>
/// <param name="windowManager"></param>
public MainViewModel(LongProcessWorker worker, OptionSettings optionSettings, IWindowManager windowManager)
{
this.worker = worker;
this.optionSettings = optionSettings;
Log = new ObservableCollection <LogEntry>();
WindowManager = windowManager;
Disposables.Add(Observable
.FromEvent <EventHandler <LogEventArgs>, LogEventArgs>(h => (s, e) => h(e), h => worker.Logged += h, h => worker.Logged -= h)
.ObserveOnDispatcher()
.Subscribe(e => Log.Add(new LogEntry(e.DateTime, e.LogType, e.Message))));
Disposables.Add(Observable
.FromEvent <EventHandler <EventArgs>, EventArgs>(h => (s, e) => h(e), h => worker.ExecutingChanged += h, h => worker.ExecutingChanged -= h)
.ObserveOnDispatcher()
.Subscribe(e => Running = worker.Executing));
}
void OnEnable()
{
settings = new OptionSettings();
//Dynamically allocates possible screen resolutions:
//Gets array of available resolutions
resolutions = Screen.resolutions;
List <Dropdown.OptionData> resolutionString = new List <Dropdown.OptionData>();
for (int i = 0; i < resolutions.Length; i++)
{
//turns every element of that array into strtring, then places in an OptionData
resolutionString.Add(new Dropdown.OptionData(resolutions[i].ToString()));
}
//Sets the options of the resolution setting as the OptionData
resolutionDropdown.options = resolutionString;
}
internal static bool GetImportSequencerProperties
(ImporterProperties importerProperties,
int index, OptionSettings prop, ref int counter)
{
if (index == counter++)
{
prop.GroupName = "ImportSequencer";
//set the internal name
prop.Name = "ImportSequencerProp";
//set name shown to user
prop.GroupCaption = " Import Sequencer";
prop.Caption = "Enable Import Sequencer";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = "";
prop.DefaultValue = MediaFairy.Settings.ImportSequencer;
prop.DataType = "bool";
prop.Dependencies = "True:SHOW ImportIDsProp" +
";False:HIDE ImportIDsProp";
return true;
}
if (index == counter++)
{
prop.GroupName = "ImportSequencer";
//set the internal name
prop.Name = "ImportIDsProp";
//set name shown to user
prop.Caption = "Import IDs to run: ";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = "";
prop.DefaultValue = MediaFairy.Settings.ImportIDs;
prop.DataType = "stringlist";
return true;
}
return false;
}
/// <summary>
///
/// </summary>
/// <param name="optionSettings"></param>
public OptionViewModel(OptionSettings optionSettings)
{
OptionSettings = optionSettings;
}
/// <param name='operations'>
/// Reference to the Rg.ClientApp.IProfile.
/// </param>
/// <param name='setting'>
/// Required.
/// </param>
public static object PostMentionPushNotificationsBySetting(this IProfile operations, OptionSettings setting)
{
return(Task.Factory.StartNew((object s) =>
{
return ((IProfile)s).PostMentionPushNotificationsBySettingAsync(setting);
}
, operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult());
}
void DrawBody()
{
GUILayout.BeginArea(mainSection);
//if windowstotattach is 2 and the connecting node isn't parented to that
if (windowsToAttach.Count == 2 &&
!(nodeConnections[windowsToAttach[0]].Contains(windowsToAttach[1])))
{
attachedWindows.Add(windowsToAttach[0]);
attachedWindows.Add(windowsToAttach[1]);
//create new dialogueOption
//then open up dialogue window editor
dialogueOption opt = new dialogueOption();
OptionSettings.OpenWindow(opt, nodes[windowsToAttach[0]]);
opt._dest = windowsToAttach[1];
//add the dialogue option to the thingy thing
nodes[windowsToAttach[0]]._options.Add(opt);
nodeConnections[windowsToAttach[0]].Add(windowsToAttach[1]);
windowsToAttach = new List <int>();
}
if (attachedWindows.Count >= 2)
{
for (int i = 0; i < attachedWindows.Count; i += 2)
{
DrawNodeCurve(windows[attachedWindows[i]], windows[attachedWindows[i + 1]]);
}
}
if (redrawLinks)
{
Debug.Log("Redrawing");
for (int i = 0; i < nodes.Count; i++)
{
//Debug.Log("Node " + i);
for (int j = 0; j < nodeConnections[i].Count; j++)
{
//Debug.Log("EY");
DrawNodeCurve(windows[i], windows[nodeConnections[i][j]]);
}
}
redrawLinks = false;
}
//for the node editor
//mark beginning area for all popup windows
BeginWindows();
//iterate over the contained windows and draw them
for (int i = 0; i < windows.Count; i++)
{
windows[i] = GUI.Window(i, windows[i], DrawNodeWindow, "Node " + i);
}
EndWindows();
GUILayout.EndArea();
}
internal static bool FimImportingOptions
(ImporterProperties importerProperties,
int index, OptionSettings prop,
string[] twochoices, ref int counter)
{
#region Film Importing options
if (index == counter++)
{
prop.GroupName = "MovieTitleLocator";
//set the internal name
prop.Name = "ImportDvdImagesProp";
//set name shown to user
prop.GroupCaption = " Film Importing Options";
prop.Caption = "Import DVD images containing films";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = "";
prop.DefaultValue = Settings.ImportDvdImages;
prop.DataType = "bool";
return true;
}
if (index == counter++)
{
prop.GroupName = "MovieTitleLocator";
//set the internal name
prop.Name = "ImportBluRayImagesProp";
//set name shown to user
prop.GroupCaption = " Film Importing Options";
prop.Caption = "Import BluRay images containing films";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = "";
prop.DefaultValue = Settings.ImportBluRayImages;
prop.DataType = "bool";
return true;
}
if (index == counter++)
{
prop.GroupName = "MovieTitleLocator";
//set the internal name
prop.Name = "ImportDvdFoldersProp";
//set name shown to user
prop.Caption = "Import DVD film back-ups (preserved disc structure)";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = "";
prop.DefaultValue = Settings.ImportDvdFolders;
prop.DataType = "bool";
return true;
}
if (index == counter++)
{
prop.GroupName = "MovieTitleLocator";
//set the internal name
prop.Name = "ImportRarFilmsProp";
//set name shown to user
prop.Caption = "Import multi-part RAR archives as films";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = "";
prop.DefaultValue = Settings.ImportFilmsInRarArchives;
prop.DataType = "bool";
return true;
}
if (index == counter++)
{
prop.GroupName = "MovieTitleLocator";
//set the internal name
prop.Name = "MovieTitleLocatorProp";
//set name shown to user
prop.Caption = "Override automated film title locator";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText =
" If the Automated film title locator fails to correctly locate the titles of your films in their paths (file name or folder name)," +
Environment.NewLine + "please check this setting to manually override it.";
prop.DefaultValue = Settings.OverrideAutomatedMovieTitleLocator;
prop.DataType = "bool";
prop.Dependencies = "False:HIDE MovieTitleLocationProp" +
";True:SHOW MovieTitleLocationProp";
return true;
}
if (index == counter++)
{
prop.GroupName = "MovieTitleLocator";
//set the internal name
prop.Name = "MovieTitleLocationProp";
//set name shown to user
prop.Caption = "Movie's title location in path: ";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = "Please specify here the location of your movies' titles in their path.";
prop.DefaultValue = Settings.MovieTitleLocationInPath;
prop.DataType = "string";
twochoices[0] = "Parent folder";
twochoices[1] = "Video filename";
prop.CanTypeChoices = false;
prop.Choices = twochoices;
prop.IsMandatory = false;
return true;
}
#endregion
return false;
}
public override bool GetProperty(Int32 index, OptionSettings prop)
{
#region init vars
int counter = 1;
string[] threechoices = new string[3];
string[] twochoices = new string[2];
string[] fourchoices = new string[4];
#endregion
#region initialize Sections
#region Create Media Library class to access media sections
#if USE_MEEDIO
IMeedioLibrary MeedioLibrary = new MeedioLibrary.MediaLibrary();
#elif USE_MEEDIOS
IMeedioLibrary MeedioLibrary = new MediaLibraryClass();
#endif
#endregion
#region Create sectionChoices array and populate it with the names of the Media Sections
string[] sectionChoices = new string[MeedioLibrary.SectionCount + 1];
sectionChoices[0] = string.Empty;
for (int i = 1; i < MeedioLibrary.SectionCount + 1; i++)
{
#if USE_MEEDIO
SectionChoices[i] = MeedioLibrary.get_Sections(i-1);
#elif USE_MEEDIOS
sectionChoices[i] = MeedioLibrary.Sections(i-1);
#endif
}
#endregion
#endregion
try
{
if (ConfigurationMode
.ConfigurationModeProperty
(this, index,
prop, ref counter))
return true;
if (MediaSections
.MediaSectionsProperties
(index, prop,
sectionChoices,
ref counter))
return true;
//DEPRECATED: Import and Update Media Types Combo Settings
//if (ImportAndUpdateMediaTypesCombo.ImportAndUpdateMediaTypesComboProperties(index, prop, ref counter)) return true;
if (ImporterPropertiesGroups
.MediaImporters
.MediaImportersProperties
(this, index, prop,
twochoices, ref counter))
return true;
#region Media Updaters
if (index == counter++)
{
//set the internal name
prop.Name = "WantMediaUpdatingProp";
prop.GroupName = "MediaUpdaters";
//set name shown to user
prop.Caption = "Enable Media Updaters ";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
prop.GroupCaption = " Media Updaters ";
//set the tool tip
prop.HelpText = "The Media Updaters scan the media sections you provide and automatically" + Environment.NewLine +
"identify, download details, cover images and other online data" + Environment.NewLine +
"for movies, tv series, audio tracks, books and/or games contained in these sections.";
prop.DefaultValue = MediaImportersAndUpdatersCoreSettings.EnableMediaUpdaters;
prop.DataType = "bool";
prop.Dependencies =
"False:HIDE"
+
" UpdateMoviesProp,"
+
"UpdateTvShowsProp,"
+
"UpdateMusicProp"
+
";False:HIDEGROUP"
+
" FilmUpdater,"
+
"TvUpdater,"
+
"MusicUpdater,"
+
"FilmDetails,"
+
"FilmCovers,"
+
"AlbumCovers,"
+
"VideoIdentifier"
+
";True:SHOW"
+
" UpdateMoviesProp,"
+
"UpdateTvShowsProp,"
+
"UpdateMusicProp";
return true;
}
if (index == counter++)
{
//set the internal name
prop.Name = "UpdateMoviesProp";
prop.GroupName = "MediaUpdaters";
//set name shown to user
prop.Caption = "Update Films section";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
//set the tool tip
prop.HelpText = "Do you want MediaFairy to work with the films in your Movies library?";
prop.DefaultValue = Settings.EnableMoviesSectionUpdater;
prop.DataType = "bool";
prop.Dependencies =
"False:HIDEGROUP "
+
"VideoIdentifier,"
+
"FilmUpdater,"
+
"FilmDetails,"
+
"FilmCovers"
+
";True:SHOWGROUP "
+
"VideoIdentifier,"
+
"FilmUpdater";
return true;
}
#region Video Identifier
if (index == counter++)
{
//set the internal name
prop.Name = "PrimaryFilmIdentificationMethodProp";
//set name shown to user
prop.Caption = "Primary film identification method: ";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
prop.GroupName = "VideoIdentifier";
//set the tool tip
prop.HelpText = "Please choose the order of the film identification methods." + Environment.NewLine +
"When/if the primary method of identification fails, MediaFairy will resort to using the secondary method instead.";
prop.DefaultValue = Settings.PrimaryFilmIdentificationMethod;
prop.DataType = "string";
twochoices[0] = "by video fingerprint";
twochoices[1] = "by video title";
prop.Choices = twochoices;
prop.CanTypeChoices = false;
return true;
}
if (index == counter++)
{
//set the internal name
prop.Name = "PrimaryVideoFingerprintMatchingSourceProp";
//set name shown to user
prop.Caption = "Primary video fingerprint matching source: ";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
prop.GroupName = "VideoIdentifier";
//set the tool tip
prop.HelpText = "Please choose the priority of video fingerprint matching sources MediaFairy should use to identify a video by its fingerprint." + Environment.NewLine +
"If/when your defined primary source fails, MediaFairy will resort to using the second source in the priority.";
prop.DefaultValue = Settings.PrimaryVideoFingerprintMatchingSource;
prop.DataType = "string";
twochoices[0] = "OSDb";
twochoices[1] = "TMDb";
prop.Choices = twochoices;
prop.CanTypeChoices = false;
return true;
}
#region IMDb Title matching engines priority
if (index == counter++)
{
//set the internal name
prop.Name = "PrimaryFilmTitleMatchingEngineProp";
//set name shown to user
prop.Caption = "Primary film title matching engine: ";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
prop.GroupName = "VideoIdentifier";
//set the tool tip
prop.HelpText = "Please choose the priority of film Title matching engines" +
" MeediFier should use when identifying your films by Title.";
prop.DefaultValue = Settings.PrimaryFilmTitleMatchingEngine;
prop.DataType = "string";
twochoices[0] = "TMDb";
twochoices[1] = "IMDb";
prop.Choices = twochoices;
prop.CanTypeChoices = false;
return true;
}
#endregion
#region IMDb Title matching engines priority
if (index == counter++)
{
//set the internal name
prop.Name = "PrimaryImdbFilmTitleMatchingEngineProp";
//set name shown to user
prop.Caption = "Primary IMDb Title matching engine: ";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
prop.GroupName = "VideoIdentifier";
//set the tool tip
prop.HelpText = "Please choose the priority of IMDb Title matching engines MediaFairy should use when identifying your films by Title." + Environment.NewLine +
"While the internal engine allows you to choose from multiple IMDb results," + Environment.NewLine +
"the external (web-based) engine will always choose the best match automatically.";
prop.DefaultValue = Settings.PrimaryIMDbFilmTitleMatchingEngine;
prop.DataType = "string";
twochoices[0] = "Internal";
twochoices[1] = "External (web-based)";
prop.Choices = twochoices;
prop.CanTypeChoices = false;
return true;
}
#endregion
if (index == counter++)
{
//set the internal name
prop.Name = "AssistModeProp";
//set name shown to user
prop.Caption = "IMDb film title matching assistance: ";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
prop.GroupName = "VideoIdentifier";
//set the tool tip
prop.HelpText = "Please choose the Film Matching Assist mode." + Environment.NewLine +
"This setting defines in which case you 'll be asked to select the correct film from a list of possible IMDb matches." + Environment.NewLine +
"Leave this setting to it's default for unsupervised operation (but with a small probability for incorrect matches when identifying by fingerprint is not possible) ?";
prop.DefaultValue = Settings.AssistType;
prop.DataType = "string";
fourchoices[0] = "When no exact match found";
fourchoices[1] = "Always";
fourchoices[2] = "Never";
fourchoices[3] = "Skip identifying unknown films";
prop.Choices = fourchoices;
prop.CanTypeChoices = false;
return true;
}
if (index == counter++)
{
//set the internal name
prop.Name = "WantHashingProp";
//set name shown to user
prop.GroupCaption = " Video Identifier Settings";
prop.GroupName = "VideoIdentifier";
prop.Caption = "Enable video fingerprint identifier? ";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
//set the tool tip
prop.HelpText = "Video fingerprint identifying is the method MediaFairy mainly uses in order to identify your films." + Environment.NewLine +
"The Fingerprint Identifying mechanism computes a unique number (fingerprint) for each of your films" + Environment.NewLine +
"and then uses the available databases to match this fingerprint with the film's unique id (IMDb ID)." + Environment.NewLine +
"When a match is not found using this fingerprint, by default MediaFairy will switch to the IMDb Title matching method below. ";
prop.DefaultValue = Settings.EnableVideoHasher;
prop.DataType = "bool";
prop.Dependencies = "False:HIDE PrimaryVideoFingerprintMatchingSourceProp" +
";True:SHOW PrimaryVideoFingerprintMatchingSourceProp";
return true;
}
if (index == counter++)
{
//set the internal name
prop.Name = "EnableNfoParsingProp";
//set name shown to user
prop.Caption = "Enable .nfo file parser";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
prop.GroupName = "VideoIdentifier";
//set the tool tip
prop.HelpText = "When this option is enabled, the video identifier will scan the film's folder for an .nfo file" + Environment.NewLine +
"which contains useful information about the film for instant and exact film identification. ";
prop.DefaultValue = Settings.EnableNfoParsing;
prop.DataType = "bool";
return true;
}
#region IMDb Title matcher
if (index == counter++)
{
//set the internal name
prop.Name = "WantMatchingProp";
//set name shown to user
prop.Caption = "Enable IMDb Title matcher";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
prop.GroupName = "VideoIdentifier";
//set the tool tip
prop.HelpText = "If the video fingerprinting mechanism is disabled or unable to identify a film by it's fingerprint," + Environment.NewLine +
"MediaFairy can resort to recognize the film using this method." + Environment.NewLine +
"The Title matching method will use the film information" + Environment.NewLine +
"already provided in 'name', 'Title' and 'Year' library fields" + Environment.NewLine +
"to recognize a film and download it's related information. ";
prop.DefaultValue = Settings.FilmTitleMatchingEnginesAreEnabled;
prop.DataType = "bool";
prop.Dependencies = "False:HIDE PrimaryImdbFilmTitleMatchingEngineProp,AssistModeProp,DurationMatchingProp" +
";True:SHOW PrimaryImdbFilmTitleMatchingEngineProp,AssistModeProp,DurationMatchingProp";
return true;
}
if (index == counter++)
{
//set the internal name
prop.Name = "DurationMatchingProp";
//set name shown to user
prop.Caption = "Try to match video duration first";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
prop.GroupName = "VideoIdentifier";
//set the tool tip
prop.HelpText = " The video duration matching mechanism will assist the video title matcher in recognizing the correct film result from the returned IMDb results," + Environment.NewLine +
"by comparing the IMDb result's duration value to the local video file's actual duration. A succesfull video duration matching will result in a perfect match. ";
prop.DefaultValue = Settings.EnableDurationMatching;
prop.DataType = "bool";
return true;
}
#endregion
#endregion
#region Film Updaters
#region Film Updater
if (index == counter++)
{
//set the internal name
prop.Name = "SimpleWantFilmDetailsProp";
prop.GroupName = "FilmUpdater";
//set name shown to user
prop.Caption = "Identify and import film information";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
prop.GroupCaption = " Film Updater";
//set the tool tip
prop.HelpText = "";
prop.DefaultValue = Settings.SimpleFilmDetailsDownloaderIsEnabled;
prop.DataType = "bool";
prop.Dependencies = "False:HIDEGROUP "
+
"FilmDetails"
+
";True:SHOWGROUP "
+
"FilmDetails"
+
";False:HIDE "
+
"DownloadPosterChoice,"
+
"DownloadBackdropsChoice,"
+
"HashUploadingProp"
+
";True:SHOW "
+
"DownloadPosterChoice,"
+
"DownloadBackdropsChoice,"
+
"HashUploadingProp";
return true;
}
if (index == counter++)
{
//set the internal name
prop.Name = "DownloadPosterChoice";
prop.GroupName = "FilmUpdater";
//set name shown to user
prop.Caption = "Also download cover images ";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
//Prop.GroupCaption = " Film Updater";
//set the tool tip
prop.HelpText = "Do you want MediaFairy to download cover images for your films?";
prop.DefaultValue = Settings.FilmCoverArtDownloaderIsEnabled;
prop.DataType = "bool";
prop.Dependencies = "False:HIDEGROUP FilmCovers" +
";True:SHOWGROUP FilmCovers";
return true;
}
if (index == counter++)
{
//set the internal name
prop.Name = "DownloadBackdropsChoice";
prop.GroupName = "FilmUpdater";
//set name shown to user
prop.Caption = "Also download backdrop images ";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
//Prop.GroupCaption = " Film Updater";
//set the tool tip
prop.HelpText = "Do you want MediaFairy to download high-resolution backdrop images for your films?";
prop.DefaultValue = Settings.FilmBackdropArtDownloaderIsEnabled;
prop.DataType = "bool";
prop.Dependencies = "False:HIDEGROUP FilmBackdrops" +
";True:SHOWGROUP FilmBackdrops";
return true;
}
#endregion
if (FilmDetailsPropertiesGetter
.GetFilmDetailsProperties
(this, index, prop, twochoices,
ref counter))
return true;
#region Film Covers
if (index == counter++)
{
//set the internal name
prop.Name = "TMDbPostersEnabledProp";
//set name shown to user
prop.Caption = "Download film coverart from TheMovieDb.org";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
//set the tool tip
prop.GroupCaption = " Film Coverart Settings";
prop.GroupName = "FilmCovers";
prop.HelpText = "Should TheMovieDb.org be searched for film posters?";
prop.DefaultValue = Settings.TMDbPostersEnabled;
prop.DataType = "bool";
return true;
}
if (index == counter++)
{
//set the internal name
prop.Name = "ImpAwardsPostersEnabledProp";
//set name shown to user
prop.Caption = "Download film coverart from ImpAwards.com";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
//set the tool tip
prop.GroupName = "FilmCovers";
prop.HelpText = "Should ImpAwards.com be searched for film coverart?";
prop.DefaultValue = Settings.ImpAwardsPostersEnabled;
prop.DataType = "bool";
return true;
}
if (index == counter++)
{
//set the internal name
prop.Name = "IMDbPostersEnabledProp";
//set name shown to user
prop.Caption = "Download film posters from IMDb.com";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
//set the tool tip
prop.GroupName = "FilmCovers";
prop.HelpText = "Should IMDb.com be searched for film posters?";
prop.DefaultValue = Settings.IMDbPostersEnabled;
prop.DataType = "bool";
return true;
}
if (index == counter++)
{
//set the internal name
prop.Name = "PrimaryPosterSourceChoice";
//set name shown to user
prop.Caption = "Primary coverart source:";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
//set the tool tip
prop.GroupName = "FilmCovers";
prop.HelpText = "From which source do you want MediaFairy to search for film coverart first?";
prop.DefaultValue = Settings.PosterPrimarySource;
prop.DataType = "string";
prop.CanTypeChoices = false;
threechoices[0] = "TheMovieDatabase";
threechoices[1] = "ImpAwards";
threechoices[2] = "IMDb";
prop.Choices = threechoices;
return true;
}
if (index == counter++)
{
//set the internal name
prop.Name = "PosterSizeChoice";
//set name shown to user
prop.Caption = "Preferred coverart size:";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
prop.GroupName = "FilmCovers";
//set the tool tip
prop.HelpText = "When downloading film coverart from TMDB, which poster size do you prefer?";
prop.DefaultValue = Settings.PosterSize;
prop.DataType = "string";
fourchoices[0] = "Extra Large";
fourchoices[1] = "Large";
fourchoices[2] = "Medium";
fourchoices[3] = "Small";
prop.CanTypeChoices = false;
prop.Choices = fourchoices;
return true;
}
#region Image Resizer
if (index == counter++)
{
//set the internal name
prop.Name = "ResizeFilmPostersProp";
//set name shown to user
prop.Caption = "Automatically resize film coverart images";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
//set the tool tip
prop.GroupName = "FilmCovers";
prop.HelpText = "Enable this option if you want the importer to automatically resize film coverart images after download." + Environment.NewLine +
"The aspect ratio of the original image will be mantained.";
prop.DefaultValue = Settings.ResizeFilmPosters;
prop.DataType = "bool";
prop.Dependencies = "False:HIDE FilmPosterWidthProp,FilmPosterHeightProp" +
";True:SHOW FilmPosterWidthProp,FilmPosterHeightProp";
return true;
}
if (index == counter++)
{
//set the internal name
prop.Name = "FilmPosterWidthProp";
//set name shown to user
prop.Caption = "Desired coverart width: ";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
//set the tool tip
prop.GroupName = "FilmCovers";
prop.HelpText = "Please set the desired pixel width of the resized coverart image. Default is 800.";
prop.DefaultValue = Settings.FilmPosterWidth;
prop.DataType = "int";
return true;
}
if (index == counter++)
{
//set the internal name
prop.Name = "FilmPosterHeightProp";
//set name shown to user
prop.Caption = "Desired coverart height: ";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
//set the tool tip
prop.GroupName = "FilmCovers";
prop.HelpText = "Please set the desired pixel height of the resized coverart image. Default is 1000.";
prop.DefaultValue = Settings.FilmPosterHeight;
prop.DataType = "int";
return true;
}
#endregion
//if (Index == counter++)
//{
// //set the internal name
// Prop.Name = "WhereToSavePosterProp";
// //set name shown to user
// Prop.Caption = "Where to store posters?";
// Prop.Caption = TranslationProvider.Translate(Prop.Caption, this);
// Prop.GroupName = "FilmCovers";
// //set the tool tip
// Prop.HelpText = "Do you want the poster/cover image for each movie to be saved in the movie's folder or to a specific folder of your choice?";
// Prop.DefaultValue = Importer.WhereToSavePoster;
// Prop.DataType = "string";
// twochoices[0] = "in the movie's folder";
// twochoices[1] = "in the folder i specify below";
// Prop.CanTypeChoices = false;
// Prop.Choices = twochoices;
// Prop.IsMandatory = false;
// Prop.Dependencies = "in the movie's folder:HIDE PosterFolderProp" +
// ";in the folder i specify below:SHOW PosterFolderProp";
// return true;
//}
//if (Index == counter++)
//{
// //set the internal name
// Prop.Name = "PosterFolderProp";
// //set name shown to user
// Prop.Caption = "Posters folder: ";
// Prop.Caption = TranslationProvider.Translate(Prop.Caption, this);
// Prop.GroupName = "FilmCovers";
// //set the tool tip
// Prop.HelpText = @"Please specify the folder in which you want downloaded film covers to be saved. (Only applicabe is option above is set to 'in the folder i specify below') ";
// Prop.DefaultValue = Importer.PosterFolder;
// Prop.DataType = "folder";
// Prop.CanTypeChoices = false;
// return true;
//}
//if (Index == counter++)
//{
// //set the internal name
// Prop.Name = "PosterNamingChoice";
// //set name shown to user
// Prop.Caption = "Poster naming convention: ";
// Prop.Caption = TranslationProvider.Translate(Prop.Caption, this);
// Prop.GroupName = "FilmCovers";
// //set the tool tip
// Prop.HelpText = "How would you like your movies' posters image files to be named ?";
// Prop.DefaultValue = Settings.PosterNamingMethod;
// Prop.DataType = "string";
// Prop.CanTypeChoices = false;
// if (Settings.WhereToSavePoster == "in the movie's folder")
// {
// threechoices[0] = "folder.jpg";
// threechoices[1] = "iMDbID";
// threechoices[2] = "video filename";
// Prop.Choices = threechoices;
// }
// else
// {
// twochoices[0] = "iMDbID";
// twochoices[1] = "video filename";
// Prop.Choices = twochoices;
// }
// if (Importer.WhereToSavePoster != "in the movie's folder")
// {
// if (Importer.PosterNamingMethod == "folder.jpg")
// Importer.PosterNamingMethod = "iMDbID";
// }
// Prop.DefaultValue = Importer.PosterNamingMethod;
// return true;
//}
//if (Index == counter++)
//{
// //set the internal name
// Prop.Name = "OverwritePosterChoice";
// //set name shown to user
// Prop.Caption = "Overwrite existing Posters?";
// Prop.Caption = TranslationProvider.Translate(Prop.Caption, this);
// Prop.GroupName = "FilmCovers";
// //set the tool tip
// Prop.HelpText = "If a poster already exists in your specified location, should MediaFairy to download a new poster and overwrite the old one?";
// Prop.DefaultValue = Importer.OverwriteExistingPosters;
// Prop.DataType = "bool";
// return true;
//}
#endregion
#region Film Backdrops
#region Image Resizer
if (index == counter++)
{
//set the internal name
prop.Name = "ResizeFilmBackdropsProp";
//set name shown to user
prop.Caption = "Automatically resize film fanart images";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
prop.GroupCaption = " Film Fanart Settings";
//set the tool tip
prop.GroupName = "FilmBackdrops";
prop.HelpText = "Enable this option if you want the importer to automatically resize film fanart images after download." + Environment.NewLine +
"The aspect ratio of the original image will be mantained.";
prop.DefaultValue = Settings.ResizeFilmBackdrops;
prop.DataType = "bool";
prop.Dependencies = "False:HIDE FilmBackdropWidthProp,FilmBackdropHeightProp" +
";True:SHOW FilmBackdropWidthProp,FilmBackdropHeightProp";
return true;
}
if (index == counter++)
{
//set the internal name
prop.Name = "FilmBackdropWidthProp";
//set name shown to user
prop.Caption = "Desired fanart width: ";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
//set the tool tip
prop.GroupName = "FilmBackdrops";
prop.HelpText = "Please set the desired pixel width of the resized fanart image. Default is 1360.";
prop.DefaultValue = Settings.FilmBackdropWidth;
prop.DataType = "int";
return true;
}
if (index == counter++)
{
//set the internal name
prop.Name = "FilmBackdropHeightProp";
//set name shown to user
prop.Caption = "Desired fanart height: ";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
//set the tool tip
prop.GroupName = "FilmBackdrops";
prop.HelpText = "Please set the desired pixel height of the resized fanart image. Default is 768.";
prop.DefaultValue = Settings.FilmBackdropHeight;
prop.DataType = "int";
return true;
}
#endregion
//if (FilmBackdropsLocationPropertiesGetter
// .GetFilmBackdropsLocationProperties
// (this, index, prop, twochoices,
// ref counter))
// return true;
#endregion
//if (FilmReleasesUpdaterProperties
// .GetFilmReleasesUpdaterProperties
// (this, index, prop, ref counter))
// return true;
#endregion
if (index == counter++)
{
//set the internal name
prop.Name = "UpdateTvShowsProp";
prop.GroupName = "MediaUpdaters";
//set name shown to user
prop.Caption = "Update Tv Series sections? ";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
//Prop.GroupCaption = " Media Updaters ";
//set the tool tip
prop.HelpText = "Do you want MediaFairy to work with the Tv Series in your Tv Shows library?";
prop.DefaultValue = Settings.EnableTvShowsSectionUpdater;
prop.DataType = "bool";
prop.Dependencies =
"False:HIDEGROUP "
+
"TvUpdater"
+
";True:SHOWGROUP "
+
"TvUpdater";
return true;
}
#region TV Updaters
#region TV Updater
if (index == counter++)
{
//set the internal name
prop.Name = "WantEpisodeDetailsProp";
prop.GroupName = "TvUpdater";
//set name shown to user
prop.Caption = "Download episode details";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
prop.GroupCaption = " TV Updater";
//set the tool tip
prop.HelpText = " Would you like the plugin to download online details from TVdb for each episode in your TV library? ";
prop.DefaultValue = Settings.WantEpisodeDetails;
prop.DataType = "bool";
return true;
}
if (index == counter++)
{
//set the internal name
prop.Name = "WantEpisodeThumbnailsProp";
prop.GroupName = "TvUpdater";
//set name shown to user
prop.Caption = "Download episode thumbnails";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
//Prop.GroupCaption = " TV Updater";
//set the tool tip
prop.HelpText = " Would you like the plugin to download thumbnail images for each episode in your TV library? ";
prop.DefaultValue = Settings.WantEpisodeThumbnails;
prop.DataType = "bool";
return true;
}
if (index == counter++)
{
//set the internal name
prop.Name = "WantSeriesBannersProp";
prop.GroupName = "TvUpdater";
//set name shown to user
prop.Caption = "Download series banners";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
//Prop.GroupCaption = " TV Updater";
//set the tool tip
prop.HelpText = " Would you like the plugin to download banner images for the series in your TV library? ";
prop.DefaultValue = Settings.WantSeriesBanners;
prop.DataType = "bool";
//Prop.Dependencies = "True:SHOWGROUP TvImages";
return true;
}
if (index == counter++)
{
//set the internal name
prop.Name = "WantSeriesBackdropsProp";
prop.GroupName = "TvUpdater";
//set name shown to user
prop.Caption = "Download series fanart images";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
//Prop.GroupCaption = " TV Updater";
//set the tool tip
prop.HelpText = " Would you like the plugin to download high resolution fanart images for the series in your TV library? ";
prop.DefaultValue = Settings.WantSeriesBackdrops;
prop.DataType = "bool";
//Prop.Dependencies = "True:SHOWGROUP TvImages";
return true;
}
if (index == counter++)
{
//set the internal name
prop.Name = "WantSeasonImagesProp";
prop.GroupName = "TvUpdater";
//set name shown to user
prop.Caption = "Download season covers";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
//Prop.GroupCaption = " TV Updater";
//set the tool tip
prop.HelpText = " Would you like the plugin to download cover images for each season of the tv series in your TV library? ";
prop.DefaultValue = Settings.WantSeasonImages;
prop.DataType = "bool";
//Prop.Dependencies = "True:SHOWGROUP TvImages";
return true;
}
#endregion
#region TV Series Images
//if (Index == counter++)
//{
// Prop.GroupCaption = " Tv Series Images Settings";
// Prop.GroupName = "TvImages";
// //set the internal name
// Prop.Name = "SeriesBannersFolderProp";
// //set name shown to user
// Prop.Caption = "Series Banners location: ";
// Prop.Caption = TranslationProvider.Translate(Prop.Caption, this);
// //set the tool tip
// Prop.HelpText = @"Please specify the folder in which you want downloaded banners for TV series to be saved. ";
// Prop.DefaultValue = Importer.SeriesBannersFolder;
// Prop.DataType = "folder";
// Prop.CanTypeChoices = false;
// return true;
//}
//if (Index == counter++)
//{
// Prop.GroupName = "TvImages";
// //set the internal name
// Prop.Name = "SeriesFanartFolderProp";
// //set name shown to user
// Prop.Caption = "Series fanart images location: ";
// Prop.Caption = TranslationProvider.Translate(Prop.Caption, this);
// //set the tool tip
// Prop.HelpText = @"Please specify the folder in which you want downloaded fanart images for TV series to be stored. ";
// Prop.DefaultValue = Importer.SeriesFanartFolder;
// Prop.DataType = "folder";
// Prop.CanTypeChoices = false;
// return true;
//}
//if (Index == counter++)
//{
// Prop.GroupName = "TvImages";
// //set the internal name
// Prop.Name = "SeasonImagesFolderProp";
// //set name shown to user
// Prop.Caption = "Season images location: ";
// Prop.Caption = TranslationProvider.Translate(Prop.Caption, this);
// //set the tool tip
// Prop.HelpText = @"Please specify the folder in which you want downloaded banners for TV series to be saved. ";
// Prop.DefaultValue = Importer.SeasonImagesFolder;
// Prop.DataType = "folder";
// Prop.CanTypeChoices = false;
// return true;
//}
#endregion
#endregion
if (index == counter++)
{
//set the internal name
prop.Name = "UpdateMusicProp";
prop.GroupName = "MediaUpdaters";
//set name shown to user
prop.Caption = "Update Music section? ";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
//Prop.GroupCaption = " Media Updaters ";
//set the tool tip
prop.HelpText = "Do you want MediaFairy to work with your Music library";
prop.DefaultValue = Settings.EnableMusicSectionUpdater;
prop.DataType = "bool";
prop.Dependencies = "False:HIDEGROUP MusicUpdater,AlbumCovers" +
";True:SHOWGROUP MusicUpdater";
return true;
}
#region Music Updater
if (index == counter++)
{
//set the internal name
prop.Name = "WantAudioTagsProp";
prop.GroupName = "MusicUpdater";
//set name shown to user
prop.Caption = "Import track information from audio file";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
prop.GroupCaption = " Music Updater";
//set the tool tip
prop.HelpText = "MediaFairy has the capability to extract the metadata contained in your audio files" + Environment.NewLine +
"and import this information into your music library. Would you like to enable this feature?";
prop.DefaultValue = Settings.WantAudioTags;
prop.DataType = "bool";
prop.Dependencies = "False:HIDE WantAlbumCoversProp" +
";True:SHOW WantAlbumCoversProp";
return true;
}
//if (index == counter++)
//{
// //set the internal name
// prop.Name = "WantMusicDNSProp";
// prop.GroupName = "MusicUpdater";
// //set name shown to user
// prop.Caption = "Also use online audio identifier ";
// prop.Caption = TranslationProvider.Translate(prop.Caption, this);
// //Prop.GroupCaption = " Music Updater";
// //set the tool tip
// prop.HelpText = "MediaFairy contains an automated song recognition engine" + Environment.NewLine +
// "which uses the audio fingerprinting technology by MusicDNS" + Environment.NewLine +
// "to uniquely identify your audio tracks by their acoustic properties." + Environment.NewLine +
// "Would you like this feature enabled?" + Environment.NewLine +
// "(It is recommended that the option 'import track information from audio file' is also enabled) ";
// prop.DefaultValue = Settings.MusicDNSAudioTrackIdentifierIsEnabled;
// prop.DataType = "bool";
// prop.Dependencies = "False:HIDE SaveMetadataToAudioTagsProp" +
// ";True:SHOW SaveMetadataToAudioTagsProp";
// return true;
//}
//if (index == counter++)
//{
// //set the internal name
// prop.Name = "SaveMetadataToAudioTagsProp";
// //set name shown to user
// prop.Caption = "Save meta-data in audio file?";
// prop.Caption = TranslationProvider.Translate(prop.Caption, this);
// //set the tool tip
// prop.GroupName = "MusicUpdater";
// prop.HelpText = "After succesfull recognition " +
// "by audio fingerprint, " +
// "the newly acquired metadata" + Environment.NewLine +
// "can be imported into the tags of the audio file," +
// " and not only in the Meedio library.";
// prop.DefaultValue = Settings.SaveMetadataToAudioTags;
// prop.DataType = "bool";
// return true;
//}
if (index == counter++)
{
//set the internal name
prop.Name = "WantAlbumCoversProp";
prop.GroupName = "MusicUpdater";
//set name shown to user
prop.Caption = "Also download album covers";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
//Prop.GroupCaption = " Music Updater";
//set the tool tip
prop.HelpText = "Do you want MediaFairy to download album cover images for your music albums?";
prop.DefaultValue = Settings.WantAlbumCovers;
prop.DataType = "bool";
prop.Dependencies = "False:HIDEGROUP AlbumCovers" +
";True:SHOWGROUP AlbumCovers";
return true;
}
//if (index == counter++)
//{
// //set the internal name
// prop.Name = "WantArtistBackdropsProp";
// prop.GroupName = "MusicUpdater";
// //set name shown to user
// prop.Caption = "Also download artist fanart images";
// prop.Caption = TranslationProvider.Translate(prop.Caption, this);
// //Prop.GroupCaption = " Music Updater";
// //set the tool tip
// prop.HelpText = "Would you like to download backdrop images for artists?";
// prop.DefaultValue = Settings.ArtistBackdropsEnabled;
// prop.DataType = "bool";
// //Prop.Dependencies = "False:HIDE ArtistBackdropsLocationProp" +
// //";True:SHOW ArtistBackdropsLocationProp";
// return true;
//}
#endregion
#region Album Covers
//if (Index == counter++)
//{
// Prop.GroupName = "AlbumCovers";
// //set the internal name
// Prop.Name = "WhereToSaveAlbumCoverProp";
// //set name shown to user
// Prop.Caption = "Where to save album covers?";
// Prop.Caption = TranslationProvider.Translate(Prop.Caption, this);
// //set the tool tip
// Prop.GroupCaption = " Album Covers Settings";
// Prop.HelpText = "Do you want the poster/cover image for each album to be saved in the album's folder or in a specific folder of your choice?";
// Prop.DefaultValue = Importer.WhereToSaveAlbumCover;
// Prop.DataType = "string";
// twochoices[0] = "in the album's folder";
// twochoices[1] = "in the folder i specify below";
// Prop.CanTypeChoices = false;
// Prop.Choices = twochoices;
// Prop.IsMandatory = false;
// Prop.Dependencies = "in the album's folder:HIDE AlbumCoversFolderProp" +
// ";in the folder i specify below:SHOW AlbumCoversFolderProp";
// return true;
//}
//if (Index == counter++)
//{
// Prop.GroupName = "AlbumCovers";
// //set the internal name
// Prop.Name = "AlbumCoversFolderProp";
// //set name shown to user
// Prop.Caption = "Album covers folder: ";
// Prop.Caption = TranslationProvider.Translate(Prop.Caption, this);
// //set the tool tip
// Prop.HelpText = @"Please specify the folder in which you want downloaded album cover images to be saved. (Only applicabe if option above is set to 'Movie's folder') ";
// Prop.DefaultValue = Importer.AlbumCoverFolder;
// Prop.DataType = "folder";
// Prop.CanTypeChoices = false;
// return true;
//}
//if (Index == counter++)
//{
// //set the internal name
// Prop.Name = "AlbumCoverNamingChoice";
// //set name shown to user
// Prop.Caption = "Album covers naming convention: (tag mask) ";
// Prop.Caption = TranslationProvider.Translate(Prop.Caption, this);
// Prop.GroupName = "AlbumCovers";
// //set the tool tip
// Prop.HelpText = "Please enter here your desired album covers naming convention in a form of a tag mask." + Environment.NewLine + "For example, the default tag mask '<IMDbID>_backdrop' will store the backdrop image as the varialbe film's IMDb number followed by the '_backdrop' suffix ." + Environment.NewLine + "Please make sure that any text strings contained in '<>' refer to the names of existing tags of your Movies media section.";
// Prop.DefaultValue = Importer.AlbumCoversNamingMethod;
// Prop.DataType = "string";
// Prop.CanTypeChoices = true;
// return true;
//}
if (index == counter++)
{
prop.GroupName = "AlbumCovers";
//set the internal name
prop.Name = "EmbedAlbumCoverProp";
//set name shown to user
prop.Caption = "Also embed cover image in audio file";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
//set the tool tip
prop.HelpText = " Certain audio file-types like .mp3 and .wma are capable of storing (embeding) the album's cover image in the file itself. \r This eliminates the need of storing a seperate image file for every music album, thus makes the audio files self-contained and easily transportable. \r Do you want the plugin to embed cover images for imported audio files? ";
prop.DefaultValue = Settings.EmbedAlbumCover;
prop.DataType = "bool";
prop.CanTypeChoices = false;
return true;
}
//if (Index == counter++)
//{
// //set the internal name
// Prop.Name = "OverwriteAlbumCovers";
// //set name shown to user
// Prop.Caption = "Overwrite existing covers?";
// Prop.Caption = TranslationProvider.Translate(Prop.Caption, this);
// Prop.GroupName = "AlbumCovers";
// //set the tool tip
// Prop.HelpText = "If an album cover image already exists in your specified location, should MediaFairy download a new cover image and overwrite the existing one?";
// Prop.DefaultValue = Importer.OverwriteExistingAlbumCovers;
// Prop.DataType = "bool";
// return true;
//}
#endregion
if (MediaOrganizersPropertiesGetter
.GetMediaOrganizersProperties
(this, index, prop,
twochoices, ref counter))
return true;
//if (GeneralContentDownloaderProperties
// .GetGeneralContentDownloaderProperties
// (this, index, prop, ref counter))
// return true;
if (LibraryManagementPropertiesGetter
.GetLibraryManagementProperties
(this, index, prop, ref counter))
return true;
#endregion
//if (MediaArchiversPropertiesGetter
// .GetMediaArchiversProperties
// (this, index, prop,
// twochoices, ref counter))
// return true;
//if (LibrarySynchronizersPropertiesGetter
// .GetLibrarySynchronizersProperties
// (this, index, prop, ref counter))
// return true;
//if (ImportSequencerPropertiesGetter
// .GetImportSequencerProperties
// (this, index, prop, ref counter))
// return true;
#region Diagnostics Properties
if (index == counter++)
{
prop.GroupName = "Diagnostics";
//set the internal name
prop.Name = "ConnectionDiagnosticsProp";
//set name shown to user
prop.Caption = "Enable internet connection diagnostic? ";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
prop.GroupCaption = " Diagnostics";
//set the tool tip
prop.HelpText = "Should MediaFairy test for internet connection and online databases availability before attempting to download data?" + Environment.NewLine +
"This feature will help the importer recognize offline or problematic sources and avoid using them," + Environment.NewLine +
"preventing failed retries, minimizing delays and improving importing times in those situations.";
prop.DefaultValue = Settings.ConnectionDiagnosticsEnabled;
prop.DataType = "bool";
prop.Dependencies = "False:HIDE DisableSourcesProp" +
";True:SHOW DisableSourcesProp";
return true;
}
if (index == counter++)
{
prop.GroupName = "Diagnostics";
//set the internal name
prop.Name = "DisableSourcesProp";
//set name shown to user
prop.Caption = "Disable problematic sources? ";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
//set the tool tip
prop.HelpText = " Should unconnectable online sources be disabled for the rest of an importing session? ";
prop.DefaultValue = Settings.WantToDisableSources;
prop.DataType = "bool";
return true;
}
if (index == counter++)
{
prop.GroupName = "Diagnostics";
//set the internal name
prop.Name = "FileserverDiagnosticsProp";
//set name shown to user
prop.Caption = "Enable media server diagnostic? ";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
//set the tool tip
prop.HelpText = "Should MediaFairy check if your network disk is online and accessible before attempting to read or transfer any data?" + Environment.NewLine +
"This feature will prevent failed attempts to access network disks and improve importing times in those cases.";
prop.DefaultValue = Settings.WantFileserverDiagnostics;
prop.DataType = "bool";
return true;
}
#endregion
#region User Interface
if (index == counter++)
{
prop.GroupName = "UserInterface";
//set the internal name
prop.Name = "EnableUIProp";
//set name shown to user
prop.Caption = "Always prompt for images";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
prop.GroupCaption = " User Interface";
//set the tool tip
prop.HelpText = "The plugin's user interface gives users the option to preview and decide if images" + Environment.NewLine +
"(film coverart,fanart images and album covers) will be downloaded and which ones." + Environment.NewLine +
"If you want the plugin to always ask for your confirmation before downloading images, please enable this option.";
prop.DefaultValue = Settings.AlwaysPromptForImages;
prop.DataType = "bool";
return true;
}
if (index == counter++)
{
prop.GroupName = "UserInterface";
//set the internal name
prop.Name = "DebugLogProp";
//set name shown to user
prop.Caption = "Write debug log file";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
prop.GroupCaption = " User Interface";
//set the tool tip
prop.HelpText = "If enabled, MediaFairy will write a debug log containing" + Environment.NewLine +
"important information from the last importing session for debugging purposes.";
prop.DefaultValue = Settings.WriteDebugLog;
prop.DataType = "bool";
return true;
}
//if (Index == counter++)
//{
// //set the internal name
// Prop.Name = "LimitFilesToImportProp";
// //set name shown to user
// Prop.Caption = "How many media files to import in each run? ";
// //set the tool tip
// Prop.GroupCaption = " Interoperability";
// Prop.HelpText = "With this option, you can limit the number of new files MediaFairy imports into your library every time it runs. This setting is useful if you schedule the importer to run frequently and you want each importing proccess to complete quickly. Leave this setting to it's default setting (0) if you want MediaFairy to import all new media files it finds in your media root folders. ";
// Prop.DefaultValue = Importer.importing_limit;
// Prop.DataType = "int";
// return true;
//}
#endregion
}
catch (Exception e)
{
MessageBox.Show(e.ToString());
}
return false;
}
internal static bool GetMediaOrganizersProperties
(ImporterProperties importerProperties,
int index, OptionSettings prop,
IList<string> twochoices, ref int counter)
{
#region Enable / disable media organizers
if (index == counter++)
{
prop.GroupName = "AutoSorter";
//set the internal name
prop.Name = "MediaOrganizersProp";
//set name shown to user
prop.GroupCaption = " Media Organizers";
prop.Caption = "Enable Media Organizers ";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = "";
prop.DefaultValue = false;
prop.DataType = "bool";
prop.Dependencies =
"False:HIDE WantSortingFilmsProp,WantSortingTvShowsProp,WantSortingMusicProp,PromptBeforeMovingProp,SortingDestinationFilmsProp,SortingDestinationTvShowsProp,SortingDestinationMusicProp" +
";False:HIDEGROUP OrganizingStructures" +
";True:SHOW WantSortingFilmsProp,WantSortingTvShowsProp,WantSortingMusicProp,PromptBeforeMovingProp";
return true;
}
if (index == counter++)
{
prop.GroupName = "AutoSorter";
//set the internal name
prop.Name = "WantSortingFilmsProp";
//set name shown to user
//Prop.GroupCaption = " Media Organizer";
prop.Caption = "Automatically organize films ";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = "If this option is enabled, MediaFairy will automatically move or rename the films" +
Environment.NewLine +
"which it has identified, accroding to your specifications below." + Environment.NewLine +
"This feature will ensure a default and well organized structure for your movie files and their related data. ";
prop.DefaultValue = MeediFier.Settings.WantSortingFilms;
prop.DataType = "bool";
prop.Dependencies = "False:HIDE SortingDestinationFilmsProp" +
";True:SHOW SortingDestinationFilmsProp" +
";True:SHOWGROUP OrganizingStructures";
return true;
}
if (index == counter++)
{
prop.GroupName = "AutoSorter";
//set the internal name
prop.Name = "WantSortingTvShowsProp";
//set name shown to user
prop.Caption = "Automatically organize tv series ";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText =
"If this option is enabled, MediaFairy will automatically move or rename the video files of tv series" +
Environment.NewLine +
"it has already identified, accroding to your specifications below." + Environment.NewLine +
"This feature will ensure a default and well organized structure for your TV series and their related files. ";
prop.DefaultValue = MeediFier.Settings.WantSortingTvShows;
prop.DataType = "bool";
prop.Dependencies = "False:HIDE SortingDestinationTvShowsProp" +
";True:SHOW SortingDestinationTvShowsProp" +
";True:SHOWGROUP OrganizingStructures";
return true;
}
if (index == counter++)
{
prop.GroupName = "AutoSorter";
//set the internal name
prop.Name = "WantSortingMusicProp";
//set name shown to user
prop.Caption = "Automatically organize music";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = "If this option is enabled, MediaFairy will automatically move or rename the audio tracks" +
Environment.NewLine +
"it has already identified, accroding to your specifications below." + Environment.NewLine +
"This feature will ensure a default and well organized structure for your audio files and their related data. ";
prop.DefaultValue = MeediFier.Settings.WantSortingMusic;
prop.DataType = "bool";
prop.Dependencies = "False:HIDE SortingDestinationMusicProp" +
";True:SHOW SortingDestinationMusicProp" +
";True:SHOWGROUP OrganizingStructures";
return true;
}
if (index == counter++)
{
prop.GroupName = "AutoSorter";
//set the internal name
prop.Name = "PromptBeforeMovingProp";
//set name shown to user
prop.Caption = "Prompt me before any file operation";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = "If you enable this option, MediaFairy will ask for your approval before performing" +
Environment.NewLine +
"any renaming or moving operation on media files. This option exists mainly for debugging purposes. ";
prop.DefaultValue = MeediFier.Settings.PromptBeforeMoving;
prop.DataType = "bool";
return true;
}
#endregion
#region Destination Directories
if (index == counter++)
{
prop.GroupName = "AutoSorter";
//set the internal name
prop.Name = "SortingDestinationFilmsProp";
//set name shown to user
prop.Caption = "Destination directory for films: ";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = @"Please specify the destination directory in which you want your sorted films" +
Environment.NewLine +
"and their related files to be moved by MediaFairy." + Environment.NewLine +
"Tip: specify the folder where your films are already contained and a blank folder mask for a simple renaming.";
prop.DefaultValue = MeediFier.Settings.SortingDestinationFilms;
prop.DataType = "folder";
return true;
}
if (index == counter++)
{
prop.GroupName = "AutoSorter";
//set the internal name
prop.Name = "SortingDestinationTvShowsProp";
//set name shown to user
prop.Caption = "Destination directory for tv series: ";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = @"Please specify the destination directory in which you want your sorted TV series episodes" +
Environment.NewLine +
"and their related files to be moved by MediaFairy." + Environment.NewLine +
"Tip: specify the folder where your TV episodes are already contained and blank folder mask for a simple renaming.";
prop.DefaultValue = MeediFier.Settings.SortingDestinationTvShows;
prop.DataType = "folder";
return true;
}
if (index == counter++)
{
prop.GroupName = "AutoSorter";
//set the internal name
prop.Name = "SortingDestinationMusicProp";
//set name shown to user
prop.Caption = "Destination directory for music: ";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = @"Please specify the destination directory where you want your sorted music tracks" +
Environment.NewLine +
"and their related files to be moved by MediaFairy." + Environment.NewLine +
"Tip: specify the folder where your audio tracks are already contained and blank folder mask for a simple renaming.";
prop.DefaultValue = MeediFier.Settings.SortingDestinationMusic;
prop.DataType = "folder";
return true;
}
#endregion
#region Organizing Structures
if (index == counter++)
{
prop.GroupName = "OrganizingStructures";
//set the internal name
prop.Name = "DirectoryStructureProp";
//set name shown to user
prop.Caption = "Preferred directory structures: ";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = "What is the directory structure in which you want your media files to be organized?" +
Environment.NewLine +
"MediaFairy will use known information relevant to each media type" + Environment.NewLine +
"to give the appropriate naming to folders and media files, according to your selected Media Organizer operating mode:" +
Environment.NewLine +
"'Simple' mode will use the default directory structures for each media type," +
Environment.NewLine +
"while 'Advanced' lets you specify your own directory structure for each media type using a tag mask." +
Environment.NewLine +
"Please refer to the plugin's Wiki web page for more information on directory structures. ";
prop.DefaultValue = MeediFier.Settings.DirectoryStructure;
prop.DataType = "string";
twochoices[0] = "Simple- Default directory structures";
twochoices[1] = "Advanced- specify directory tag masks below";
prop.Choices = twochoices;
prop.CanTypeChoices = false;
prop.Dependencies =
"Simple- Default directory structures:HIDE DirectoryTagMaskFilmsProp,DirectoryTagMaskTvShowsProp,DirectoryTagMaskMusicProp" +
";Advanced- specify directory tag masks below:SHOW DirectoryTagMaskFilmsProp,DirectoryTagMaskTvShowsProp,DirectoryTagMaskMusicProp";
return true;
}
if (index == counter++)
{
prop.GroupName = "OrganizingStructures";
//set the internal name
prop.Name = "DirectoryTagMaskFilmsProp";
//set name shown to user
prop.Caption = "Folder tag mask for films? ";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = " Please type your desired folder structure in the form of a tag mask." + Environment.NewLine +
"For each additional directory level you want to be created based on the value of an item's specific tag," +
Environment.NewLine +
"include this folder name in < and > brackets." + Environment.NewLine +
"For example, if you wanted your directory structure to include a folder for Film Genres" +
Environment.NewLine +
"and below this level each movie to reside in it's own folder named after the film's name," +
Environment.NewLine +
@"you would use this tag mask: <Genre>\<Title> . ";
prop.DefaultValue = MeediFier.Settings.DirectoryTagMaskFilms;
prop.DataType = "string";
return true;
}
if (index == counter++)
{
prop.GroupName = "OrganizingStructures";
//set the internal name
prop.Name = "DirectoryTagMaskTvShowsProp";
//set name shown to user
prop.Caption = "Folder tag mask for tv shows? ";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText =
@" Please type your desired folder structure in the form of a tag mask. For each additional directory level you want to be created based on the value of an item's specific tag, include this folder name in < and > brackets. For example, if you wanted your directory structure to include a folder for Film Genres and below this level each movie to reside in it's own folder named after the film's name, you would use this tag mask: <Genre>\<Title> . ";
prop.DefaultValue = MeediFier.Settings.DirectoryTagMaskTvShows;
prop.DataType = "string";
return true;
}
if (index == counter++)
{
prop.GroupName = "OrganizingStructures";
//set the internal name
prop.Name = "DirectoryTagMaskMusicProp";
//set name shown to user
prop.Caption = "Folder tag mask for music? ";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText =
@" Please type your desired folder structure in the form of a tag mask. For each additional directory level you want to be created based on the value of an item's specific tag, include this folder name in < and > brackets. For example, if you wanted your directory structure to include a folder for Film Genres and below this level each movie to reside in it's own folder named after the film's name, you would use this tag mask: <Genre>\<Title> . ";
prop.DefaultValue = MeediFier.Settings.DirectoryTagMaskMusic;
prop.DataType = "string";
return true;
}
#endregion
return false;
}
internal static bool GetGeneralContentDownloaderProperties
(ImporterProperties importerProperties,
int index, OptionSettings prop, ref int counter)
{
if (index == counter++)
{
prop.GroupName = "OnlineMediaDownloader";
//set the internal name
prop.Name = "DownloadOnlineContentProp";
prop.GroupCaption = " Online Media Downloader";
//set name shown to user
prop.Caption = "Download online files ";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = "MediaFairy can automatically download any online media file (from the web or ftp address)" +
Environment.NewLine +
"which is contained in the field you specify in the 'Online content library field' option below, and save it to the folder you specify." +
Environment.NewLine +
"Please refer to the plugin's documentation for more information and usage paradigms.";
prop.DefaultValue = Settings.DownloadOnlineContent;
prop.DataType = "bool";
prop.Dependencies = "False:HIDE OnlineContentFieldProp,DownloadFolderProp" +
";True:SHOW OnlineContentFieldProp,DownloadFolderProp";
return true;
}
if (index == counter++)
{
prop.GroupName = "OnlineMediaDownloader";
//set the internal name
prop.Name = "OnlineContentFieldProp";
//set name shown to user
prop.Caption = "Online media library fields: ";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText =
" Please specify here the library fields (Tags) in which the online files you desire to store locally are contained." +
Environment.NewLine +
"MediaFairy will download the online files to which the links contained in these tags are referring, and replace them with the disk paths of the local files those links were downloaded to." +
Environment.NewLine +
"Please input those tag names by either clicking the '...' button and typing a tag name *or* by typing the tag names directly in the input box, seperating with a comma (,)." +
Environment.NewLine +
"MediaFairy will search for those tags in all currently supported media libraries and save the online files they contain in the local locations you specify below. ";
prop.DefaultValue = Settings.OnlineContentFields;
prop.DataType = "stringlist";
return true;
}
if (index == counter++)
{
prop.GroupName = "OnlineMediaDownloader";
//set the internal name
prop.Name = "DownloadFolderProp";
//set name shown to user
prop.Caption = "Save online media in: ";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = @"Please specify the folder in which you want downloaded online content to be saved. ";
prop.DefaultValue = Settings.DownloadFolder;
prop.DataType = "folder";
return true;
}
return false;
}
internal static bool GetLibrarySynchronizersProperties
(ImporterProperties importerProperties,
int index, OptionSettings prop, ref int counter)
{
if (index == counter++)
{
prop.GroupName = "LibraryBackup";
//set the internal name
prop.Name = "LibraryBackupProp";
//set name shown to user
prop.GroupCaption = " Library Backup & Restore";
prop.Caption = "Enable Library Backup and Restore";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = "";
prop.DefaultValue = false;
prop.DataType = "bool";
prop.Dependencies =
"True:SHOW BackupMoviesSectionProp,BackupTvSeriesSectionsProp,BackupMusicSectionProp,RestoreSectionsProp,XmlBackupDirectoryProp" +
";False:HIDE BackupMoviesSectionProp,BackupTvSeriesSectionsProp,BackupMusicSectionProp,RestoreSectionsProp,XmlBackupDirectoryProp";
return true;
}
if (index == counter++)
{
prop.GroupName = "LibraryBackup";
//set the internal name
prop.Name = "BackupMoviesSectionProp";
//set name shown to user
prop.Caption = "Backup Movies Section";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = "";
prop.DefaultValue = MediaFairy.Settings.EnableXmlBackupFilms;
prop.DataType = "bool";
return true;
}
if (index == counter++)
{
prop.GroupName = "LibraryBackup";
//set the internal name
prop.Name = "BackupTvSeriesSectionsProp";
//set name shown to user
prop.Caption = "Backup TV Series Sections";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = "";
prop.DefaultValue = MediaFairy.Settings.EnableXmlBackupTvSeries;
prop.DataType = "bool";
return true;
}
if (index == counter++)
{
prop.GroupName = "LibraryBackup";
//set the internal name
prop.Name = "BackupMusicSectionProp";
//set name shown to user
prop.Caption = "Backup Music Section";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = "";
prop.DefaultValue = MediaFairy.Settings.EnableXmlBackupMusic;
prop.DataType = "bool";
return true;
}
if (index == counter++)
{
prop.GroupName = "LibraryBackup";
//set the internal name
prop.Name = "RestoreSectionsProp";
//set name shown to user
prop.Caption = "Restore Sections from backup";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = "";
prop.DefaultValue = MediaFairy.Settings.EnableXmlRestore;
prop.DataType = "bool";
return true;
}
if (index == counter++)
{
prop.GroupName = "LibraryBackup";
//set the internal name
prop.Name = "XmlBackupDirectoryProp";
//set name shown to user
prop.Caption = "XML backups directory";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = "";
prop.DefaultValue = MediaFairy.Settings.XmlBackupsDirectory;
prop.DataType = "folder";
return true;
}
return false;
}
public void Init()
{
opts = new UserSettings(new MemorySettingsStorage()).Options;
}
/// <param name='operations'>
/// Reference to the Rg.ClientApp.IProfile.
/// </param>
/// <param name='setting'>
/// Required.
/// </param>
/// <param name='cancellationToken'>
/// Cancellation token.
/// </param>
public static async Task <object> PostMentionPushNotificationsBySettingAsync(this IProfile operations, OptionSettings setting, CancellationToken cancellationToken = default(System.Threading.CancellationToken))
{
Microsoft.Rest.HttpOperationResponse <object> result = await operations.PostMentionPushNotificationsBySettingWithOperationResponseAsync(setting, cancellationToken).ConfigureAwait(false);
return(result.Body);
}
internal static bool GetPropertyForFileInclusion(int index, ref int i, OptionSettings prop)
{
if (index == i++)
{
prop.Name = "IncludeFileMasks";
prop.Caption = "File masks to include";
prop.HelpText = "Enter any number of file masks separated by semicolons" + Environment.NewLine +
"For example: \"*.avi;*.bmp\" (without the quotes)" + Environment.NewLine +
"If left blank, all files will be included (same as \"*.*\")" + Environment.NewLine +
"(The files of course need to match the other criteria.)";
prop.DataType = "string";
prop.GroupCaption = "File inclusion/exclusion rules";
prop.GroupName = "FileInEx";
prop.CanTypeChoices = true;
prop.Choices2[ImporterPropertiesCore
.FileImporterProperties.VideoExtensions]
= "Video extensions".Translate();
prop.Choices2[ImporterPropertiesCore
.FileImporterProperties.AudioExtensions]
= "Audio extensions".Translate();
prop.Choices2[ImporterPropertiesCore
.FileImporterProperties.TextExtensions]
= "Text extensions".Translate();
prop.Choices2[ImporterPropertiesCore
.FileImporterProperties.ImageExtensions]
= "Image extensions".Translate();
prop.DefaultValue = String.Empty;
return true;
}
if (index == i++)
{
prop.Name = "ExcludeFileMasks";
prop.Caption = "File masks to exclude";
prop.HelpText =
"Enter any number of masks separated by semicolons. If left blank, no files will be excluded." +
Environment.NewLine + "For example: \"*.avi;*.ogm\" (without the quotes)" + Environment.NewLine +
"The mask is prefixed internally with the files's rootfolder for you." + Environment.NewLine +
"So the above example would exclude all the avi and ogm files in the rootfolder, " +
Environment.NewLine + "but it will not exclude them in a any subfolders." + Environment.NewLine +
"You have to match the subfolder in the mask if you want to exclude files in a subfolder." +
Environment.NewLine +
"For example: \"trailer\\*.*\" (without the quotes) will exclude all files in the trailer subfolder.";
prop.DataType = "string";
prop.GroupName = "FileInEx";
prop.DefaultValue = String.Empty;
return true;
}
if (index == i++)
{
prop.Name = "IncludeHiddenFiles";
prop.Caption = "Import hidden files";
prop.HelpText = "If set hidden files will be imported";
prop.DataType = "bool";
prop.DefaultValue = false;
prop.GroupName = "FileInEx";
return true;
}
if (index == i++)
{
prop.Name = "MinFileSize";
prop.Caption = "Minimum filesize (in KB)";
prop.HelpText = "Only files at least the size specified (in KB) get imported";
prop.DataType = "int";
prop.DefaultValue = 0;
prop.GroupName = "FileInEx";
return true;
}
/*
if(index == i++)
{
prop.Name = "FollowShortcuts";
prop.Caption = "Follow shortcuts";
prop.HelpText = "If set, it will use the file targeted by the shortcut";
prop.DataType = "bool";
prop.DefaultValue = false;
prop.GroupName = "FileInEx";
return true;
}
*/
if (index == i++)
{
prop.Name = "ExcludeUnmatchedFiles";
prop.Caption = "Exclude files not matched";
prop.HelpText =
"When checked files that couldn't be matched with the tag masks will not be imported." +
Environment.NewLine + "This way you can prevent having invalid items in your library." +
Environment.NewLine +
"All the files not imported will be listed in the log. (if 'Debug'set to INFO or higher level)";
prop.DataType = "bool";
prop.DefaultValue = true;
prop.GroupName = "FileInEx";
return true;
}
return false;
}
internal static bool GetMediaArchiversProperties
(ImporterProperties importerProperties,
int index, OptionSettings prop,
IList<string> twochoices, ref int counter)
{
if (index == counter++)
{
prop.GroupName = "MediaArchiver";
//set the internal name
prop.Name = "MediaArchiversProp";
//set name shown to user
prop.GroupCaption = " Media Archivers (reserved for future version)";
prop.Caption = "Enable Media Archivers";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = "";
prop.DefaultValue = false;
prop.DataType = "bool";
prop.Dependencies = "True:SHOW FilmArchiverProp" +
";False:HIDE FilmArchiverProp,ArchiveWatchedFilmsProp,ArchiveOldFilmsProp,ArchivePreferenceFilmsProp,ArchiveLocationProp";
return true;
}
if (index == counter++)
{
prop.GroupName = "MediaArchiver";
//set the internal name
prop.Name = "FilmArchiverProp";
//set name shown to user
prop.Caption = "Archive Films";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText =
"If you enable this option, the built-in archiver will compress and store (in the directory you provide below)" +
Environment.NewLine +
"a zip archive for each watched film, containing the entire film's directory." + Environment.NewLine +
"The original directory containing the film will be deleted, but only when the archiving operation is succesfull." +
Environment.NewLine +
"Please note that in order to determine if a film is watced or not, the plugin will look for a tag named 'Watched' in your film library.";
prop.DefaultValue = false;
prop.DataType = "bool";
prop.Dependencies = "True:SHOW ArchiveWatchedFilmsProp,ArchiveOldFilmsProp" +
";False:HIDE ArchiveWatchedFilmsProp,ArchiveOldFilmsProp,ArchivePreferenceFilmsProp,ArchiveLocationProp";
return true;
}
if (index == counter++)
{
prop.GroupName = "MediaArchiver";
//set the internal name
prop.Name = "ArchiveWatchedFilmsProp";
//set name shown to user
prop.Caption = "Archive watched films";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = "";
prop.DefaultValue = Settings.ArchiveWatchedFilms;
prop.DataType = "bool";
prop.Dependencies = "True:SHOW ArchivePreferenceFilmsProp";
return true;
}
if (index == counter++)
{
prop.GroupName = "MediaArchiver";
//set the internal name
prop.Name = "ArchiveOldFilmsProp";
//set name shown to user
prop.Caption = "Archive Old Films";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = "";
prop.DefaultValue = Settings.ArchiveOldFilms;
prop.DataType = "bool";
prop.Dependencies = "True:SHOW ArchivePreferenceFilmsProp";
return true;
}
if (index == counter++)
{
prop.GroupName = "MediaArchiver";
//set the internal name
prop.Name = "ArchivePreferenceFilmsProp";
//set name shown to user
prop.Caption = "Archive preference for films: ";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = "";
prop.DefaultValue = "Delete";
prop.DataType = "string";
twochoices[0] = "Archive";
twochoices[1] = "Delete";
prop.Choices = twochoices;
prop.CanTypeChoices = false;
prop.Dependencies = "Delete:HIDE ArchiveLocationProp" +
";Archive:SHOW ArchiveLocationProp";
return true;
}
if (index == counter++)
{
prop.GroupName = "MediaArchiver";
//set the internal name
prop.Name = "ArchiveLocationProp";
//set name shown to user
prop.Caption = "Directory to store archives: ";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = "Please specify the directory in which the zip archives of your watched films will be stored: ";
prop.DefaultValue = Settings.ArchiveLocation;
prop.DataType = "folder";
return true;
}
return false;
}
internal static bool GetLibraryManagementProperties
(ImporterProperties importerProperties,
int index, OptionSettings prop, ref int counter)
{
if (index == counter++)
{
prop.GroupName = "LibraryCleanup";
//set the internal name
prop.Name = "ExtractMetadataFromFilenamesProp";
//set name shown to user
prop.GroupCaption = " Library Management";
prop.Caption = "Clean and extract metadata from filenames";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = "This option enables the program's ability to recognize and extract key information" +
Environment.NewLine +
"about media files from their filenames, and clean them by removing unessecarry information." +
Environment.NewLine +
"Warning: Disabling this option may compromise the performance and accuraccy of the automated film and tv series identifiers.";
prop.DefaultValue = MeediFier.Settings.ExtractMetadataFromFilenames;
prop.DataType = "bool";
return true;
}
if (index == counter++)
{
prop.GroupName = "LibraryCleanup";
//set the internal name
prop.Name = "EnableChainLinkingProp";
//set name shown to user
prop.Caption = "Link orphaned video files";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = "If this setting is enabled, the films section updater will scan and link together" +
Environment.NewLine +
"multiple video files of the same film, using the film's unique id.";
prop.DefaultValue = MeediFier.Settings.FilmItemChainLinkerIsEnabled;
prop.DataType = "bool";
return true;
}
if (index == counter++)
{
prop.GroupName = "LibraryCleanup";
//set the internal name
prop.Name = "DeleteMissingProp";
//set name shown to user
prop.Caption = "Delete missing library items";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText =
"This feature will automatically delete library items which refer to non-existent (deleted) files." +
Environment.NewLine +
"The media server diagnostic will ensure that the items located in your file server will not be accidentaly deleted if the server is offline. ";
prop.DefaultValue = MeediFier.Settings.DeleteMissing;
prop.DataType = "bool";
prop.Dependencies =
"False:HIDE DeleteCoverImageOfMissingMediaFilesProp,DeleteFanartImageOfMissingMediaFilesProp" +
";True:SHOW DeleteCoverImageOfMissingMediaFilesProp,DeleteFanartImageOfMissingMediaFilesProp";
return true;
}
if (index == counter++)
{
prop.GroupName = "LibraryCleanup";
//set the internal name
prop.Name = "DeleteCoverImageOfMissingMediaFilesProp";
//set name shown to user
prop.Caption = "Delete cover images of missing media files";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = "Enable this setting for the plugin to automatically delete" + Environment.NewLine +
"any left-over cover images of media files which were deleted. (but their entries are still present in library)";
prop.DefaultValue = MeediFier.Settings.DeleteCoverImageOfMissingMediaFiles;
prop.DataType = "bool";
return true;
}
if (index == counter++)
{
prop.GroupName = "LibraryCleanup";
//set the internal name
prop.Name = "DeleteFanartImageOfMissingMediaFilesProp";
//set name shown to user
prop.Caption = "Delete fanart images of missing media files";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = "Enable this setting for the plugin to automatically delete" + Environment.NewLine +
"any left-over fanart images of media files which were deleted. (but their entry is still present in library)";
prop.DefaultValue = MeediFier.Settings.DeleteFanartImageOfMissingMediaFiles;
prop.DataType = "bool";
return true;
}
if (index == counter++)
{
prop.GroupName = "LibraryCleanup";
//set the internal name
prop.Name = "ClearEmptyFieldsProp";
//set name shown to user
prop.Caption = "Remove empty library fields";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = "If you enable this option, MediaFairy will remove all empty tags in your library." +
Environment.NewLine +
"Only the tags that have all their values empty will be removed." + Environment.NewLine +
"Enabling this option will ensure a cleaner library and faster library accessing operations. ";
prop.DefaultValue = MeediFier.Settings.CleanEmptyFields;
prop.DataType = "bool";
return true;
}
if (index == counter++)
{
prop.GroupName = "LibraryCleanup";
//set the internal name
prop.Name = "CleanSelectedFieldsProp";
//set name shown to user
prop.Caption = "Remove selected library fields: ";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = "If you enable this option, MediaFairy will remove the library fields you specify below." +
Environment.NewLine +
"You can use this option to delete uneeded/unwanted library tags which other importers may have created.";
prop.DefaultValue = MeediFier.Settings.CleanSelectedFields;
prop.DataType = "bool";
prop.Dependencies = "False:HIDE SelectedFieldsToCleanProp" +
";True:SHOW SelectedFieldsToCleanProp";
return true;
}
if (index == counter++)
{
prop.GroupName = "LibraryCleanup";
//set the internal name
prop.Name = "SelectedFieldsToCleanProp";
//set name shown to user
prop.Caption = "Which tags to delete? ";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = " Please specify here the names of the tags to remove, seperating with a comma (,) ";
prop.DefaultValue = MeediFier.Settings.SelectedFieldsToClean;
prop.DataType = "string";
return true;
}
//if (index == counter++)
//{
// prop.GroupName = "LibraryCleanup";
// //set the internal name
// prop.Name = "MovieNightCompatibleProp";
// //set name shown to user
// prop.Caption = "MovieNight compatibility (for Meedio version)";
// prop.Caption = TranslationProvider.Translate(prop.Caption, this);
// //set the tool tip
// prop.HelpText = "Enable this setting if you are a user of MovieNight media module for Meedio." + Environment.NewLine +
// "Your film library tags in this case will be named according to this module's definitions.";
// prop.DefaultValue = Settings.MovieNightCompatibility;
// prop.DataType = "bool";
// return true;
//}
if (index == counter++)
{
prop.GroupName = "LibraryCleanup";
//set the internal name
prop.Name = "MeePopupProviderCompatibilityProp";
//set name shown to user
prop.Caption = "MeePopupProvider compatibility (for MeediOS version)";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = "Enable this setting if you are a user of MeePopupProvider for MeediOS." + Environment.NewLine +
"A 'meePopupProvider' field will be added to all media sections containing each item's ID number.";
prop.DefaultValue = MeediFier.Settings.MeePopupProviderCompatibility;
prop.DataType = "bool";
return true;
}
return false;
}
//for opening the window any other time
public void OpenWindow()
{
window = (OptionSettings)GetWindow(typeof(OptionSettings));
window.minSize = new Vector2(300, 300);
window.Show();
}
public override bool GetProperty(int index, OptionSettings prop)
{
int i = 1;
if (MiscPropertiesGetter.GetPropertyForMisc
(index, ref i, prop,
fileImporter, this))
{
return true;
}
if (FileInclusionPropertiesGetter.GetPropertyForFileInclusion
(index, ref i, prop))
{
return true;
}
if (ImageAssociationPropertiesGetter.GetPropertyForImageAssociation
(this, index, ref i, prop))
{
return true;
}
if (FileSystemInfoPropertiesGetter.GetPropertyForFilesystemInfo
(index, ref i, prop))
{
return true;
}
if (AdsPropertiesGetter.GetPropertyForAlternateDataStreamsOptions
(index, ref i, prop))
{
return true;
}
return GetPropertyForDebugging
(index, i, prop);
}
internal bool ImportAndUpdateMediaTypesComboProperties(int index, OptionSettings prop, ref int counter)
{
#region [DEPRECATED] Media Types to Import & Update:
#region Movies
if (index == counter++)
{
//set the internal name
prop.Name = "WantToImportAndUpdateFilmsProp";
prop.GroupName = "SimpleMode";
//set name shown to user
prop.Caption = "Import and update Movies";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
//Prop.GroupCaption = " Media Importer";
//set the tool tip
prop.HelpText = "With this setting enabled, the plugin will automatically import, identify" +
Environment.NewLine +
"and download media information & images for all films in your Media Sources." +
Environment.NewLine +
"Important: This setting will enable both media importing *AND* updating for this media type." +
Environment.NewLine +
"If you need to independently enable the Media Importing or Updating for this media type, please un-tick this checkbox and use Advanced Mode instead. ";
prop.DefaultValue = Settings.WantToImportAndUpdateFilms;
prop.DataType = "bool";
prop.Dependencies = "False:HIDEGROUP MovieTitleLocator,FilmDetails,FilmCovers,AlbumCovers" +
";True:SHOWGROUP MovieTitleLocator" +
";True:HIDEGROUP FilmDetails,FilmCovers,AlbumCovers";
return true;
}
#endregion
#region TV Series
if (index == counter++)
{
//set the internal name
prop.Name = "WantToImportAndUpdateTvSeriesProp";
prop.GroupName = "SimpleMode";
//set name shown to user
prop.Caption = "Import and update Tv Series";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
prop.HelpText = "With this setting enabled, the plugin will automatically import, identify" +
Environment.NewLine +
"and download media information & images for all episodes of TV series in your Media Sources. ";
prop.DefaultValue = Settings.ImportAndUpdateTvSeries;
prop.DataType = "bool";
prop.Dependencies = "False:HIDEGROUP AlbumCovers,FilmCovers" +
";True:HIDEGROUP AlbumCovers,FilmCovers";
return true;
}
#endregion
#region Music
if (index == counter++)
{
//set the internal name
prop.Name = "WantToImportAndUpdateMusicProp";
prop.GroupName = "SimpleMode";
//set name shown to user
prop.Caption = "Import and update Music";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
//Prop.GroupCaption = " Media Importer";
//set the tool tip
prop.HelpText = "With this setting enabled, the plugin will automatically import, identify" +
Environment.NewLine +
"and download media information & images for all music in your Media Sources. ";
prop.DefaultValue = Settings.WantToImportAndUpdateMusic;
prop.DataType = "bool";
prop.Dependencies = "False:HIDEGROUP AlbumCovers,FilmCovers" +
";True:HIDEGROUP AlbumCovers,FilmCovers";
return true;
}
#endregion
#region Games
if (index == counter++)
{
//set the internal name
prop.Name = "WantToImportAndUpdateGamesProp";
prop.GroupName = "SimpleMode";
//set name shown to user
prop.Caption = "Import and update Games";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
//Prop.GroupCaption = " Media Importer";
//set the tool tip
prop.HelpText = "With this setting enabled, the plugin will automatically import, identify" + Environment.NewLine +
"and download media information & images for the PC games in your games shortcuts' location. ";
prop.DefaultValue = Settings.WantToImportAndUpdateGames;
prop.DataType = "bool";
prop.Dependencies = "False:HIDE GameShortcutsProp" +
";True:SHOW GameShortcutsProp";
return true;
}
if (index == counter++)
{
//set the internal name
prop.Name = "GameShortcutsProp";
prop.GroupName = "SimpleMode";
//set name shown to user
prop.Caption = "Game shortcuts location:";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
//Prop.GroupCaption = " Media Importer";
//set the tool tip
prop.HelpText = "Please provide the location of the shortcuts for your PC games." + Environment.NewLine +
"MediaFairy will first use the manifest information of the game executable to recognize the game's title." + Environment.NewLine +
"If manifest info is not available, MF will use the shortcut's name instead to get the title of the game.";
prop.DefaultValue = Settings.GameShortcutsLocation;
prop.DataType = "folder";
return true;
}
#endregion
#region Books
if (index == counter++)
{
//set the internal name
prop.Name = "WantToImportAndUpdateBooksProp";
prop.GroupName = "SimpleMode";
//set name shown to user
prop.Caption = "Import and update Books (reserved for future version)";
prop.Caption = TranslationProvider.Translate(prop.Caption, this);
//Prop.GroupCaption = " Media Importer";
//set the tool tip
prop.HelpText = "With this setting enabled, the plugin will automatically import, identify" +
Environment.NewLine +
"and download media information & images for all digital books in your Media Sources. ";
prop.DefaultValue = Settings.WantToImportAndUpdateBooks;
prop.DataType = "bool";
prop.Dependencies = "False:HIDEGROUP AlbumCovers,FilmCovers" +
";True:HIDEGROUP AlbumCovers,FilmCovers";
return true;
}
#endregion
#endregion Media Types to Import & Update
return false;
}
internal static bool ArchiveExtractorPropRerties(ImporterProperties importerProperties, int index, OptionSettings prop,
ref int counter)
{
if (index == counter++)
{
prop.GroupName = "ArchiveExtractor";
//set the internal name
prop.Name = "EnableArchiveExtractorProp";
//set name shown to user
prop.GroupCaption = " Archive Extractor";
prop.Caption = "Auto-extract compressed archives";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText =
"The built-in media importer has the capability to automatically extract zip and/or rar archives" +
Environment.NewLine +
"contained in your specified media root directories and import the media files they may contain." +
Environment.NewLine +
"Multi-part rar archives are also supported.";
prop.DefaultValue = Settings.EnableArchiveExtractor;
prop.DataType = "bool";
prop.Dependencies = "False:HIDE DeleteArchiveAfterExtractionProp,freespaceThresholdProp" +
";True:SHOW DeleteArchiveAfterExtractionProp,freespaceThresholdProp";
return true;
}
if (index == counter++)
{
prop.GroupName = "ArchiveExtractor";
//set the internal name
prop.Name = "DeleteArchiveAfterExtractionProp";
//set name shown to user
prop.Caption = "Delete archive after extraction ";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = "When an archive extraction process is succesfull, the media importer can delete" +
Environment.NewLine +
"the original compressed archive in order to free any disk space used by that archive.";
prop.DefaultValue = Settings.DeleteArchiveAfterExtraction;
prop.DataType = "bool";
return true;
}
if (index == counter++)
{
prop.GroupName = "ArchiveExtractor";
//set the internal name
prop.Name = "freespaceThresholdProp";
//set name shown to user
prop.Caption = "Maintain at least this amount of disk space: (MB)";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText =
"Please specify here the amount of free disk space (in Megabytes, MB) you would like the plugin to always maintain." +
Environment.NewLine +
"When this limit is calculated to be exceeded, the archive extraction process in question will be skipped.";
prop.DefaultValue = Settings.freespaceThreshold;
prop.DataType = "int";
return true;
}
return false;
}
internal static bool GetFilmReleasesUpdaterProperties
(ImporterProperties importerProperties,
int index, OptionSettings prop, ref int counter)
{
if (index == counter++)
{
prop.GroupName = "RssUpdater";
//set the internal name
prop.Name = "EnableFilmReleasesProp";
//set name shown to user
prop.GroupCaption = " RSS Releases Updater";
prop.Caption = "Download film releases via BitTorrent";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText =
"The Film Releases Updater will scan for new film releases the rss feeds you provide in the RSS Sources.txt file (in the plugin's direcotry), \n and download those films using your default BitTorrent client. Adittional filters can be provided like the film's production year or IMDb rating. ";
prop.DefaultValue = Settings.DownloadFilmReleases;
prop.DataType = "bool";
prop.Dependencies = "False:HIDE FilmRatingMinProp,TorrentsFolderProp" +
";True:SHOW FilmRatingMinProp,TorrentsFolderProp";
return true;
}
if (index == counter++)
{
prop.GroupName = "RssUpdater";
//set the internal name
prop.Name = "TorrentsFolderProp";
//set name shown to user
prop.Caption = "Store torrent files in: ";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = @"Please specify the folder where downloaded torrent files should be stored. ";
prop.DefaultValue = Settings.TorrentsFolder;
prop.DataType = "folder";
prop.CanTypeChoices = false;
return true;
}
//if (Index == counter++)
//{
// //set the internal name
// Prop.Name = "FilmReleasesRssProp";
// //set name shown to user
// Prop.Caption = " RSS feeds for films releases: ";
// //set the tool tip
// Prop.HelpText = "Please provide here the rss feed URLs which will be scanned for new film releases. Important Notice: Please make sure that the sources you provide contain public domain media, in order to comply with copyright regulations. ";
// Prop.DefaultValue = Importer.FilmsRssFeeds;
// Prop.DataType = "stringlist";
// return true;
//}
if (index == counter++)
{
prop.GroupName = "RssUpdater";
//set the internal name
prop.Name = "FilmRatingMinProp";
prop.Caption = "Minimum film IMDb rating: ";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText =
"This value represents the minimum IMDb rating that a film must have, in order to be downloaded. Set this value to zero (0) to disable the rating filter.";
prop.DefaultValue = Settings.FilmRatingMin2;
prop.DataType = "string";
return true;
}
return false;
}
internal static bool ConfigurationModeProperty
(ImporterProperties importerProperties,
int index, OptionSettings prop, ref int counter)
{
if (index == counter++)
{
prop.Name = "Mode";
prop.Caption = "Configuration Mode: ";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
prop.HelpText = "The Configuration Mode menu categorizes the available settings of the plugin" +
Environment.NewLine +
" according to the following settings groups:" + Environment.NewLine +
"Media Sections, Media Importers, Media Importing Settings, " + Environment.NewLine +
"Media Updaters, Media Updaters Settings," + Environment.NewLine +
" Media Organizers, User Interface Settings, Tools, Compatibility";
prop.DataType = "string";
prop.Choices = new[]
{"Media Sections",
"Media Importers",
"Media Updaters",
"Media Organizers",
"Advanced"};
prop.CanTypeChoices = false;
prop.Dependencies =
#region Media Sections
"Media Sections:HIDEGROUP"
+
" MediaImporter,"
+
"MediaAnalyzer,"
+
"MovieTitleLocator,"
+
"MediaUpdaters,"
+
"FilmUpdater,"
+
"TvUpdater,"
+
"MusicUpdater,"
+
"VideoIdentifier,"
+
"FilmDetails,"
+
"FilmCovers,"
+
"AlbumCovers,"
+
"AutoSorter,"
+
"OrganizingStructures,"
+
"Diagnostics,"
+
"LibraryCleanup,"
+
"UserInterface,"
+
"RSSimporter"
+
";Media Sections:"
+
"SHOWGROUP "
+
"MediaSections"
#endregion Media Sections
+
#region Media Importers
";Media Importers:HIDEGROUP"
+
" MediaSections,"
+
"MediaAnalyzer,"
+
"MovieTitleLocator,"
+
"MediaUpdaters,"
+
"FilmUpdater,"
+
"TvUpdater,"
+
"MusicUpdater,"
+
"VideoIdentifier,"
+
"FilmDetails,"
+
"FilmCovers,"
+
"AlbumCovers,"
+
"AutoSorter,"
+
"OrganizingStructures,"
+
"Diagnostics,"
+
"LibraryCleanup,"
+
"UserInterface,"
+
"RSSimporter"
+
";Media Importers:"
+
"SHOWGROUP "
+
"MediaImporter"
#endregion Media Importers
+
#region Media Updaters
";Media Updaters:"
+
"SHOWGROUP "
+
"MediaUpdaters"
+
";Media Updaters:HIDEGROUP "
+
"MediaSections,"
+
"MediaImporter,"
+
"MediaAnalyzer,"
+
"MovieTitleLocator,"
+
"AutoSorter,"
+
"OrganizingStructures,"
+
"Diagnostics,"
+
"LibraryCleanup,"
+
"UserInterface,"
+
"RSSimporter"
#endregion Media Updaters
+
#region Media Organizers
";Media Organizers:"
+
"SHOWGROUP "
+
"AutoSorter"
+
";Media Organizers:"
+
"HIDEGROUP "
+
"MediaSections,"
+
"MediaImporter,"
+
"MediaAnalyzer,"
+
"MovieTitleLocator,"
+
"RSSimporter,"
+
"MediaUpdaters,"
+
"FilmUpdater,"
+
"TvUpdater,"
+
"MusicUpdater,"
+
"VideoIdentifier,"
+
"FilmDetails,"
+
"FilmCovers,"
+
"AlbumCovers,"
+
"Diagnostics,"
+
"LibraryCleanup,"
+
"UserInterface"
#endregion Media Organizers
+
#region Advanced
";Advanced:"
+
"SHOWGROUP "
+
"AutoSorter,"
+
"Diagnostics,"
+
"LibraryCleanup,"
+
"UserInterface"
+
";Advanced:HIDEGROUP "
+
"MediaSections,"
+
"MediaImporter,"
+
"MediaAnalyzer,"
+
"MovieTitleLocator,"
+
"RSSimporter,"
+
"MediaUpdaters,"
+
"FilmUpdater,"
+
"TvUpdater,"
+
"MusicUpdater,"
+
"VideoIdentifier,"
+
"FilmDetails,"
+
"FilmCovers,"
+
"AlbumCovers";
#endregion Advanced
prop.GroupName = "misc";
prop.DefaultValue = "Simple";
return true;
}
return false;
}
internal static bool GetFilmDetailsProperties
(ImporterProperties importerProperties, int index, OptionSettings prop,
IList<string> twochoices, ref int counter)
{
if (index == counter++)
{
//set the internal name
prop.Name = "PopulateIMDbDetailsProp";
//set name shown to user
prop.Caption = "Download Film Details from IMDb";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
prop.GroupCaption = " Film Details";
prop.GroupName = "FilmDetails";
//set the tool tip
prop.HelpText = "Would you like to use IMDb (International Movie Database) to download details for your films?";
prop.DefaultValue = MeediFier.Settings.FilmIMDbDetailsDownloaderIsEnabled;
prop.DataType = "bool";
return true;
}
if (index == counter++)
{
//set the internal name
prop.Name = "PopulateOSdbDetailsProp";
//set name shown to user
prop.Caption = "Download Film Details from OSdb";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
prop.GroupName = "FilmDetails";
//set the tool tip
prop.HelpText = "Would you like to use OSdb (opensubtitles.org) as one of the film details online sources?" +
Environment.NewLine +
"MediaFairy will download film details from OSdb only if IMDb is offline or unreachable";
prop.DefaultValue = MeediFier.Settings.FilmOSDbDetailsDownloaderIsEnabled;
prop.DataType = "bool";
return true;
}
if (index == counter++)
{
//set the internal name
prop.Name = "PopulateTMDbDetailsProp";
//set name shown to user
prop.Caption = "Download additional film details from TMDb";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
prop.GroupName = "FilmDetails";
//set the tool tip
prop.HelpText = " Would you like additional film details to be downloaded from TMDb (www.themoviedb.org)?" +
Environment.NewLine +
"(TMDb Rating, Media Type, Budget, Revenue, film HomePage, Production Countries, Trailer)";
prop.DefaultValue = MeediFier.Settings.TMDbFilmDetailsEnabled;
prop.DataType = "bool";
return true;
}
//if (index == counter++)
//{
// //set the internal name
// prop.Name = "PopulateAMGDetailsProp";
// //set name shown to user
// prop.Caption = "Download additional film details from AMG";
// prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
// prop.GroupName = "FilmDetails";
// //set the tool tip
// prop.HelpText = " Would you like additional film details to be downloaded from AMG (allmovie.com)?" +
// Environment.NewLine +
// "(Plot synopsis, Editorial review, Category, Types, Flags, Keywords, Themes, Tones)";
// prop.DefaultValue = MediaFairy.Settings.AllMediaGuideFilmDetailsEnabled;
// prop.DataType = "bool";
// return true;
//}
//if (index == counter++)
//{
// //set the internal name
// prop.Name = "PopulateSevenVideoNetDetailsProp";
// //set name shown to user
// prop.Caption = "Download Greek film details from Seven Video Net";
// prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
// prop.GroupName = "FilmDetails";
// //set the tool tip
// prop.HelpText =
// " Would you like to automatically download Greek film details from Seven Video Net (videoseven.gr)?";
// prop.DefaultValue = MediaFairy.Settings.SevenFilmDetailsEnabled;
// prop.DataType = "bool";
// return true;
//}
if (index == counter++)
{
//set the internal name
prop.Name = "WriteFilmDescriptorsProp";
//set name shown to user
prop.Caption = "Save film descriptors ";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
prop.GroupName = "FilmDetails";
//set the tool tip
prop.HelpText =
"Film descriptors are standrard .xml files which contain a film's identifying information and details." +
Environment.NewLine +
"If this feature is enabled, a film descriptor will be saved (in the film's directory) for each film the plugin successfully identifies." +
Environment.NewLine +
"This procedure offers greatly increased updating performance if/when the film needs to be imported again," +
Environment.NewLine +
"because if a film descriptor is found, the plugin will use this file to obtain the film's details, thus skipping the video identifying phase. ";
prop.DefaultValue = MeediFier.Settings.FilmDescriptorsAreEnabled;
prop.DataType = "bool";
return true;
}
if (index == counter++)
{
//set the internal name
prop.Name = "FilmDescriptorConventionProp";
//set name shown to user
prop.Caption = "Film descriptors naming convention ";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
prop.GroupName = "FilmDetails";
//set the tool tip
prop.HelpText = "Which naming convention would you like to use for your film descriptors?" + Environment.NewLine +
"MediaFairy is compatible with XBMC's .nfo files." + Environment.NewLine +
"MediaFairy's film descriptors are named <VideoHash>.xml while XBMC's are named <MovieName>.nfo";
prop.DefaultValue = MeediFier.Settings.FilmDescriptorConvention;
prop.DataType = "string";
prop.CanTypeChoices = false;
twochoices[0] = "MediaFairy";
twochoices[1] = "XBMC";
prop.Choices = twochoices;
return true;
}
return false;
}
internal static bool GetPropertyForMisc(int index, ref int i, OptionSettings prop,
CORE.FileImporter fileImporter,
ImporterPropertiesCore.FileImporterProperties importerProperties)
{
if (index == i++)
{
prop.Name = "Mode";
prop.Caption = "Mode";
prop.HelpText = "Expert mode shows all options " +
"except those dependent on other options." +
Environment.NewLine +
"(Ex: 'Chaining tags' option is only visible" +
" if you selected 'Group/chain items" +
" with matching tags' in the 'Chaining options'.)" +
Environment.NewLine +
"Simple-Hide mode hides a lot of the more advanced options." +
" Simple-Disable will instead disable the same advanced options.";
prop.DataType = "string";
prop.Choices = new[]
{
"Simple-Hide".Translate(),
"Simple-Disable".Translate(),
"Expert".Translate()
};
prop.Dependencies = "Simple-Hide".Translate()
+
":::HIDEGROUP"
+
" ImageAssociationRules,"
+
"FilesystemInfo,"
+
"Debugging," +
"ADS"
+
";;;"
+
"Simple-Disable".Translate()
+
":::DISABLEGROUP"
+
" ImageAssociationRules,"
+
"FilesystemInfo,"
+
"Debugging,ADS"
+
";;;"
+
"Simple-Hide".Translate()
+
":::HIDE"
+
" ImageTagName,"
+
"DeleteNonExistentFiles,"
+
"AlwaysUpdate,"
+
"IncludeHiddenFiles,"
+
"ExcludeFileMasks,"
+
"MinFileSize,"
+
"ExcludeUnmatchedFiles,"
+
"ChainingOptions,"
+
"AlwaysUpdateImages,"
+
"TagValuesReplacement"
+
";;;"
+
"Simple-Disable".Translate()
+
":::DISABLE ImageTagName,"
+
"DeleteNonExistentFiles,"
+
"AlwaysUpdate,"
+
"IncludeHiddenFiles,"
+
"ExcludeFileMasks"
+
",MinFileSize,"
+
"ExcludeUnmatchedFiles,"
+
"ChainingOptions,AlwaysUpdateImages,"
+
"TagValuesReplacement"
+
";;;"
+
"Expert".Translate()
+
":::ENABLEGROUP "
+
"ImageAssociationRules,"
+
"FilesystemInfo,"
+
"Debugging,"
+
"ADS"
+
";;;"
+
"Expert".Translate()
+
":::SHOWGROUP "
+
"ImageAssociationRules,"
+
"FilesystemInfo,"
+
"Debugging,"
+
"ADS"
+
";;;" + "Expert".Translate()
+
":::ENABLE "
+
"ImageTagName,"
+
"DeleteNonExistentFiles,"
+
"AlwaysUpdate,"
+
"IncludeHiddenFiles,"
+
"ExcludeFileMasks,"
+
"MinFileSize,"
+
"ExcludeUnmatchedFiles,"
+
"ChainingOptions,"
+
"AlwaysUpdateImages,"
+
"TagValuesReplacement"
+
";;;"
+
"Expert".Translate()
+
":::Show "
+
"ImageTagName,"
+
"DeleteNonExistentFiles,"
+
"AlwaysUpdate,"
+
"IncludeHiddenFiles,"
+
"ExcludeFileMasks,"
+
"MinFileSize,"
+
"ExcludeUnmatchedFiles,"
+
"ChainingOptions,"
+
"AlwaysUpdateImages,"
+
"TagValuesReplacement";
prop.GroupName = "Misc";
prop.DefaultValue = "Simple-Hide".Translate();
return true;
}
/*
if (index == i++)
{
prop.Name = "WizardToggle";
prop.Caption = string.Empty;
prop.DefaultValue = "Start the setup wizard".Translate();
prop.HelpText = "Click to start a wizard guiding you through the setup of this import";
prop.GroupName = "Misc";
prop.Dependencies = "Start the setup wizard".Translate() +
":::WizardStepper = 1|||SHOW WizardStepper";
prop.DataType = "toggle";
return true;
}
if (index == i++)
{
prop.Name = "WizardStepper";
prop.Caption = "Wizard test";
prop.HelpText = "help";
prop.Choices = new List<string> { "MediaType", "RootFolders2", "TagMasks" };
prop.DefaultValue = 0;
prop.DataType = "wizard";
return true;
}
*/
//if (index == i++)
//{
// prop.Name = "MediaType";
// prop.Caption = "Media type";
// prop.Choices2["any"] = "Any";
// prop.Choices2["music"] = "Music";
// prop.Choices2["musicvideos"] = "Music videos";
// prop.Choices2["movies"] = "Movies";
// prop.Choices2["tvshows"] = "TVShows";
// prop.Choices2["text"] = "Text";
// prop.Choices2["games"] = "Games";
// prop.Choices2["images"] = "Images";
// prop.HelpText = "If set other properties " +
// "will be preconfigured to reflect" +
// " the chosen media type.";
//// fileImporter.MovieProfile = "default";
//// fileImporter.MusicProfile = "default";
//// fileImporter.PicturesProfile = "default";
//// fileImporter.TVShowsProfile = "default";
// //string movieFolders = string.Empty;
// //if (fileImporter.MovieFolders != null)
// //{
// // movieFolders
// // = string.Join
// // (Environment.NewLine,
// // fileImporter.MovieFolders);
// //}
// //string tvFolders = String.Empty;
// //if (fileImporter.TVShowsFolders != null)
// //{
// // tvFolders
// // = string.Join
// // (Environment.NewLine,
// // fileImporter.TVShowsFolders);
// //}
// //string musicFolders = String.Empty;
// //if (fileImporter.MusicFolders != null)
// //{
// // musicFolders
// // = string.Join
// // (Environment.NewLine,
// // fileImporter.MusicFolders);
// //}
// //string photoFolders = String.Empty;
// //if (fileImporter.PicturesFolders != null)
// //{
// // photoFolders
// // = string.Join
// // (Environment.NewLine,
// // fileImporter.PicturesFolders);
// //}
// //string musicVideosFolders
// // = importerProperties
// // .FixMediaLocation
// // ("ExistingMusicVideos");
// //string moviePosterFolder
// //= importerProperties
// //.FixMediaLocation
// //("ExistingMoviePosters");
// //string movieFanartFolder
// //= importerProperties.FixMediaLocation
// //("ExistingMovieFanArt");
// //string tvSeriesBannerFolder
// // = importerProperties.FixMediaLocation
// // ("ExistingTVSeriesBanners");
// //string tvSeriesPosterFolder
// // = importerProperties.FixMediaLocation
// // ("ExistingTVSeriesPosters");
// //string tvSeriesFanartFolder
// // = importerProperties.FixMediaLocation
// // ("ExistingTVFanArt");
// //string tvSeasonImageFolder
// // = importerProperties.FixMediaLocation
// // ("ExistingTVSeasonPosters");
// //prop.Dependencies = ".*:::UPDATE Mode" +
// // ";;;any:::IncludeFileMasks = " +
// // "|||SHOWGROUP ImageAssociationRules" +
// // "|||ImageSearchActive2 = false" +
// // "|||ImageSearchActive3 = false" +
// // "|||ImageSearchActive4 = false" +
// // "|||ImageSearchActive5 = false" +
// // ";;;music:::IncludeFileMasks = "
// // +
// // FileImporter
// // .FileImporterProperties
// // .AudioExtensions
// // +
// // "|||RootFolders2 = "
// // +
// // musicFolders
// // +
// // "|||TagMasks = "
// // +
// // importerProperties.MusicRegex
// // +
// // "|||SHOWGROUP ImageAssociationRules"
// // +
// // "|||ImageSearchActive2 = false"
// // +
// // "|||ImageSearchActive3 = false"
// // +
// // "|||ImageSearchActive4 = false"
// // +
// // "|||ImageSearchActive5 = false"
// // +
// // ";;;movies:::IncludeFileMasks = "
// // +
// // FileImporter.FileImporterProperties.VideoExtensions
// // +
// // "|||RootFolders2 = "
// // +
// // movieFolders
// // +
// // "|||TagMasks = "
// // +
// // importerProperties.MoviesRegex
// // +
// // "|||SHOWGROUP ImageAssociationRules" +
// // "|||ImageSearchActive2 = true" +
// // "|||ImageSearchActive3 = false" +
// // "|||ImageSearchActive4 = false" +
// // "|||ImageSearchActive5 = false" +
// // "|||ImageFolder = " + moviePosterFolder
// // +
// // "|||ImageFolder2 = " + movieFanartFolder
// // +
// // ";;;musicvideos:::IncludeFileMasks = "
// // +
// // FileImporter.FileImporterProperties.VideoExtensions
// // +
// // "|||RootFolders2 = " + musicVideosFolders +
// // "|||SHOWGROUP ImageAssociationRules" +
// // "|||ImageSearchActive2 = false" +
// // "|||ImageSearchActive3 = false" +
// // "|||ImageSearchActive4 = false" +
// // "|||ImageSearchActive5 = false" +
// // ";;;tvshows:::IncludeFileMasks = " + FileImporter.FileImporterProperties.VideoExtensions +
// // "|||RootFolders2 = " + tvFolders +
// // "|||TagMasks = " + importerProperties.TVShowsRegex +
// // "|||TagValuesReplacement = " + importerProperties.tvShowsReplacements +
// // "|||ENABLEGROUP ImageAssociationRules" +
// // "|||SHOWGROUP ImageAssociationRules" +
// // "|||ImageSearchActive2 = true" +
// // "|||ImageSearchActive3 = true" +
// // "|||ImageSearchActive4 = true" +
// // "|||ImageSearchActive5 = true" +
// // "|||ImageFolder2 = "
// // +
// // tvSeriesFanartFolder
// // +
// // "|||ImageFolder3 = "
// // +
// // tvSeasonImageFolder
// // +
// // "|||ImageFolder4 = "
// // +
// // tvSeriesPosterFolder
// // +
// // "|||ImageFolder5 = "
// // +
// // tvSeriesBannerFolder
// // +
// // ";;;text:::IncludeFileMasks = "
// // +
// // FileImporter.FileImporterProperties.TextExtensions
// // +
// // "|||SHOWGROUP ImageAssociationRules"
// // +
// // "|||ImageSearchActive2 = false"
// // +
// // "|||ImageSearchActive3 = false" +
// // "|||ImageSearchActive4 = false" +
// // "|||ImageSearchActive5 = false" +
// // ";;;images:::IncludeFileMasks = "
// // +
// // FileImporter.FileImporterProperties.ImageExtensions +
// // "|||RootFolders2 = " + photoFolders +
// // "|||HIDEGROUP ImageAssociationRules" +
// // "|||ImageSearchActive2 = false" +
// // "|||ImageSearchActive3 = false" +
// // "|||ImageSearchActive4 = false" +
// // "|||ImageSearchActive5 = false" +
// // ";;;games:::IncludeFileMasks = " + "*.lnk" +
// // "|||SHOWGROUP ImageAssociationRules" +
// // "|||ImageSearchActive2 = false" +
// // "|||ImageSearchActive3 = false" +
// // "|||ImageSearchActive4 = false" +
// // "|||ImageSearchActive5 = false";
// prop.DataType = "string";
// const string defaultValue = "any";
//// if (fileImporter.IsFirstLoad)
//// {
//// string sectionName
//// = fileImporter.Section
//// .Name.ToLowerInvariant();
//// List<string> musicLibraryNames
//// = new List<string>
//// {
//// "music",
//// "music".Translate()
//// };
//// List<string> moviesLibraryNames
//// = new List<string>
//// {
//// "movies",
//// "movies".Translate()
//// };
//// List<string> musicvideosLibraryNames
//// = new List<string>
//// {
//// "musicvideos",
//// "musicvideos".Translate()
//// };
//// List<string> tvshowsLibraryNames = new List<string>
//// {
//// "tv-shows",
//// "tv-shows".Translate(),
//// "tvshows",
//// "tvshows".Translate(),
//// "series",
//// "series".Translate(),
//// "tv series",
//// "tv series".Translate()
//// };
//// List<string> gamesLibraryNames
//// = new List<string> { "games",
//// "games".Translate() };
//// List<string> imagesLibraryNames = new List<string>
//// {
//// "photos",
//// "photos".Translate(),
//// "images",
//// "images".Translate(),
//// "pictures",
//// "pictures".Translate()
//// };
//// List<string> booksLibraryNames = new List<string>
//// {
//// "books",
//// "books".Translate(),
//// "text",
//// "text".Translate()
//// };
//// if (musicLibraryNames.Contains(sectionName))
//// {
//// defaultValue = "music";
//// }
//// else if (moviesLibraryNames.Contains(sectionName))
//// {
//// defaultValue = "movies";
//// }
//// else if (musicvideosLibraryNames.Contains(sectionName))
//// {
//// defaultValue = "musicvideos";
//// }
//// else if (tvshowsLibraryNames.Contains(sectionName))
//// {
//// defaultValue = "tvshows";
//// }
//// else if (booksLibraryNames.Contains(sectionName))
//// {
//// defaultValue = "text";
//// }
//// else if (gamesLibraryNames.Contains(sectionName))
//// {
//// defaultValue = "games";
//// }
//// else if (imagesLibraryNames.Contains(sectionName))
//// {
//// defaultValue = "images";
//// }
//// }
// prop.DefaultValue = defaultValue;
// return true;
//}
if (index == i++)
{
prop.Name = "RootFolders2";
prop.Caption = "Root folders";
prop.HelpText = "Select any number of root folders from which to import files";
prop.DataType = "folderlist";
prop.Choices = new string[] { };
return true;
}
if (index == i++)
{
prop.Name = "TagMasks";
prop.Caption = "Tag masks";
prop.HelpText = "Enter one or more tag masks such as <artist>\\<album>\\<track> - <name>.<>" +
Environment.NewLine +
"The 'name' tag is important because it will be used as the item's name, that is showed on the last view step." +
Environment.NewLine +
"So usually your tag masks should at least make sure to fill this tag.";
prop.DataType = "stringlist";
return true;
}
if (index == i++)
{
prop.Name = "ChainFiles";
prop.Caption = "Group/chain files in each directory together";
prop.HelpText =
"If set files in a folder will be added as one item with all the filenames separated by pipes";
prop.Dependencies = "False:::ChainingOptions = 0" + ";;;True:::ChainingOptions = 1";
prop.DataType = "bool";
prop.DefaultValue = false;
return true;
}
if (index == i++)
{
prop.Name = "ChainingOptions";
prop.Caption = "Chaining options";
prop.Choices2["0"] = "Don't group/chain anything".Translate();
prop.Choices2["1"] = "Group/chain files in same folder".Translate();
prop.Choices2["2"] = "Group/chain items with matching tags".Translate();
prop.HelpText =
"If set files in a folder will be added as one item with all the filenames separated by pipes";
prop.Dependencies = "..*:::DISABLE ChainFiles|||HIDE ChainFiles" + ";;;0:::HIDE ChainingTags" +
";;;1:::HIDE ChainingTags" + ";;;2:::SHOW ChainingTags";
prop.DataType = "string";
prop.DefaultValue = "0";
return true;
}
if (index == i++)
{
prop.Name = "ChainingTags";
prop.Caption = "Chaining tags";
prop.HelpText = "The tags used for the \"Group/chain items with matching tags\" chaining option";
prop.DataType = "stringlist";
return true;
}
if (index == i++)
{
prop.Name = "DeleteNonExistentFiles";
prop.Caption = "Delete/Relocate non existent files";
prop.HelpText =
"If set all files of already existing items will be checked. If a file isn't available anymore it is first searched for in other rootfolders." +
Environment.NewLine +
"If found the location just gets replaced with the new one. If not the location gets deleted. If all locations are deleted the item will get deleted." +
Environment.NewLine +
"To prevent deleting the items just because your NAS is currently offline, the items only get deleted if the rootfolder of the item is currently available." +
Environment.NewLine +
"(If you removed the rootfolder from the 'RootFolders' property the items folder is checked instead.)";
prop.DataType = "bool";
prop.DefaultValue = false;
return true;
}
if (index == i++)
{
prop.Name = "AlwaysUpdate";
prop.Caption = "Update all items";
prop.HelpText = "If set all found files will be updated.\r\n" +
"If not only files that were modified since the last import will be updated.";
prop.DataType = "bool";
prop.DefaultValue = false;
return true;
}
if (index == i++)
{
prop.Name = "TagValuesReplacement";
prop.Caption = "Tag values replacement";
prop.HelpText = "Use this option to relace tag values.\r\n" +
"Each line is one replacement rule.\r\n" + "Ex:\r\n" +
"<SeriesName>=Star Trek; The Next Generation (<-?->) <SeriesName>=Star Trek: The Next Generation\r\n" +
"<SeriesName>=Star Trek; Voyager (<-?->) <SeriesName>=Star Trek: Voyager\r\n" +
"\r\n" + "<resolution>=720p (<-?->) <IsHD>=true\r\n" +
"<resolution>=1080p (<-?->) <IsHD>=true (<-:->) <IsHD>=false";
prop.DataType = "customlist";
prop.DefaultValue = new string[] { };
prop.CanTypeChoices = true;
return true;
}
return false;
}
internal static bool MediaImportersProperties
(ImporterProperties importerProperties,
int index, OptionSettings prop,
string[] twochoices, ref int counter)
{
if (index == counter++)
{
//set the internal name
prop.Name = "WantFilesImportingProp";
//set name shown to user
prop.Caption = "Enable Media Importer";
prop.Caption
= TranslationProvider.Translate
(prop.Caption, importerProperties);
prop.GroupName = "MediaImporter";
prop.GroupCaption = " Media Importer";
prop.HelpText =
"The Automated Media Importer will scan the media directories you provide below" +
Environment.NewLine +
"and automatically recognize and import the media files of your desired media types" +
Environment.NewLine +
"in their respective library sections, depending on your preferences.";
prop.DefaultValue = MediaImportersAndUpdatersCoreSettings.EnableMediaImporters;
prop.DataType = "bool";
prop.Dependencies =
"False:HIDE "
+
"WantToImportFilmsProp," +
"WantToImportMusicProp," +
"WantToImportTvSeriesProp," +
"WantMediaInfoProp," +
"WantToImportNewsProp"
+
";False:HIDEGROUP "
+
"MediaAnalyzer,"
+
"MovieTitleLocator,"
+
"RSSimporter"
+
";True:SHOW "
+
"WantToImportFilmsProp," +
"WantToImportMusicProp," +
"WantToImportTvSeriesProp," +
//"WantToImportBooksProp," +
//"WantToImportGamesProp," +
"WantMediaInfoProp," +
"WantToImportNewsProp"
+
";True:SHOWGROUP "
+
"MediaAnalyzer";
return true;
}
#region [DEPRECATED] Media Locations dialog
//if (Index == counter++)
//{
// //set the internal name
// Prop.Name = "ImportRootFolderProp";
// Prop.GroupName = "MediaImporter";
// //set name shown to user
// Prop.Caption = " Media Sources: ";
// //Prop.GroupCaption = " Media Importer";
// //set the tool tip
// //Prop.IsMandatory = true;
// Prop.HelpText = "Please specify the local or network locations which contain the media files you want to import." + Environment.NewLine +
// "These directories can contain mixed media types and also any other type of files." + Environment.NewLine +
// "The built-in media type recognition engine will take care of importing each media file into its appropriate library section.";
// Prop.DefaultValue = Settings.ImportRootFolders;
// Prop.DataType = "folderlist";
// return true;
//}
#endregion
#region Import Media Types
#region Movies
if (index == counter++)
{
//set the internal name
prop.Name = "WantToImportFilmsProp";
prop.GroupName = "MediaImporter";
//set name shown to user
prop.Caption = "Import Films";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
prop.HelpText = " Would you like the Automated Media Importer to import the films it finds in your root folders? ";
prop.DefaultValue = MediaImportersAndUpdatersCoreSettings.EnableMovieImporter;
prop.DataType = "bool";
prop.Dependencies = "False:HIDEGROUP MovieTitleLocator" +
";True:SHOWGROUP MovieTitleLocator";
return true;
}
#endregion
if (MediaSections.FimImportingOptions(importerProperties, index, prop, twochoices, ref counter)) return true;
#region TV Shows
if (index == counter++)
{
//set the internal name
prop.Name = "WantToImportTvSeriesProp";
prop.GroupName = "MediaImporter";
//set name shown to user
prop.Caption = "Import Tv Series";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//Prop.GroupCaption = " Media Importer";
//set the tool tip
prop.HelpText =
"Would you like the Automated Media Importer to import the Tv Series episodes it finds in your root folders?";
prop.DefaultValue = MediaImportersAndUpdatersCoreSettings.EnableTvSeriesImporter;
prop.DataType = "bool";
return true;
}
#endregion
#region Music
if (index == counter++)
{
//set the internal name
prop.Name = "WantToImportMusicProp";
prop.GroupName = "MediaImporter";
//set name shown to user
prop.Caption = "Import Music";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//Prop.GroupCaption = " Media Importer";
//set the tool tip
prop.HelpText =
"Would you like the Automated Media Importer to import the music tracks it finds in your root folders?";
prop.DefaultValue = MediaImportersAndUpdatersCoreSettings.EnableMusicImporter;
prop.DataType = "bool";
return true;
}
#endregion
#region RSS Feeds
if (index == counter++)
{
//set the internal name
prop.Name = "WantToImportNewsProp";
prop.GroupName = "MediaImporter";
//set name shown to user
prop.Caption = "Import RSS feeds";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//Prop.GroupCaption = " Media Importer";
//set the tool tip
prop.HelpText = "Would you like to import RSS newsfeeds?";
prop.DefaultValue = Settings.EnableRssImporter;
prop.DataType = "bool";
prop.Dependencies = "False:HIDEGROUP RSSimporter" +
";True:SHOWGROUP RSSimporter";
return true;
}
#endregion
//FUTURE: PC Games Importer
#region PC Games Importer
//if (index == counter++)
//{
// //set the internal name
// prop.Name = "WantToImportGamesProp";
// prop.GroupName = "MediaImporter";
// //set name shown to user
// prop.Caption = "Import PC games ";
// prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
// //Prop.GroupCaption = " Media Importer";
// //set the tool tip
// prop.HelpText =
// "Would you like the Automated Media Importer to import and download online details for the PC games in your game shortcuts' location?";
// prop.DefaultValue = Settings.EnableGamesImporter;
// prop.DataType = "bool";
// prop.Dependencies = "False:HIDE GameShortcutsProp" +
// ";True:SHOW GameShortcutsProp";
// return true;
//}
#endregion
//FUTURE: Books Importer
#region Books Importer
//if (index == counter++)
//{
// //set the internal name
// prop.Name = "WantToImportBooksProp";
// prop.GroupName = "MediaImporter";
// //set name shown to user
// prop.Caption = "Import Books (reserved for future version) ";
// prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
// //Prop.GroupCaption = " Media Importer";
// //set the tool tip
// prop.HelpText =
// "Would you like the Automated Media Importer to import the digital books it finds in your root folders?";
// prop.DefaultValue = Settings.EnableBooksImporter;
// prop.DataType = "bool";
// return true;
//}
#endregion
#endregion
#region Media Analyzer
if (index == counter++)
{
//set the internal name
prop.Name = "EnableMediaDetectionProp";
prop.GroupName = "MediaAnalyzer";
//set name shown to user
prop.Caption = "Automatically detect media types";
prop.Caption
= TranslationProvider.Translate
(prop.Caption, importerProperties);
prop.GroupCaption = " Media Analyzer";
//set the tool tip
prop.HelpText = " This setting will determine if a media type analyzing process will be performed for each imported media file." + Environment.NewLine +
"This analyzing process provides the media importer the ability to automatically recognize media files and distinguish their media type," + Environment.NewLine +
"without requiring any user configuration and/or manual media collection organizing." + Environment.NewLine +
"Please note however that with this feature enabled, the importing time may be significantly increased the first time you run the importer, especially with online files and/or large media collections." + Environment.NewLine +
"Disabling this feature will improve the importing performance, but you will have to specify the root directories under which each media type is stored (under 'Override Media Analyzer' settings group)," + Environment.NewLine +
"and those diretories will need to *only* contain media files belonging to the selected media type.";
prop.DefaultValue = Settings.EnableMediaDetection;
prop.DataType = "bool";
return true;
}
if (index == counter++)
{
//set the internal name
prop.Name = "RescanFilesNotFoundInLibraryProp";
prop.GroupName = "MediaAnalyzer";
//set name shown to user
prop.Caption = "Re-scan media files missing from library";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
prop.GroupCaption = " Media Analyzer";
//set the tool tip
prop.HelpText =
"This setting determines if media files already scanned (but currently not present in any media section) will be re-scanned and re-imported." +
Environment.NewLine +
"With a slight importing performance impact, this feature will resolve two problems:" + Environment.NewLine +
"1) Items which were removed by mistake will be re-imported." + Environment.NewLine +
"2) If any of the root media folders are set to a downloads location and the download is not completed before MediaFairy scans the media file for the first time," +
Environment.NewLine +
"it may not be detected as a media file and thus not imported." + Environment.NewLine +
"Having this option enabled however will force a re-scan of this media file on all subsequent runs until it is finally analyzed correctly and imported." +
Environment.NewLine +
"If none of the above functionality is needed for your routine usage, you may disable this option for a slight importing performance gain.";
prop.DefaultValue = Settings.RescanFilesNotFoundInLibrary;
prop.DataType = "bool";
return true;
}
if (index == counter++)
{
//set the internal name
prop.Name = "WantMediaInfoProp";
prop.GroupName = "MediaAnalyzer";
//set name shown to user
prop.Caption = "Import media information";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//Prop.GroupCaption = " Media Analyzer";
//set the tool tip
prop.HelpText =
"Modern themes for Meedio frontend have the capability to graphically display digital media information for films or series,\r for example the video/audio format or quality.\r Would you like the plugin to automatically import this information?";
prop.DefaultValue = Settings.MediaInfoIsEnabled;
prop.DataType = "bool";
return true;
}
#endregion
#region RSS Importer
if (index == counter++)
{
//set the internal name
prop.Name = "RssFeedsProp";
prop.GroupName = "RSSimporter";
//set name shown to user
prop.Caption = "RSS feeds to import: ";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
prop.GroupCaption = " RSS Importer";
//set the tool tip
prop.HelpText = "";
prop.DefaultValue = Settings.RsSfeeds;
prop.DataType = "stringlist";
return true;
}
if (index == counter++)
{
//set the internal name
prop.Name = "DownloadFeedImagesProp";
prop.GroupName = "RSSimporter";
//set name shown to user
prop.Caption = "Download feed images";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = "";
prop.DefaultValue = Settings.DownloadRsSimages;
prop.DataType = "bool";
prop.Dependencies = "False:HIDE RSSimagesLocationProp" +
";True:SHOW RSSimagesLocationProp";
return true;
}
if (index == counter++)
{
//set the internal name
prop.Name = "RSSimagesLocationProp";
prop.GroupName = "RSSimporter";
//set name shown to user
prop.Caption = "RSS images location: ";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
prop.HelpText = "";
prop.DefaultValue = Settings.RSSimagesLocation;
prop.DataType = "folder";
return true;
}
#endregion
//if (FileDatesImporterPropertiesGetter
// .GetFileDatesProperties
// (importerProperties, index,
// prop, ref counter))
// return true;
//if (MediaWatcher.MediaWatcherProperties
// (importerProperties, index, prop,
// twochoices, ref counter))
// return true;
//if (ArchiveExtractor
// .ArchiveExtractorPropRerties
// (importerProperties, index,
// prop, ref counter))
// return true;
return false;
}
internal static bool GetPropertyForFilesystemInfo(int index, ref int i, OptionSettings prop)
{
if (index == i++)
{
prop.Name = "FilesystemInfoToggle1";
prop.Caption = String.Empty;
prop.DefaultValue = "Don't import any filesystem info".Translate();
prop.HelpText = "Click to delete all tagnames in the 'Filesystem Info' group." + Environment.NewLine +
"This way these tags don't get imported.";
prop.GroupCaption = "Filesystem Info:";
prop.GroupName = "FilesystemInfo";
prop.Dependencies = "Don't import any filesystem info".Translate() +
":::CreationDateTagName,LastAccessDateTagName,LastModificationDateTagName,FileSizeTagName,SerialNumberTagName,VolumeNameTagName = ";
prop.DataType = "toggle";
return true;
}
if (index == i++)
{
prop.Name = "FilesystemInfoToggle2";
prop.Caption = String.Empty;
prop.DefaultValue = "Reset tagnames".Translate();
prop.HelpText =
"Click to set all the tagnames in the 'Filesystem Info' group to their defaultvalues." +
Environment.NewLine + "This way all 'filesystem info' will be saved in the default tags.";
prop.GroupName = "FilesystemInfo";
prop.Dependencies = "Reset tagnames".Translate() +
":::DEFAULT CreationDateTagName,LastAccessDateTagName,LastModificationDateTagName,FileSizeTagName,SerialNumberTagName,VolumeNameTagName";
prop.DataType = "toggle";
return true;
}
if (index == i++)
{
prop.Name = "CreationDateTagName";
prop.Caption = "Creation date tag name";
prop.HelpText = "This is the name for the tag the datetime the file was created will be saved to." +
Environment.NewLine + "Leave empty if you don't want to import the creation date.";
prop.DataType = "string";
prop.DefaultValue = "File-Created";
prop.GroupName = "FilesystemInfo";
prop.Dependencies = "default:::CreationDateTagName = " + prop.DefaultValue;
return true;
}
if (index == i++)
{
prop.Name = "LastAccessDateTagName";
prop.Caption = "Last Access tag name";
prop.HelpText =
"This is the name for the tag the datetime the file was last accessed will be saved to." +
Environment.NewLine +
"Leave empty if you don't want to import the datetime the file was last accessed.";
prop.DataType = "string";
prop.DefaultValue = "File-LastAccess";
prop.GroupName = "FilesystemInfo";
prop.Dependencies = "default:::LastAccessDateTagName = " + prop.DefaultValue;
return true;
}
if (index == i++)
{
prop.Name = "LastModificationDateTagName";
prop.Caption = "Last modification tag name";
prop.HelpText =
"This is the name for the tag the datetime of the files last modification will be saved to." +
Environment.NewLine +
"Leave empty if you don't want to import the datetime the file was last modified.";
prop.DataType = "string";
prop.DefaultValue = "File-LastModification";
prop.GroupName = "FilesystemInfo";
prop.Dependencies = "default:::LastModificationDateTagName = " + prop.DefaultValue;
return true;
}
if (index == i++)
{
prop.Name = "FileSizeTagName";
prop.Caption = "Filesize tag name";
prop.HelpText = "This is the name for the tag the size of the file will be saved to." +
Environment.NewLine +
"Leave empty if you don't want to import the size of the file.";
prop.DataType = "string";
prop.DefaultValue = "File-Size";
prop.GroupName = "FilesystemInfo";
prop.Dependencies = "default:::FileSizeTagName = " + prop.DefaultValue;
return true;
}
if (index == i++)
{
prop.Name = "SerialNumberTagName";
prop.Caption = "Serialnumber tag name";
prop.HelpText =
"This is the name for the tag the serialnumber of the drive the file is saved to will be saved to." +
Environment.NewLine + "Leave empty if you don't want to import the serialnumber.";
prop.DataType = "string";
prop.DefaultValue = "File-SerialNumber";
prop.GroupName = "FilesystemInfo";
prop.Dependencies = "default:::SerialNumberTagName = " + prop.DefaultValue;
return true;
}
/*
if(index == i++)
{
prop.Name = "DiscIDTagName";
prop.Caption = "DiscID tag name";
prop.GroupCaption = "Optional info";
prop.HelpText = "This is the name for the tag the discid will be saved to";
prop.DataType = "string";
prop.DefaultValue = "DiscID";
prop.GroupName = "FilesystemInfo";
return true;
}
*/
if (index == i++)
{
prop.Name = "VolumeNameTagName";
prop.Caption = "Volumename tag name";
prop.HelpText =
"This is the name for the tag the volumename of the drive the file is on will be saved to." +
Environment.NewLine + "Leave empty if you don't want to import the volumename.";
prop.DataType = "string";
prop.DefaultValue = "File-VolumeName";
prop.GroupName = "FilesystemInfo";
prop.Dependencies = "default:::VolumeNameTagName = " + prop.DefaultValue;
return true;
}
return false;
}
public OptionsController(IOptions <OptionSettings> settings, IOptions <List <ComplexList> > complex)
{
this.settings = settings.Value;
this.complex = complex.Value;
}
internal static bool GetPropertyForImageAssociation(ImporterPropertiesCore.FileImporterProperties fileImporterProperties,
int index, ref int i, OptionSettings prop)
{
if (index == i++)
{
prop.Name = "AlwaysUpdateImages";
prop.Caption = fileImporterProperties.AlwaysUpdateImagesCaption;
prop.HelpText = fileImporterProperties.AlwaysUpdateImagesHelptext;
prop.DataType = "bool";
prop.DefaultValue = false;
prop.GroupCaption = fileImporterProperties.miscGroupcaption + ":";
prop.GroupName = "ImageAssociationRules";
return true;
}
if (index == i++)
{
prop.Name = "ImageFolder";
prop.Caption = fileImporterProperties.ImageFolderCaption;
prop.HelpText = fileImporterProperties.ImageFolderHelptext;
prop.DataType = "folder";
prop.GroupName = "ImageAssociationRules";
return true;
}
if (index == i++)
{
prop.Name = "FileFolderImage";
prop.Caption = fileImporterProperties.FileFolderImageCaption;
prop.HelpText = fileImporterProperties.FileFolderImageHelptext;
prop.DataType = "string";
prop.Choices = new[]
{
fileImporterProperties.FileFolderImageChoice1.Translate(),
fileImporterProperties.FileFolderImageChoice2.Translate(),
fileImporterProperties.FileFolderImageChoice3.Translate()
};
prop.DefaultValue = fileImporterProperties.FileFolderImageChoice1.Translate();
prop.GroupName = "ImageAssociationRules";
return true;
}
if (index == i++)
{
prop.Name = "ImageFileMasks";
prop.Caption = fileImporterProperties.ImageFileMasksCaption;
prop.HelpText = fileImporterProperties.ImageFileMasksHelptext;
prop.DataType = "string";
prop.CanTypeChoices = true;
prop.Choices = new[] { "<name>.png;<name>.jpg;<name>.jpeg;<name>.bmp", "*.png;*.jpg;*.jpeg;*.bmp" };
prop.DefaultValue = "<name>.png;<name>.jpg;<name>.jpeg;<name>.bmp";
prop.GroupName = "ImageAssociationRules";
return true;
}
if (index == i++)
{
prop.Name = "ImageTagName";
prop.Caption = fileImporterProperties.ImageTagNameCaption;
prop.HelpText = fileImporterProperties.imageTagNameHelptext;
prop.DataType = "string";
prop.DefaultValue = String.Empty;
prop.GroupName = "ImageAssociationRules";
prop.Dependencies = "default:::ImageTagName = " + prop.DefaultValue + ";;;Default:::ImageTagName = " +
prop.DefaultValue + ";;;:::SaveInImageBaseTag = false|||HIDE SaveInImageBaseTag" +
";;;..*:::SHOW SaveInImageBaseTag";
return true;
}
if (index == i++)
{
prop.Name = "ImageCount";
prop.Caption = fileImporterProperties.imageCountCaption;
prop.HelpText = fileImporterProperties.imageCountHelptext;
prop.DataType = "int";
prop.DefaultValue = 1;
prop.GroupName = "ImageAssociationRules";
return true;
}
if (index == i++)
{
prop.Name = "SaveInImageBaseTag";
prop.Caption = fileImporterProperties.SaveInImageBaseTagCaption;
prop.HelpText = fileImporterProperties.SaveInImageBaseTagHelptext;
prop.DataType = "bool";
prop.DefaultValue = false;
prop.GroupName = "ImageAssociationRules";
return true;
}
if (index == i++)
{
prop.Name = "AddImageSearchToggle";
prop.Caption = String.Empty;
prop.DefaultValue = fileImporterProperties.addImageSearchToggleDefault.Translate();
prop.HelpText = fileImporterProperties.addImageSearchToggleHelptext;
prop.GroupName = "ImageAssociationRules";
prop.Dependencies = fileImporterProperties
.addImageSearchToggleDefault.Translate()
+ ":::ImageSearchActive2 = true";
prop.DataType = "toggle";
return true;
}
if (index == i++)
{
prop.Name = "ImageSearchActive2";
prop.Caption = String.Empty;
prop.HelpText = String.Empty;
prop.DataType = "bool";
prop.DefaultValue = false;
prop.GroupCaption = fileImporterProperties.miscGroupcaption + " 2:";
prop.GroupName = "ImageAssociationRules2";
prop.Dependencies =
"True:::SHOWGROUP ImageAssociationRules2|||HIDE AddImageSearchToggle|||HIDE ImageSearchActive2;;;False:::HIDEGROUP ImageAssociationRules2|||SHOW AddImageSearchToggle|||HIDE ImageSearchActive2";
return true;
}
if (index == i++)
{
prop.Name = "ImageFolder2";
prop.Caption = fileImporterProperties.ImageFolderCaption;
prop.HelpText = fileImporterProperties.ImageFolderHelptext;
prop.DataType = "folder";
prop.GroupName = "ImageAssociationRules2";
return true;
}
if (index == i++)
{
prop.Name = "FileFolderImage2";
prop.Caption = fileImporterProperties.FileFolderImageCaption;
prop.HelpText = fileImporterProperties.FileFolderImageHelptext;
prop.DataType = "string";
prop.Choices = new[]
{
fileImporterProperties.FileFolderImageChoice1.Translate(), fileImporterProperties.FileFolderImageChoice2.Translate(),
fileImporterProperties.FileFolderImageChoice3.Translate()
};
prop.DefaultValue = fileImporterProperties.FileFolderImageChoice1.Translate();
prop.GroupName = "ImageAssociationRules2";
return true;
}
if (index == i++)
{
prop.Name = "ImageFileMasks2";
prop.Caption = fileImporterProperties.ImageFileMasksCaption;
prop.HelpText = fileImporterProperties.ImageFileMasksHelptext;
prop.DataType = "string";
prop.CanTypeChoices = true;
prop.Choices = new[] { "<name>.png;<name>.jpg;<name>.jpeg;<name>.bmp", "*.png;*.jpg;*.jpeg;*.bmp" };
prop.DefaultValue = "<name>.*";
prop.GroupName = "ImageAssociationRules2";
return true;
}
if (index == i++)
{
prop.Name = "ImageTagName2";
prop.Caption = fileImporterProperties.ImageTagNameCaption;
prop.HelpText = fileImporterProperties.imageTagNameHelptext;
prop.DataType = "string";
prop.DefaultValue = "Fanart";
prop.GroupName = "ImageAssociationRules2";
prop.Dependencies = "default:::ImageTagName2 = " + prop.DefaultValue +
";;;Default:::ImageTagName2 = " + prop.DefaultValue +
";;;:::SaveInImageBaseTag2 = false|||HIDE SaveInImageBaseTag2" +
";;;..*:::SHOW SaveInImageBaseTag2";
return true;
}
if (index == i++)
{
prop.Name = "ImageCount2";
prop.Caption = fileImporterProperties.imageCountCaption;
prop.HelpText = fileImporterProperties.imageCountHelptext;
prop.DataType = "int";
prop.DefaultValue = 1;
prop.GroupName = "ImageAssociationRules2";
return true;
}
if (index == i++)
{
prop.Name = "SaveInImageBaseTag2";
prop.Caption = fileImporterProperties.SaveInImageBaseTagCaption;
prop.HelpText = fileImporterProperties.SaveInImageBaseTagHelptext;
prop.DataType = "bool";
prop.DefaultValue = false;
prop.GroupName = "ImageAssociationRules2";
return true;
}
if (index == i++)
{
prop.Name = "RemoveImageSearchToggle2";
prop.Caption = String.Empty;
prop.DefaultValue = fileImporterProperties.RemoveImageSearchToggleDefault.Translate();
prop.HelpText = fileImporterProperties.RemoveImageSearchToggleHelptext;
prop.Dependencies = fileImporterProperties.RemoveImageSearchToggleDefault.Translate() +
":::ImageSearchActive2 = false";
prop.DataType = "toggle";
prop.GroupName = "ImageAssociationRules2";
return true;
}
if (index == i++)
{
prop.Name = "AddImageSearchToggle2";
prop.Caption = String.Empty;
prop.DefaultValue = fileImporterProperties.addImageSearchToggleDefault.Translate();
prop.HelpText = fileImporterProperties.addImageSearchToggleHelptext;
prop.GroupName = "ImageAssociationRules2";
prop.Dependencies = fileImporterProperties.addImageSearchToggleDefault.Translate() + ":::ImageSearchActive3 = true";
prop.DataType = "toggle";
return true;
}
if (index == i++)
{
prop.Name = "ImageSearchActive3";
prop.Caption = String.Empty;
prop.HelpText = String.Empty;
prop.DataType = "bool";
prop.DefaultValue = false;
prop.GroupCaption = fileImporterProperties.miscGroupcaption + " 3:";
prop.GroupName = "ImageAssociationRules3";
prop.Dependencies =
"True:::SHOWGROUP ImageAssociationRules3|||HIDE AddImageSearchToggle2|||HIDE ImageSearchActive3;;;False:::HIDEGROUP ImageAssociationRules3|||SHOW AddImageSearchToggle2|||HIDE ImageSearchActive3";
return true;
}
if (index == i++)
{
prop.Name = "ImageFolder3";
prop.Caption = fileImporterProperties.ImageFolderCaption;
prop.HelpText = fileImporterProperties.ImageFolderHelptext;
prop.DataType = "folder";
prop.GroupName = "ImageAssociationRules3";
return true;
}
if (index == i++)
{
prop.Name = "FileFolderImage3";
prop.Caption = fileImporterProperties.FileFolderImageCaption;
prop.HelpText = fileImporterProperties.FileFolderImageHelptext;
prop.DataType = "string";
prop.Choices = new[]
{
fileImporterProperties.FileFolderImageChoice1.Translate(), fileImporterProperties.FileFolderImageChoice2.Translate(),
fileImporterProperties.FileFolderImageChoice3.Translate()
};
prop.DefaultValue = fileImporterProperties.FileFolderImageChoice1.Translate();
prop.GroupName = "ImageAssociationRules3";
return true;
}
if (index == i++)
{
prop.Name = "ImageFileMasks3";
prop.Caption = fileImporterProperties.ImageFileMasksCaption;
prop.HelpText = fileImporterProperties.ImageFileMasksHelptext;
prop.DataType = "string";
prop.CanTypeChoices = true;
prop.Choices = new[] { "<name>.png;<name>.jpg;<name>.jpeg;<name>.bmp", "*.png;*.jpg;*.jpeg;*.bmp" };
prop.DefaultValue = "<SeriesID>-<SeasonNumber>.*";
prop.GroupName = "ImageAssociationRules3";
return true;
}
if (index == i++)
{
prop.Name = "ImageTagName3";
prop.Caption = fileImporterProperties.ImageTagNameCaption;
prop.HelpText = fileImporterProperties.imageTagNameHelptext;
prop.DataType = "string";
prop.DefaultValue = "SeasonImage";
prop.GroupName = "ImageAssociationRules3";
prop.Dependencies = "default:::ImageTagName3 = " + prop.DefaultValue +
";;;Default:::ImageTagName3 = " + prop.DefaultValue +
";;;:::SaveInImageBaseTag3 = false|||HIDE SaveInImageBaseTag3" +
";;;..*:::SHOW SaveInImageBaseTag3";
return true;
}
if (index == i++)
{
prop.Name = "ImageCount3";
prop.Caption = fileImporterProperties.imageCountCaption;
prop.HelpText = fileImporterProperties.imageCountHelptext;
prop.DataType = "int";
prop.DefaultValue = 1;
prop.GroupName = "ImageAssociationRules3";
return true;
}
if (index == i++)
{
prop.Name = "SaveInImageBaseTag3";
prop.Caption = fileImporterProperties.SaveInImageBaseTagCaption;
prop.HelpText = fileImporterProperties.SaveInImageBaseTagHelptext;
prop.DataType = "bool";
prop.DefaultValue = false;
prop.GroupName = "ImageAssociationRules3";
return true;
}
if (index == i++)
{
prop.Name = "RemoveImageSearchToggle3";
prop.Caption = String.Empty;
prop.DefaultValue = fileImporterProperties.RemoveImageSearchToggleDefault.Translate();
prop.HelpText = fileImporterProperties.RemoveImageSearchToggleHelptext;
prop.Dependencies = fileImporterProperties.RemoveImageSearchToggleDefault.Translate() +
":::ImageSearchActive3 = false";
prop.DataType = "toggle";
prop.GroupName = "ImageAssociationRules3";
return true;
}
if (index == i++)
{
prop.Name = "AddImageSearchToggle3";
prop.Caption = String.Empty;
prop.DefaultValue = fileImporterProperties.addImageSearchToggleDefault.Translate();
prop.HelpText = fileImporterProperties.addImageSearchToggleHelptext;
prop.GroupName = "ImageAssociationRules3";
prop.Dependencies = fileImporterProperties.addImageSearchToggleDefault.Translate() + ":::ImageSearchActive4 = true";
prop.DataType = "toggle";
return true;
}
if (index == i++)
{
prop.Name = "ImageSearchActive4";
prop.Caption = String.Empty;
prop.HelpText = String.Empty;
prop.DataType = "bool";
prop.DefaultValue = false;
prop.GroupCaption = fileImporterProperties.miscGroupcaption + " 4:";
prop.GroupName = "ImageAssociationRules4";
prop.Dependencies =
"True:::SHOWGROUP ImageAssociationRules4|||HIDE AddImageSearchToggle3|||HIDE ImageSearchActive4;;;False:::HIDEGROUP ImageAssociationRules4|||SHOW AddImageSearchToggle3|||HIDE ImageSearchActive4";
return true;
}
if (index == i++)
{
prop.Name = "ImageFolder4";
prop.Caption = fileImporterProperties.ImageFolderCaption;
prop.HelpText = fileImporterProperties.ImageFolderHelptext;
prop.DataType = "folder";
prop.GroupName = "ImageAssociationRules4";
return true;
}
if (index == i++)
{
prop.Name = "FileFolderImage4";
prop.Caption = fileImporterProperties.FileFolderImageCaption;
prop.HelpText = fileImporterProperties.FileFolderImageHelptext;
prop.DataType = "string";
prop.Choices = new[]
{
fileImporterProperties.FileFolderImageChoice1.Translate(), fileImporterProperties.FileFolderImageChoice2.Translate(),
fileImporterProperties.FileFolderImageChoice3.Translate()
};
prop.DefaultValue = fileImporterProperties.FileFolderImageChoice1.Translate();
prop.GroupName = "ImageAssociationRules4";
return true;
}
if (index == i++)
{
prop.Name = "ImageFileMasks4";
prop.Caption = fileImporterProperties.ImageFileMasksCaption;
prop.HelpText = fileImporterProperties.ImageFileMasksHelptext;
prop.DataType = "string";
prop.CanTypeChoices = true;
prop.Choices = new[] { "<name>.png;<name>.jpg;<name>.jpeg;<name>.bmp", "*.png;*.jpg;*.jpeg;*.bmp" };
prop.DefaultValue = "<SeriesID>.*";
prop.GroupName = "ImageAssociationRules4";
return true;
}
if (index == i++)
{
prop.Name = "ImageTagName4";
prop.Caption = fileImporterProperties.ImageTagNameCaption;
prop.HelpText = fileImporterProperties.imageTagNameHelptext;
prop.DataType = "string";
prop.DefaultValue = "SeriesPoster";
prop.GroupName = "ImageAssociationRules4";
prop.Dependencies = "default:::ImageTagName4 = " + prop.DefaultValue +
";;;Default:::ImageTagName4 = " + prop.DefaultValue +
";;;:::SaveInImageBaseTag4 = false|||HIDE SaveInImageBaseTag4" +
";;;..*:::SHOW SaveInImageBaseTag4";
return true;
}
if (index == i++)
{
prop.Name = "ImageCount4";
prop.Caption = fileImporterProperties.imageCountCaption;
prop.HelpText = fileImporterProperties.imageCountHelptext;
prop.DataType = "int";
prop.DefaultValue = 1;
prop.GroupName = "ImageAssociationRules4";
return true;
}
if (index == i++)
{
prop.Name = "SaveInImageBaseTag4";
prop.Caption = fileImporterProperties.SaveInImageBaseTagCaption;
prop.HelpText = fileImporterProperties.SaveInImageBaseTagHelptext;
prop.DataType = "bool";
prop.DefaultValue = false;
prop.GroupName = "ImageAssociationRules4";
return true;
}
if (index == i++)
{
prop.Name = "RemoveImageSearchToggle4";
prop.Caption = String.Empty;
prop.DefaultValue = fileImporterProperties.RemoveImageSearchToggleDefault.Translate();
prop.HelpText = fileImporterProperties.RemoveImageSearchToggleHelptext;
prop.Dependencies = fileImporterProperties.RemoveImageSearchToggleDefault.Translate() +
":::ImageSearchActive4 = false";
prop.DataType = "toggle";
prop.GroupName = "ImageAssociationRules4";
return true;
}
if (index == i++)
{
prop.Name = "AddImageSearchToggle4";
prop.Caption = String.Empty;
prop.DefaultValue = fileImporterProperties.addImageSearchToggleDefault.Translate();
prop.HelpText = fileImporterProperties.addImageSearchToggleHelptext;
prop.GroupName = "ImageAssociationRules4";
prop.Dependencies = fileImporterProperties.addImageSearchToggleDefault.Translate() + ":::ImageSearchActive5 = true";
prop.DataType = "toggle";
return true;
}
if (index == i++)
{
prop.Name = "ImageSearchActive5";
prop.Caption = String.Empty;
prop.HelpText = String.Empty;
prop.DataType = "bool";
prop.DefaultValue = false;
prop.GroupCaption = fileImporterProperties.miscGroupcaption + " 5:";
prop.GroupName = "ImageAssociationRules5";
prop.Dependencies =
"True:::SHOWGROUP ImageAssociationRules5|||HIDE AddImageSearchToggle4|||HIDE ImageSearchActive5;;;False:::HIDEGROUP ImageAssociationRules5|||SHOW AddImageSearchToggle4|||HIDE ImageSearchActive5";
return true;
}
if (index == i++)
{
prop.Name = "ImageFolder5";
prop.Caption = fileImporterProperties.ImageFolderCaption;
prop.HelpText = fileImporterProperties.ImageFolderHelptext;
prop.DataType = "folder";
prop.GroupName = "ImageAssociationRules5";
return true;
}
if (index == i++)
{
prop.Name = "FileFolderImage5";
prop.Caption = fileImporterProperties.FileFolderImageCaption;
prop.HelpText = fileImporterProperties.FileFolderImageHelptext;
prop.DataType = "string";
prop.Choices = new[]
{
fileImporterProperties.FileFolderImageChoice1.Translate(), fileImporterProperties.FileFolderImageChoice2.Translate(),
fileImporterProperties.FileFolderImageChoice3.Translate()
};
prop.DefaultValue = fileImporterProperties.FileFolderImageChoice1.Translate();
prop.GroupName = "ImageAssociationRules5";
return true;
}
if (index == i++)
{
prop.Name = "ImageFileMasks5";
prop.Caption = fileImporterProperties.ImageFileMasksCaption;
prop.HelpText = fileImporterProperties.ImageFileMasksHelptext;
prop.DataType = "string";
prop.CanTypeChoices = true;
prop.Choices = new[] { "<name>.png;<name>.jpg;<name>.jpeg;<name>.bmp", "*.png;*.jpg;*.jpeg;*.bmp" };
prop.DefaultValue = "<SeriesID>.*";
prop.GroupName = "ImageAssociationRules5";
return true;
}
if (index == i++)
{
prop.Name = "ImageTagName5";
prop.Caption = fileImporterProperties.ImageTagNameCaption;
prop.HelpText = fileImporterProperties.imageTagNameHelptext;
prop.DataType = "string";
prop.DefaultValue = "SeriesBanner";
prop.GroupName = "ImageAssociationRules5";
prop.Dependencies = "default:::ImageTagName5 = " + prop.DefaultValue +
";;;Default:::ImageTagName5 = " + prop.DefaultValue +
";;;:::SaveInImageBaseTag5 = false|||HIDE SaveInImageBaseTag5" +
";;;..*:::SHOW SaveInImageBaseTag5";
return true;
}
if (index == i++)
{
prop.Name = "ImageCount5";
prop.Caption = fileImporterProperties.imageCountCaption;
prop.HelpText = fileImporterProperties.imageCountHelptext;
prop.DataType = "int";
prop.DefaultValue = 1;
prop.GroupName = "ImageAssociationRules5";
return true;
}
if (index == i++)
{
prop.Name = "SaveInImageBaseTag5";
prop.Caption = fileImporterProperties.SaveInImageBaseTagCaption;
prop.HelpText = fileImporterProperties.SaveInImageBaseTagHelptext;
prop.DataType = "bool";
prop.DefaultValue = false;
prop.GroupName = "ImageAssociationRules5";
return true;
}
if (index == i++)
{
prop.Name = "RemoveImageSearchToggle5";
prop.Caption = String.Empty;
prop.DefaultValue = fileImporterProperties.RemoveImageSearchToggleDefault.Translate();
prop.HelpText = fileImporterProperties.RemoveImageSearchToggleHelptext;
prop.Dependencies = fileImporterProperties.RemoveImageSearchToggleDefault.Translate() +
":::ImageSearchActive5 = false";
prop.DataType = "toggle";
prop.GroupName = "ImageAssociationRules5";
return true;
}
return false;
}
private bool GetPropertyForDebugging(int index, int i,
OptionSettings prop)
{
if (index == i)
{
prop.Name = "DebugLevel";
prop.Caption = "Debug level";
prop.HelpText = "If not set to 'Off' a log file will be created." + Environment.NewLine +
"The debug level defines what messages get written. (Higher levels include the lower levels.)";
prop.Choices = new[] { "Off", "Warn", "Info", "Debug" };
prop.DataType = "string";
prop.DefaultValue = "Off";
prop.GroupCaption = "Debugging";
prop.GroupName = "Debugging";
if (fileImporter.IsFirstLoad)
{
prop.Dependencies = ".*:::UPDATE MediaType";
}
return true;
}
return false;
}
public void Init()
{
NUnitRegistry.TestMode = true;
NUnitRegistry.ClearTestKeys();
opts = UserSettings.Options;
}
internal static bool MediaWatcherProperties
(ImporterProperties importerProperties,
int index, OptionSettings prop,
string[] twochoices, ref int counter)
{
#region Media Watcher
if (index == counter++)
{
//set the internal name
prop.Name = "EnableMediaWatcherProp";
prop.GroupName = "MediaWatcher";
//set name shown to user
prop.Caption = "Enable Media Watcher?";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
prop.GroupCaption = " Media Watcher";
//set the tool tip
//TODO: Add help tooltip
prop.HelpText = "";
prop.DefaultValue = Settings.MediaWatcherEnabled;
prop.DataType = "bool";
prop.Dependencies =
"False:HIDE UseRootFoldersAsDirsToWatchProp,DirectoriesToWatchProp,IncludeSubdirectoriesProp,ItemsAdditionModeProp,UseAutoSorterForMediaWatcherProp" +
";True:SHOW UseRootFoldersAsDirsToWatchProp,IncludeSubdirectoriesProp,ItemsAdditionModeProp,UseAutoSorterForMediaWatcherProp";
return true;
}
if (index == counter++)
{
//set the internal name
prop.Name = "UseRootFoldersAsDirsToWatchProp";
prop.GroupName = "MediaWatcher";
//set name shown to user
prop.Caption = "Use Root media folders as directories to watch";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
//TODO: Add help tooltip
prop.HelpText = "";
prop.DefaultValue = Settings.UseRootFoldersAsDirsToWatch;
prop.DataType = "bool";
prop.Dependencies = "False:SHOW DirectoriesToWatchProp" +
";True:HIDE DirectoriesToWatchProp";
return true;
}
if (index == counter++)
{
//set the internal name
prop.Name = "DirectoriesToWatchProp";
prop.GroupName = "MediaWatcher";
//set name shown to user
prop.Caption = "Directories to Watch: ";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
//TODO: Add help tooltip
prop.HelpText = "";
prop.DefaultValue = Settings.DirectoriesToWatch;
prop.DataType = "folder";
//Prop.Dependencies = "False:SHOW AnalyzerOverrides" +
//";True:HIDE AnalyzerOverrides";
return true;
}
if (index == counter++)
{
//set the internal name
prop.Name = "IncludeSubdirectoriesProp";
prop.GroupName = "MediaWatcher";
//set name shown to user
prop.Caption = "Include subdirectories";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
//TODO: Add help tooltip
prop.HelpText = "";
prop.DefaultValue = Settings.IncludeSubdirectories;
prop.DataType = "bool";
return true;
}
if (index == counter++)
{
//set the internal name
prop.Name = "ItemsAdditionModeProp";
prop.GroupName = "MediaWatcher";
//set name shown to user
prop.Caption = "Addition Mode for new items: ";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
//TODO: Add help tooltip
prop.HelpText = "";
prop.DefaultValue = Settings.ItemsAdditionMode;
prop.DataType = "string";
twochoices[0] = "Import Only";
twochoices[1] = "Import and Update";
prop.CanTypeChoices = false;
prop.Choices = twochoices;
prop.IsMandatory = false;
//Prop.Dependencies = "in the movie's folder:HIDE PosterFolderProp" +
//";in the folder i specify below:SHOW PosterFolderProp";
return true;
}
if (index == counter++)
{
//set the internal name
prop.Name = "UseAutoSorterForMediaWatcherProp";
prop.GroupName = "MediaWatcher";
//set name shown to user
prop.Caption = "Organize imported files using Media Organizer settings";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
//set the tool tip
//TODO: Add help tooltip
prop.HelpText = "";
prop.DefaultValue = Settings.UseAutoSorterForMediaWatcher;
prop.DataType = "bool";
return true;
}
#endregion
return false;
}//endof function
internal static bool GetFilmBackdropsLocationProperties
(ImporterProperties importerProperties, int index, OptionSettings prop,
string[] twochoices, ref int counter)
{
if (index == counter++)
{
//set the internal name
prop.Name = "WhereToSaveBackdropProp";
//set name shown to user
prop.Caption = "Where to store fanart?";
prop.Caption
= TranslationProvider.Translate
(prop.Caption, importerProperties);
//set the tool tip
prop.GroupName = "FilmBackdrops";
prop.GroupCaption = " Film fanart Settings";
prop.HelpText = "Do you want the backdrop/fanart image " +
"for each movie to be saved in the movie's folder" +
" or to a specific folder of your choice?";
prop.DefaultValue = Importer.WhereToSaveBackdrop;
Prop.DataType = "string";
twochoices[0] = "in the movie's folder";
twochoices[1] = "in the folder i specify below";
Prop.Choices = twochoices;
Prop.CanTypeChoices = false;
Prop.Dependencies = "in the movie's folder:HIDE BackdropFolderProp" +
";in the folder i specify below:SHOW BackdropFolderProp";
return true;
}
if (Index == counter++)
{
//set the internal name
Prop.Name = "BackdropFolderProp";
//set name shown to user
Prop.Caption = "Fanart folder: ";
Prop.Caption = TranslationProvider.Translate(Prop.Caption, importerProperties);
Prop.GroupName = "FilmBackdrops";
//set the tool tip
Prop.HelpText =
@"Please specify the folder in which you want downloaded Fanart to be saved. (Only applicabe if option above is *not* set to 'Movie's folder') ";
Prop.DefaultValue = Importer.BackdropFolder;
Prop.DataType = "folder";
Prop.CanTypeChoices = false;
return true;
}
if (Index == counter++)
{
//set the internal name
Prop.Name = "BackdropNamingChoice";
//set name shown to user
Prop.Caption = "Fanart naming convention: (tag mask) ";
Prop.Caption = TranslationProvider.Translate(Prop.Caption, importerProperties);
Prop.GroupName = "FilmBackdrops";
//set the tool tip
Prop.HelpText = "Please enter here your desired fanart naming convention in a form of a tag mask." +
Environment.NewLine +
"For example, the default tag mask '<IMDbID>_backdrop' will store the backdrop image as the varialbe film's IMDb number followed by the '_backdrop' suffix ." +
Environment.NewLine +
"Please make sure that any text strings contained in '<>' refer to the names of existing tags of your Movies media section.";
Prop.DefaultValue = Importer.BackdropNamingMethod;
Prop.DataType = "string";
Prop.CanTypeChoices = true;
return true;
}
if (index == counter++)
{
//set the internal name
prop.Name = "OverwriteBackdropChoice";
//set name shown to user
prop.Caption = "Overwrite existing fanart? ";
prop.Caption = TranslationProvider.Translate(prop.Caption, importerProperties);
prop.GroupName = "FilmBackdrops";
//set the tool tip
prop.HelpText = "If a backdrop already exists" +
" in your specified location, " +
"should MediaFairy to download" +
" a new backdrop and overwrite the original?";
prop.DefaultValue = Importer.OverwriteExistingBackdrops;
prop.DataType = "bool";
return true;
}
return false;
}
/// <param name='setting'>
/// Required.
/// </param>
/// <param name='cancellationToken'>
/// Cancellation token.
/// </param>
public async Task <HttpOperationResponse <object> > PostMentionPushNotificationsBySettingWithOperationResponseAsync(OptionSettings setting, CancellationToken cancellationToken = default(System.Threading.CancellationToken))
{
// Validate
if (setting == null)
{
throw new ArgumentNullException("setting");
}
// Tracing
bool shouldTrace = ServiceClientTracing.IsEnabled;
string invocationId = null;
if (shouldTrace)
{
invocationId = ServiceClientTracing.NextInvocationId.ToString();
Dictionary <string, object> tracingParameters = new Dictionary <string, object>();
tracingParameters.Add("setting", setting);
ServiceClientTracing.Enter(invocationId, this, "PostMentionPushNotificationsBySettingAsync", tracingParameters);
}
// Construct URL
string url = "";
url = url + "/api/Profile/NotifyWhenMentioned";
string baseUrl = this.Client.BaseUri.AbsoluteUri;
// Trim '/' character from the end of baseUrl and beginning of url.
if (baseUrl[baseUrl.Length - 1] == '/')
{
baseUrl = baseUrl.Substring(0, baseUrl.Length - 1);
}
if (url[0] == '/')
{
url = url.Substring(1);
}
url = baseUrl + "/" + url;
url = url.Replace(" ", "%20");
// Create HTTP transport objects
HttpRequestMessage httpRequest = new HttpRequestMessage();
httpRequest.Method = HttpMethod.Post;
httpRequest.RequestUri = new Uri(url);
// Set Headers
// Set Credentials
if (this.Client.Credentials != null)
{
cancellationToken.ThrowIfCancellationRequested();
await this.Client.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false);
}
// Serialize Request
string requestContent = null;
JToken requestDoc = setting.SerializeJson(null);
requestContent = requestDoc.ToString(Newtonsoft.Json.Formatting.Indented);
httpRequest.Content = new StringContent(requestContent, Encoding.UTF8);
httpRequest.Content.Headers.ContentType = MediaTypeHeaderValue.Parse("application/json");
// Send Request
if (shouldTrace)
{
ServiceClientTracing.SendRequest(invocationId, httpRequest);
}
cancellationToken.ThrowIfCancellationRequested();
HttpResponseMessage httpResponse = await this.Client.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false);
if (shouldTrace)
{
ServiceClientTracing.ReceiveResponse(invocationId, httpResponse);
}
HttpStatusCode statusCode = httpResponse.StatusCode;
cancellationToken.ThrowIfCancellationRequested();
string responseContent = await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
if (statusCode != HttpStatusCode.NoContent)
{
HttpOperationException <object> ex = new HttpOperationException <object>();
ex.Request = httpRequest;
ex.Response = httpResponse;
ex.Body = null;
if (shouldTrace)
{
ServiceClientTracing.Error(invocationId, ex);
}
throw ex;
}
// Create Result
HttpOperationResponse <object> result = new HttpOperationResponse <object>();
result.Request = httpRequest;
result.Response = httpResponse;
// Deserialize Response
object resultModel = default(object);
result.Body = resultModel;
if (shouldTrace)
{
ServiceClientTracing.Exit(invocationId, result);
}
return(result);
}
internal static bool MediaSectionsProperties
(int index, OptionSettings prop, string[] sectionChoices, ref int counter)
{
#region Movies Section
if (index == counter++)
{
//set the internal name
prop.Name = "FilmsLibraryProp";
//set name shown to user
prop.Caption = "Please select your Movies library section: ";
//set the tool tip
prop.GroupName = "MediaSections";
prop.GroupCaption = " Media Sections Configuration";
//Prop.IsMandatory = true;
prop.HelpText =
"Please select your Movies library section from the list of available library sections.";
prop.DefaultValue = Settings.FilmsLibrary;
prop.DataType = "string";
//Prop.IsMandatory = true;
//MessageBox.Show("Sections= " + MeedioLibrary.SectionCount);
prop.Choices = sectionChoices;
prop.CanTypeChoices = false;
return true;
}
#endregion
if (index == counter++)
{
//set the internal name
prop.Name = "TvShowsLibraryProp";
//set name shown to user
prop.GroupName = "MediaSections";
prop.Caption = "Please select your TV Episodes library section: ";
//Prop.IsMandatory = true;
prop.HelpText =
"Please select your TV Episodes library section from the list of available library sections.";
prop.DefaultValue = Settings.TvShowsLibrary;
prop.DataType = "string";
//MessageBox.Show("Sections= " + MeedioLibrary.SectionCount);
prop.Choices = sectionChoices;
prop.CanTypeChoices = false;
return true;
}
if (index == counter++)
{
//set the internal name
prop.Name = "MusicLibraryProp";
//set name shown to user
prop.GroupName = "MediaSections";
//Prop.GroupCaption = " Media Sections";
prop.Caption = "Please select your Music library section: ";
//Prop.IsMandatory = true;
//set the tool tip
prop.HelpText =
"Please select your Music library section from the list of available library sections.";
prop.DefaultValue = Settings.MusicLibrary;
prop.DataType = "string";
//Prop.IsMandatory = true;
//MessageBox.Show("Sections= " + MeedioLibrary.SectionCount);
prop.Choices = sectionChoices;
prop.CanTypeChoices = false;
return true;
}
if (index == counter++)
{
//set the internal name
prop.Name = "NewsLibraryProp";
//set name shown to user
prop.GroupName = "MediaSections";
//Prop.GroupCaption = " Media Sections";
prop.Caption = "Please select your RSS News Section: ";
//Prop.IsMandatory = true;
//set the tool tip
prop.HelpText =
"Please select your RSS News library section from the list of available library sections.";
prop.DefaultValue = Settings.NewsLibrary;
prop.DataType = "string";
//Prop.IsMandatory = true;
//MessageBox.Show("Sections= " + MeedioLibrary.SectionCount);
prop.Choices = sectionChoices;
prop.CanTypeChoices = false;
return true;
}
#region [DEPRECATED] e-Books Section
//if (index == counter++)
//{
// //set the internal name
// prop.Name = "BooksLibraryProp";
// //set name shown to user
// prop.GroupName = "MediaSections";
// //Prop.GroupCaption = " Media Sections";
// prop.Caption = "Please select your e-Books Section: ";
// //Prop.IsMandatory = true;
// //set the tool tip
// prop.HelpText =
// "Please select your Books Section from the provided list. If you don't want MediaFairy to update this library, just uncheck the 'Update Books Section' option.";
// prop.DefaultValue = Settings.BooksLibrary;
// prop.DataType = "string";
// //Prop.IsMandatory = true;
// //MessageBox.Show("Sections= " + MeedioLibrary.SectionCount);
// prop.Choices = sectionChoices;
// prop.CanTypeChoices = false;
// return true;
//}
#endregion
#region [DEPRECATED] Games Section
//if (index == counter++)
//{
// //set the internal name
// prop.Name = "GamesLibraryProp";
// //set name shown to user
// prop.GroupName = "MediaSections";
// //Prop.GroupCaption = " Media Sections";
// prop.Caption = "Please select your Games Section: ";
// //Prop.IsMandatory = true;
// //set the tool tip
// prop.HelpText =
// "Please select your Games Section from the provided list. If you don't want MediaFairy to update this library, just uncheck the 'Import and update Games' option.";
// prop.DefaultValue = Settings.GamesLibrary;
// prop.DataType = "string";
// //Prop.IsMandatory = true;
// //MessageBox.Show("Sections= " + MeedioLibrary.SectionCount);
// prop.Choices = sectionChoices;
// prop.CanTypeChoices = false;
// return true;
//}
#endregion
return false;
}
