/// <summary>
        /// Retrieves the ToolboxItem used by this Modeling based editor.
        /// This is where you add complex toolbox items that are not simply
        /// fragments of diagram to be added.
        /// </summary>
        public override ModelingToolboxItem[] GetToolboxItems()
        {
            // Put all the base items in the list and then add the connector tools
            List <ModelingToolboxItem> items = new List <ModelingToolboxItem>();

            // Get the base list of toolbox items
            ModelingToolboxItem[] baseItems = base.GetToolboxItems();
            foreach (ModelingToolboxItem baseItem in baseItems)
            {
                items.Add(baseItem);
            }



            // Create an entry for the SchemaModelItemHasSchemaModelItemConnector tool
            {
                ModelingToolboxItem item = new ModelingToolboxItem(
                    "SchemaModelItemHasSchemaModelItemConnectorToolBoxItemId",                               // Id
                    EditorFactory.SchemaModelItemHasSchemaModelItemConnectorPosition,                        // Position
                    EditorFactory.GetResource("ActivityHasArtifactConnectorToolboxCaption", true) as string, // Caption
                    EditorFactory.GetResource("connector") as System.Drawing.Bitmap,                         // Bitmap
                    Designer_Resource.ToolboxTab + "Id",
                    Designer_Resource.ToolboxTab,
                    "ExampleConnectorHelpId", // f1Keyword
                    null,                     // Tooltip
                    null,                     // ElementGroupPrototype
                    new ToolboxItemFilterAttribute[] { new ToolboxItemFilterAttribute(SFSchemaLanguageDiagram.DiagramFilterString, ToolboxItemFilterType.Require), new ToolboxItemFilterAttribute(EditorFactory.SchemaModelItemHasSchemaModelItemConnectorFilterString, ToolboxItemFilterType.Allow) });

                items.Add(item);
            }

            // Return the augmented list
            return(items.ToArray());
        }
        /// <summary>
        /// Create a list of <see cref="ModelingToolboxItem"/>s from a <see cref="IServiceProvider"/>
        /// </summary>
        /// <param name="serviceProvider">The context <see cref="IServiceProvider"/></param>
        /// <param name="domainModelType">The type of the <see cref="DomainModel"/> associated with this attribute</param>
        /// <returns>List of <see cref="ModelingToolboxItem"/> elements.</returns>
        public IList <ModelingToolboxItem> CreateToolboxItems(IServiceProvider serviceProvider, Type domainModelType)
        {
            Type createType = myToolboxItemProviderType;

            if (createType == null)
            {
                string[] nestedTypeNames = myNestedToolboxInitializerName.Split(new char[] { '.', '+' }, StringSplitOptions.RemoveEmptyEntries);
                createType = domainModelType;
                for (int i = 0; i < nestedTypeNames.Length; ++i)
                {
                    createType = createType.GetNestedType(nestedTypeNames[i], BindingFlags.NonPublic | BindingFlags.Public);
                }
            }
            if (createType != null)
            {
                IModelingToolboxItemProvider initializer = (IModelingToolboxItemProvider)Activator.CreateInstance(createType, true);
                IList <ModelingToolboxItem>  items       = initializer.CreateToolboxItems(serviceProvider);
                int itemCount;
                if (items != null &&
                    0 != (itemCount = items.Count))
                {
                    int offsetAdjustment = initializer.ToolboxItemPositionOffset;
                    if (offsetAdjustment != 0)
                    {
                        for (int i = 0; i < itemCount; ++i)
                        {
                            ModelingToolboxItem item = items[i];
                            items[i] = new ModelingToolboxItem(item.Id, item.Position + offsetAdjustment, item.DisplayName, item.Bitmap, item.TabNameId, item.TabName, item.ContextSensitiveHelpKeyword, item.Description, item.Prototype, item.Filter);
                        }
                    }
                    return(items);
                }
            }
            return(null);
        }
Beispiel #3
0
        private ModelingToolboxItem CreateToolboxItem(Store store, GadgeteerPart moduleDefinition, string description,
                                                      string tabName, ElementGroupPrototype prototype, string itemId)
        {
            //Add a filter attribute for each of the .NETMF versions supported by this module. The DocData adds a corresponding
            //filter depending on the version of the project
            var filters = moduleDefinition.SupportedMicroframeworkVersions.Select(v => new ToolboxItemFilterAttribute(GadgeteerDSLToolboxHelperBase.ToolboxFilterString + v,
                                                                                                                      ToolboxItemFilterType.Require)).ToArray();

            var result = new ModelingToolboxItem(
                itemId,                                                // Unique identifier (non-localized) for the toolbox item.
                2,                                                     // Position relative to other items in the same toolbox tab.
                moduleDefinition.Name,
                moduleToolboxIcon,                                     // Image displayed next to the toolbox item.
                "Microsoft.Gadgeteer.Designer.GadgeteerDSLToolboxTab", // Unique identifier (non-localized) for the toolbox item tab.
                tabName,                                               // Localized display name for the toolbox tab.
                moduleDefinition.Name,                                 // F1 help keyword for the toolbox item.
                description,                                           // Localized tooltip text for the toolbox item.
                prototype,
                filters
                );

            //Imporant to make this transient. Otherwise the toolbox items remain even if modules are uninstalled
            result.IsTransient = true;

            return(result);
        }
