protected static ConfigSectionMetadata BuildSection(PluginItemMetadata itemData, PluginRuntime plugin) { string location = ConfigBaseMetadata.ConcatLocations(itemData.RegistrationLocation, itemData.Id); string text = null; string iconSmallPath = null; string iconLargePath = null; foreach (KeyValuePair<string, string> attr in itemData.Attributes) { switch (attr.Key) { case "Text": text = attr.Value; break; case "IconSmallPath": iconSmallPath = attr.Value; break; case "IconLargePath": iconLargePath = attr.Value; break; default: throw new ArgumentException("'ConfigSection' builder doesn't define an attribute '" + attr.Key + "'"); } } if (text == null) throw new ArgumentException("'ConfigSection' item needs an attribute 'Text'"); return new ConfigSectionMetadata(location, text, plugin.Metadata.GetAbsolutePath(iconSmallPath), plugin.Metadata.GetAbsolutePath(iconLargePath)); }
public object BuildItem(PluginItemMetadata itemData, PluginRuntime plugin) { BuilderHelper.CheckParameter("ClassName", itemData); BuilderHelper.CheckParameter("ProviderName", itemData); BuilderHelper.CheckParameter("Priority", itemData); return new ThumbnailProviderRegistration(plugin.GetPluginType(itemData.Attributes["ClassName"]), itemData.Id, itemData.Attributes["ProviderName"], itemData.Attributes["Priority"]); }
/// <summary> /// Registers the specified plugin item in the plugin tree. /// </summary> /// <param name="itemMetadata">Metadata structure of the item to register.</param> /// <returns><c>true</c>, if the plugin item could be registered, <c>false</c>, /// if the item already existed and <see cref="PluginItemMetadata.IsRedundant"/> is specified.</returns> /// <exception cref="ArgumentException">If there is already an item registered at the registration /// location and the <see cref="PluginItemMetadata.IsRedundant"/> flag is not set.</exception> internal bool RegisterItem(PluginItemMetadata itemMetadata) { lock (_syncObj) { IRegistryNode node = GetRegistryNode(itemMetadata.RegistrationLocation, true); itemMetadata.PluginRuntime = this; if (node.Items != null && node.Items.ContainsKey(itemMetadata.Id)) { if (itemMetadata.IsRedundant) { PluginItemRegistration itemRegistration = (PluginItemRegistration)node.Items[itemMetadata.Id]; itemRegistration.AdditionalRedundantItemsMetadata.Add(itemMetadata); return(false); } else { throw new ArgumentException(string.Format("At location '{0}', a plugin item with id '{1}' is already registered", itemMetadata.RegistrationLocation, itemMetadata.Id)); } } PluginItemRegistration resultItemRegistration = new PluginItemRegistration(itemMetadata); node.AddItem(itemMetadata.Id, resultItemRegistration); _itemRegistrations.Add(itemMetadata, resultItemRegistration); } return(true); }
public object BuildItem(PluginItemMetadata itemData, PluginRuntime plugin) { BuilderHelper.CheckParameter("ClassName", itemData); BuilderHelper.CheckParameter("Caption", itemData); BuilderHelper.CheckParameter("Sort", itemData); return new MediaItemActionExtension(plugin.GetPluginType(itemData.Attributes["ClassName"]), itemData.Attributes["Caption"], itemData.Attributes["Sort"], itemData.Id); }
/// <summary> /// Unregisters the specified plugin item from the plugin tree. /// </summary> /// <param name="itemMetadata">Meta data structure of the item to unregister.</param> /// <returns>Plugin item registration structure of the item to be unregistered.</returns> internal void UnregisterItem(PluginItemMetadata itemMetadata) { lock (_syncObj) try { IRegistryNode node = GetRegistryNode(itemMetadata.RegistrationLocation, false); if (node == null || node.Items == null) { return; } if (node.Items.ContainsKey(itemMetadata.Id)) { PluginItemRegistration itemRegistration = (PluginItemRegistration)node.Items[itemMetadata.Id]; // Check, if there are additional redundant items registered at this position. If yes, we'll use // the first of them instead of the old item to be unregistered. PluginItemMetadata newItemMetadata = null; IEnumerator <PluginItemMetadata> enumerator = itemRegistration.AdditionalRedundantItemsMetadata.GetEnumerator(); if (enumerator.MoveNext()) { newItemMetadata = enumerator.Current; itemRegistration.AdditionalRedundantItemsMetadata.Remove(newItemMetadata); } node.Items.Remove(itemMetadata.Id); if (newItemMetadata != null) { newItemMetadata.PluginRuntime.RegisterItem(newItemMetadata); } } } finally { _itemRegistrations.Remove(itemMetadata); } }
public object BuildItem(PluginItemMetadata itemData, PluginRuntime plugin) { BuilderHelper.CheckParameter("ServiceClassName", itemData); string serviceClassName = itemData.Attributes["ServiceClassName"]; object serviceInstance = plugin.InstantiatePluginObject(serviceClassName); if (serviceInstance == null) { ServiceRegistration.Get<ILogger>().Warn("ServiceBuilder: Could not instantiate service class '{0}' in plugin '{1}' (id: '{2}')", serviceClassName, itemData.PluginRuntime.Metadata.Name, itemData.PluginRuntime.Metadata.PluginId); return null; } string registrationClassAssembly; if (!itemData.Attributes.TryGetValue("RegistrationClassAssembly", out registrationClassAssembly)) registrationClassAssembly = null; string registrationClassName; if (!itemData.Attributes.TryGetValue("RegistrationClassName", out registrationClassName)) registrationClassName = null; Type registrationType; if (string.IsNullOrEmpty(registrationClassName)) registrationType = serviceInstance.GetType(); else registrationType = string.IsNullOrEmpty(registrationClassAssembly) ? plugin.GetPluginType(registrationClassName) : Type.GetType(registrationClassName + ", " + registrationClassAssembly); if (registrationType == null) { ServiceRegistration.Get<ILogger>().Warn("ServiceBuilder: Could not instantiate service registration type '{0}' (Assembly: '{1}') in plugin '{2}' (id: '{3}')", registrationClassName, registrationClassAssembly, itemData.PluginRuntime.Metadata.Name, itemData.PluginRuntime.Metadata.PluginId); return null; } return new ServiceItem(registrationType, serviceInstance); }
public static void CheckParameter(string parameterName, PluginItemMetadata itemData) { if (!itemData.Attributes.ContainsKey(parameterName)) throw new PluginItemBuildException( "'{0}' item at registration location '{1}' needs to specify the '{2}' parameter", itemData.BuilderName, itemData.RegistrationLocation, parameterName); }
public object BuildItem(PluginItemMetadata itemData, PluginRuntime plugin) { BuilderHelper.CheckParameter("Type", itemData); BuilderHelper.CheckParameter("Directory", itemData); return new PluginResource( (PluginResourceType) Enum.Parse(typeof (PluginResourceType), itemData.Attributes["Type"]), plugin.Metadata.GetAbsolutePath(itemData.Attributes["Directory"])); }
public void RevokeItem(object item, PluginItemMetadata itemData, PluginRuntime plugin) { BackgroundType type; string typeName = GetBackgroundAndType(itemData.Attributes, out type); switch (type) { case BackgroundType.Manager: plugin.RevokePluginObject(typeName); break; } }
public object BuildItem(PluginItemMetadata itemData, PluginRuntime plugin) { BackgroundType type; string value = GetBackgroundAndType(itemData.Attributes, out type); switch (type) { case BackgroundType.Static: return new StaticBackgroundManager(value); case BackgroundType.Manager: // The cast is necessary here to ensure the returned instance is an IBackgroundManager return (IBackgroundManager) plugin.InstantiatePluginObject(value); default: throw new NotImplementedException(string.Format( "Background builder: Background type '{0}' is not implemented", type)); } }
public object BuildItem(PluginItemMetadata itemData, PluginRuntime plugin) { BuilderHelper.CheckParameter("ClassName", itemData); BuilderHelper.CheckParameter("Filter", itemData); // Support for simplified escaping inside XML tag string filter = itemData.Attributes["Filter"].Replace("{", "<").Replace("}", ">"); FilterWrapper wrapper; if (_serializer == null) _serializer = new XmlSerializer(typeof(FilterWrapper)); using (var reader = new StringReader(filter)) wrapper = (FilterWrapper)_serializer.Deserialize(reader); return new MediaNavigationFilter(itemData.Attributes["ClassName"], wrapper.Filter); }
protected static ConfigGroupMetadata BuildGroup( PluginItemMetadata itemData, PluginRuntime plugin) { string location = ConfigBaseMetadata.ConcatLocations(itemData.RegistrationLocation, itemData.Id); string text = null; foreach (KeyValuePair<string, string> attr in itemData.Attributes) { switch (attr.Key) { case "Text": text = attr.Value; break; default: throw new ArgumentException("'ConfigGroup' builder doesn't define an attribute '" + attr.Key + "'"); } } if (text == null) throw new ArgumentException("'ConfigGroup' item needs an attribute 'Text'"); return new ConfigGroupMetadata(location, text); }
protected WorkflowState BuildWorkflowState(PluginItemMetadata itemData) { IDictionary<string, string> attributes = itemData.Attributes; Guid id = Guid.Empty; try { string name; string displayLabel; bool isTemporary = false; string mainScreen = null; bool inheritMenu = false; Guid? workflowModelId = null; if (string.IsNullOrEmpty(itemData.Id)) throw new ArgumentException(string.Format("WorkflowState: Id must be specified")); id = new Guid(itemData.Id); if (!attributes.TryGetValue("Name", out name)) throw new ArgumentException(string.Format("WorkflowState with id '{0}': 'Name' attribute missing", id)); if (!attributes.TryGetValue("DisplayLabel", out displayLabel)) throw new ArgumentException(string.Format("WorkflowState with id '{0}': 'DisplayLabel' attribute missing", id)); string tmpStr; if (attributes.TryGetValue("WorkflowModel", out tmpStr)) workflowModelId = new Guid(tmpStr); if (!attributes.TryGetValue("MainScreen", out mainScreen)) { mainScreen = null; if (workflowModelId == null) throw new ArgumentException(string.Format("WorkflowState '{0}': Either 'WorkflowModel' or 'MainScreen' atrribute must be specified", name)); } if (attributes.TryGetValue("Temporary", out tmpStr) && !bool.TryParse(tmpStr, out isTemporary)) throw new ArgumentException("'Temporary' attribute has to be of type bool"); if (attributes.TryGetValue("InheritMenu", out tmpStr) && !bool.TryParse(tmpStr, out inheritMenu)) throw new ArgumentException("'InheritMenu' attribute has to be of type bool"); return new WorkflowState(id, name, displayLabel, isTemporary, mainScreen, inheritMenu, false, workflowModelId, WorkflowType.Workflow); } catch (Exception e) { ServiceRegistration.Get<ILogger>().Error("WorkflowStateBuilder: Workflow state '{0}' cannot be built", e, id); return null; } }
public object BuildItem(PluginItemMetadata itemData, PluginRuntime plugin) { BuilderHelper.CheckParameter("ClassName", itemData); BuilderHelper.CheckParameter("MimeType", itemData); return new VideoPlayerMimeTypeMapping(plugin.GetPluginType(itemData.Attributes["ClassName"]), itemData.Attributes["MimeType"]); }
public bool NeedsPluginActive(PluginItemMetadata itemData, PluginRuntime plugin) { BackgroundType type; string value = GetBackgroundAndType(itemData.Attributes, out type); if (type == BackgroundType.Static) return false; if (type == BackgroundType.Manager) return true; throw new NotImplementedException(string.Format( "Background builder: Background type '{0}' is not implemented", type)); }
public object BuildItem(PluginItemMetadata itemData, PluginRuntime plugin) { BuilderHelper.CheckParameter("ClassName", itemData); return new FanartImageSourceProviderRegistration(plugin.GetPluginType(itemData.Attributes["ClassName"]), itemData.Id); }
/// <summary> /// Creates a new plugin item registration data structure for the specified plugin item metadata /// instance. /// </summary> /// <param name="metaData">The metadata of the plugin item to create this registration /// structure for.</param> internal PluginItemRegistration(PluginItemMetadata metaData) { _pluginItemMetadata = metaData; }
public void RevokeItem(object item, PluginItemMetadata itemData, PluginRuntime plugin) { if (item == null) return; plugin.RevokePluginObject(item.GetType().FullName); }
protected static ConfigSettingMetadata BuildCustomSetting( PluginItemMetadata itemData, PluginRuntime plugin) { string location = ConfigBaseMetadata.ConcatLocations(itemData.RegistrationLocation, itemData.Id); string text = null; string sort = null; string className = null; string helpText = null; IDictionary<string, string> additionalData = null; IDictionary<string, Type> additionalTypes = null; ICollection<string> listenTo = null; foreach (KeyValuePair<string, string> attr in itemData.Attributes) { switch (attr.Key) { case "Text": text = attr.Value; break; case "Sort": sort = attr.Value; break; case "ClassName": className = attr.Value; break; case "HelpText": helpText = attr.Value; break; case "ListenTo": listenTo = ParseListenTo(attr.Value); break; case "AdditionalData": additionalData = ParseAdditionalData(attr.Value); break; case "AdditionalTypes": additionalTypes = ParseAdditionalTypes(attr.Value, plugin); break; default: throw new ArgumentException("'ConfigSetting' builder doesn't define an attribute '" + attr.Key + "'"); } } if (text == null) throw new ArgumentException("'ConfigSetting' item needs an attribute 'Text'"); ConfigSettingMetadata result = new ConfigSettingMetadata(location, text, sort, className, helpText, listenTo) { AdditionalData = additionalData, AdditionalTypes = additionalTypes }; return result; }
public object BuildItem(PluginItemMetadata itemData, PluginRuntime plugin) { BuilderHelper.CheckParameter("MediaItemAspectTypeId", itemData); return new MIATypeRegistration { MediaItemAspectTypeId = new Guid(itemData.Attributes["MediaItemAspectTypeId"]) }; }
public void RevokeItem(object item, PluginItemMetadata itemData, PluginRuntime plugin) { // Noting to do }
/// <summary> /// Registers the specified plugin item in the plugin tree. /// </summary> /// <param name="itemMetadata">Metadata structure of the item to register.</param> /// <returns><c>true</c>, if the plugin item could be registered, <c>false</c>, /// if the item already existed and <see cref="PluginItemMetadata.IsRedundant"/> is specified.</returns> /// <exception cref="ArgumentException">If there is already an item registered at the registration /// location and the <see cref="PluginItemMetadata.IsRedundant"/> flag is not set.</exception> internal bool RegisterItem(PluginItemMetadata itemMetadata) { lock (_syncObj) { IRegistryNode node = GetRegistryNode(itemMetadata.RegistrationLocation, true); itemMetadata.PluginRuntime = this; if (node.Items != null && node.Items.ContainsKey(itemMetadata.Id)) if (itemMetadata.IsRedundant) { PluginItemRegistration itemRegistration = (PluginItemRegistration) node.Items[itemMetadata.Id]; itemRegistration.AdditionalRedundantItemsMetadata.Add(itemMetadata); return false; } else throw new ArgumentException(string.Format("At location '{0}', a plugin item with id '{1}' is already registered", itemMetadata.RegistrationLocation, itemMetadata.Id)); PluginItemRegistration resultItemRegistration = new PluginItemRegistration(itemMetadata); node.AddItem(itemMetadata.Id, resultItemRegistration); _itemRegistrations.Add(itemMetadata, resultItemRegistration); } return true; }
public void RevokeItem(object item, PluginItemMetadata itemData, PluginRuntime plugin) { if (item == null) return; ServiceItem si = (ServiceItem) item; plugin.RevokePluginObject(si.ServiceInstance.GetType().FullName); }
public object BuildItem(PluginItemMetadata itemData, PluginRuntime plugin) { if (itemData.BuilderName == "WorkflowState") return BuildWorkflowState(itemData); if (itemData.BuilderName == "DialogState") return BuildDialogState(itemData); return null; }
protected static ConfigSettingMetadata BuildSetting( PluginItemMetadata itemData, PluginRuntime plugin) { string location = ConfigBaseMetadata.ConcatLocations(itemData.RegistrationLocation, itemData.Id); string text = null; string className = null; string helpText = null; ICollection<string> listenTo = null; foreach (KeyValuePair<string, string> attr in itemData.Attributes) { switch (attr.Key) { case "Text": text = attr.Value; break; case "ClassName": className = attr.Value; break; case "HelpText": helpText = attr.Value; break; case "ListenTo": listenTo = ParseListenTo(attr.Value); break; default: throw new ArgumentException("'ConfigSetting' builder doesn't define an attribute '" + attr.Key+ "'"); } } if (text == null) throw new ArgumentException("'ConfigSetting' item needs an attribute 'Text'"); return new ConfigSettingMetadata(location, text, className, helpText, listenTo); }
public void RevokeItem(object item, PluginItemMetadata itemData, PluginRuntime plugin) { // Nothing to do here - the WorkflowManager will listen for workflow state withdrawals }
public object BuildItem(PluginItemMetadata itemData, PluginRuntime plugin) { BuilderHelper.CheckParameter("ClassName", itemData); return plugin.InstantiatePluginObject(itemData.Attributes["ClassName"]); }
public object BuildItem(PluginItemMetadata itemData, PluginRuntime plugin) { switch (itemData.BuilderName) { case "ConfigSection": return BuildSection(itemData, plugin); case "ConfigGroup": return BuildGroup(itemData, plugin); case "ConfigSetting": return BuildSetting(itemData, plugin); case "CustomConfigSetting": return BuildCustomSetting(itemData, plugin); } throw new ArgumentException(string.Format("{0} builder cannot build setting of type '{1}'", typeof(ConfigBuilder).Name, itemData.BuilderName)); }
/// <summary> /// Unregisters the specified plugin item from the plugin tree. /// </summary> /// <param name="itemMetadata">Meta data structure of the item to unregister.</param> /// <returns>Plugin item registration structure of the item to be unregistered.</returns> internal void UnregisterItem(PluginItemMetadata itemMetadata) { lock (_syncObj) try { IRegistryNode node = GetRegistryNode(itemMetadata.RegistrationLocation, false); if (node == null || node.Items == null) return; if (node.Items.ContainsKey(itemMetadata.Id)) { PluginItemRegistration itemRegistration = (PluginItemRegistration) node.Items[itemMetadata.Id]; // Check, if there are additional redundant items registered at this position. If yes, we'll use // the first of them instead of the old item to be unregistered. PluginItemMetadata newItemMetadata = null; IEnumerator<PluginItemMetadata> enumerator = itemRegistration.AdditionalRedundantItemsMetadata.GetEnumerator(); if (enumerator.MoveNext()) { newItemMetadata = enumerator.Current; itemRegistration.AdditionalRedundantItemsMetadata.Remove(newItemMetadata); } node.Items.Remove(itemMetadata.Id); if (newItemMetadata != null) newItemMetadata.PluginRuntime.RegisterItem(newItemMetadata); } } finally { _itemRegistrations.Remove(itemMetadata); } }
public bool NeedsPluginActive(PluginItemMetadata itemData, PluginRuntime plugin) { return true; }
public bool NeedsPluginActive(PluginItemMetadata itemData, PluginRuntime plugin) { return itemData.BuilderName != "ConfigSection" && itemData.BuilderName != "ConfigGroup"; }