Beispiel #4
0
        /// <summary>
        /// Create a serialized prototype for Activity to attach to the toolbox.
        /// </summary>
        /// <param name="toolboxItem"></param>
        /// <returns>The prototype</returns>
        public override ElementGroupPrototype InitializeToolboxItem(ModelingToolboxItem toolboxItem)
        {
            ElementGroup          elementGroup = new ElementGroup(this.Store);
            ElementGroupPrototype proto        = null;

            Debug.Assert(this.Store.TransactionManager.InTransaction, "Must be in transaction");

            ISpySoft.SFSchemaLanguage.DomainModel.Activity instance = ISpySoft.SFSchemaLanguage.DomainModel.Activity.CreateActivity(this.Store);

            if (instance != null)
            {
                elementGroup.AddGraph(instance);

                proto = elementGroup.CreatePrototype(instance);
            }
            return(proto);
        }
        /// <summary>
        /// Add a filter to the specified <see cref="ModelingToolboxItem"/>
        /// </summary>
        /// <param name="items">A list of existing items</param>
        /// <param name="itemIndexDictionary">A dictionary mapping from the item identifier to an index in the
        /// <paramref name="items"/> list. The dictionary should be created with <see cref="CreateIdentifierToIndexMap"/></param>
        /// <param name="itemId">The identifer of the item to modify</param>
        /// <param name="filterAttribute">The filter attribute to add</param>
        public static void AddFilterAttribute(IList <ModelingToolboxItem> items, IDictionary <string, int> itemIndexDictionary, string itemId, ToolboxItemFilterAttribute filterAttribute)
        {
            int itemIndex;

            if (itemIndexDictionary.TryGetValue(itemId, out itemIndex))
            {
                ModelingToolboxItem itemBase            = items[itemIndex];
                ICollection         baseFilters         = itemBase.Filter;
                int baseFilterCount                     = (baseFilters != null) ? baseFilters.Count : 0;
                ToolboxItemFilterAttribute[] newFilters = new ToolboxItemFilterAttribute[baseFilterCount + 1];
                if (baseFilterCount != 0)
                {
                    baseFilters.CopyTo(newFilters, 0);
                }
                newFilters[baseFilterCount] = filterAttribute;
                itemBase.Filter             = newFilters;
            }
        }
        /// <summary>
        /// Remove a filter from the specified <see cref="ModelingToolboxItem"/>
        /// </summary>
        /// <param name="items">A list of existing items</param>
        /// <param name="itemIndexDictionary">A dictionary mapping from the item identifier to an index in the
        /// <paramref name="items"/> list. The dictionary should be created with <see cref="CreateIdentifierToIndexMap"/></param>
        /// <param name="itemId">The identifer of the item to modify</param>
        /// <param name="filterString">The filter string for the filter to remove</param>
        public static void RemoveFilterAttribute(IList <ModelingToolboxItem> items, IDictionary <string, int> itemIndexDictionary, string itemId, string filterString)
        {
            int itemIndex;

            if (itemIndexDictionary.TryGetValue(itemId, out itemIndex))
            {
                ModelingToolboxItem itemBase    = items[itemIndex];
                ICollection         baseFilters = itemBase.Filter;
                int baseFilterCount             = baseFilters.Count;
                if (baseFilterCount != 0)
                {
                    int removeCount = 0;
                    foreach (object filter in baseFilters)
                    {
                        ToolboxItemFilterAttribute filterAttribute = filter as ToolboxItemFilterAttribute;
                        if (filterAttribute == null || filterAttribute.FilterString == filterString)
                        {
                            ++removeCount;
                        }
                    }
                    if (removeCount == baseFilterCount)
                    {
                        itemBase.Filter = null;
                    }
                    else
                    {
                        ToolboxItemFilterAttribute[] newFilters = new ToolboxItemFilterAttribute[baseFilterCount - removeCount];
                        int nextIndex = 0;
                        foreach (object filter in baseFilters)
                        {
                            ToolboxItemFilterAttribute filterAttribute = filter as ToolboxItemFilterAttribute;
                            if (filterAttribute != null && filterAttribute.FilterString != filterString)
                            {
                                newFilters[nextIndex] = filterAttribute;
                                ++nextIndex;
                            }
                        }
                        itemBase.Filter = newFilters;
                    }
                }
            }
        }
		/// <summary>
		/// Create a list of <see cref="ModelingToolboxItem"/>s from a <see cref="IServiceProvider"/>
		/// </summary>
		/// <param name="serviceProvider">The context <see cref="IServiceProvider"/></param>
		/// <param name="domainModelType">The type of the <see cref="DomainModel"/> associated with this attribute</param>
		/// <returns>List of <see cref="ModelingToolboxItem"/> elements.</returns>
		public IList<ModelingToolboxItem> CreateToolboxItems(IServiceProvider serviceProvider, Type domainModelType)
		{
			Type createType = myToolboxItemProviderType;
			if (createType == null)
			{
				string[] nestedTypeNames = myNestedToolboxInitializerName.Split(new char[] { '.', '+' }, StringSplitOptions.RemoveEmptyEntries);
				createType = domainModelType;
				for (int i = 0; i < nestedTypeNames.Length; ++i)
				{
					createType = createType.GetNestedType(nestedTypeNames[i], BindingFlags.NonPublic | BindingFlags.Public);
				}
			}
			if (createType != null)
			{
				IModelingToolboxItemProvider initializer = (IModelingToolboxItemProvider)Activator.CreateInstance(createType, true);
				IList<ModelingToolboxItem> items = initializer.CreateToolboxItems(serviceProvider);
				int itemCount;
				if (items != null &&
					0 != (itemCount = items.Count))
				{
					int offsetAdjustment = initializer.ToolboxItemPositionOffset;
					if (offsetAdjustment != 0)
					{
						for (int i = 0; i < itemCount; ++i)
						{
							ModelingToolboxItem item = items[i];
							items[i] = new ModelingToolboxItem(item.Id, item.Position + offsetAdjustment, item.DisplayName, item.Bitmap, item.TabNameId, item.TabName, item.ContextSensitiveHelpKeyword, item.Description, item.Prototype, item.Filter);
						}
					}
					return items;
				}
			}
			return null;
		}