public GetEditor ( |
||
editorBaseType | ||
Результат | object |
public PropertyEditorCell GetEditor (PropertyDescriptor pd) { PropertyEditorCell cell = pd.GetEditor (typeof(PropertyEditorCell)) as PropertyEditorCell; if (cell != null) return cell; Type editorType = GetEditorType (pd); if (editorType == null) return Default; if (typeof(IPropertyEditor).IsAssignableFrom (editorType)) { if (!typeof(Gtk.Widget).IsAssignableFrom (editorType)) throw new Exception ("The property editor '" + editorType + "' must be a Gtk Widget"); return Default; } cell = cellCache [editorType] as PropertyEditorCell; if (cell != null) return cell; if (!typeof(PropertyEditorCell).IsAssignableFrom (editorType)) throw new Exception ("The property editor '" + editorType + "' must be a subclass of Stetic.PropertyEditorCell or implement Stetic.IPropertyEditor"); cell = (PropertyEditorCell) Activator.CreateInstance (editorType); cellCache [editorType] = cell; return cell; }
/// <summary> /// Parses annotations in schema sets. Override this to handle custom annotations. /// Supports annotations for property descriptors and palette items.</summary> /// <param name="schemaSet">XML schema sets being loaded</param> /// <param name="annotations">Dictionary of annotations in schema</param> protected override void ParseAnnotations( XmlSchemaSet schemaSet, IDictionary <NamedMetadata, IList <XmlNode> > annotations) { base.ParseAnnotations(schemaSet, annotations); IList <XmlNode> xmlNodes; foreach (DomNodeType nodeType in m_typeCollection.GetNodeTypes()) { // parse XML annotation for property descriptors if (annotations.TryGetValue(nodeType, out xmlNodes)) { PropertyDescriptorCollection propertyDescriptors = Sce.Atf.Dom.PropertyDescriptor.ParseXml(nodeType, xmlNodes); // Customizations // The flags and enum support from annotation used to be in ATF 2.8. // Please request this feature from the ATF team if you need it and a ParseXml overload // can probably be created. System.ComponentModel.PropertyDescriptor gameFlow = propertyDescriptors["Special Event"]; if (gameFlow != null) { FlagsUITypeEditor editor = (FlagsUITypeEditor)gameFlow.GetEditor(typeof(FlagsUITypeEditor)); editor.DefineFlags(new string[] { "Reward==Give player the reward", "Trophy==Give player the trophy", "LevelUp==Level up", "BossDies==Boss dies", "PlayerDies==Player dies", "EndCinematic==End cinematic", "EndGame==End game", }); } nodeType.SetTag <PropertyDescriptorCollection>(propertyDescriptors); // parse type annotation to create palette items XmlNode xmlNode = FindElement(xmlNodes, "scea.dom.editors"); if (xmlNode != null) { string menuText = FindAttribute(xmlNode, "menuText"); if (menuText != null) // must have menu text and category { string description = FindAttribute(xmlNode, "description"); string image = FindAttribute(xmlNode, "image"); NodeTypePaletteItem item = new NodeTypePaletteItem(nodeType, menuText, description, image); nodeType.SetTag <NodeTypePaletteItem>(item); } } } } }
/// <summary> /// Factory method for creating the appropriate drop-down control based on the given property descriptor. /// If the property descriptor supports a UITypeEditor, a TypeEditorHost will be created with that editor. /// If not, and the TypeConverver attached to the PropertyDescriptor supports standard values, a /// TypeEditorHostListBox will be created with this TypeConverter. /// </summary> /// <param name="propertyDescriptor">A property descriptor describing the property being set</param> /// <param name="instance">The object instance being edited</param> /// <param name="editControlStyle">The type of control to show in the edit area.</param> /// <returns>A TypeEditorHost instance if the given property descriptor supports it, null otherwise.</returns> public static new TypeEditorHost Create(PropertyDescriptor propertyDescriptor, object instance, TypeEditorHostEditControlStyle editControlStyle) { TypeEditorHost host = null; if (propertyDescriptor != null) { UITypeEditor editor = propertyDescriptor.GetEditor(typeof(UITypeEditor)) as UITypeEditor; if (editor != null) { return new OnScreenTypeEditorHost(editor, propertyDescriptor, instance, editControlStyle); } TypeConverter typeConverter = propertyDescriptor.Converter; if ((typeConverter != null) && typeConverter.GetStandardValuesSupported(null)) { host = new OnScreenTypeEditorHostListBox(typeConverter, propertyDescriptor, instance, editControlStyle); } } return host; }
/// <summary> /// Gets a UI type editor for the given property descriptor and context</summary> /// <param name="descriptor">Property descriptor</param> /// <param name="context">Type descriptor context</param> /// <returns>UI type editor for the given property descriptor and context</returns> public static UITypeEditor GetUITypeEditor( PropertyDescriptor descriptor, ITypeDescriptorContext context) { UITypeEditor editor = descriptor.GetEditor(typeof(UITypeEditor)) as UITypeEditor; if (editor == null) { if (StandardValuesUIEditor.CanCreateStandardValues(descriptor, context)) { editor = new StandardValuesUIEditor(descriptor); } else { Type type = descriptor.PropertyType; editor = TypeDescriptor.GetEditor(type, typeof(UITypeEditor)) as UITypeEditor; } } return editor; }
/// <summary> /// Invokes the editor for the items of the designed ImageListView. /// </summary> public void EditItems() { // IComponentChangeService is used to pass change notifications to the designer IComponentChangeService ccs = (IComponentChangeService)GetService(typeof(IComponentChangeService)); // Get the collection editor itemProperty = GetPropertyByName("Items"); UITypeEditor editor = (UITypeEditor)itemProperty.GetEditor(typeof(UITypeEditor)); object value = imageListView.Items; // Notify the designers of the change if (ccs != null) ccs.OnComponentChanging(imageListView, itemProperty); // Edit the value value = editor.EditValue(this, this, value); imageListView.Items = (ImageListView.ImageListViewItemCollection)value; // Notify the designers of the change if (ccs != null) ccs.OnComponentChanged(imageListView, itemProperty, null, null); designerService.Refresh(Component); }
/// <summary> /// Factory method for creating the appropriate drop-down control based on the given property descriptor. /// If the property descriptor supports a UITypeEditor, a TypeEditorHost will be created with that editor. /// If not, and the TypeConverver attached to the PropertyDescriptor supports standard values, a /// TypeEditorHostListBox will be created with this TypeConverter. /// </summary> /// <param name="propertyDescriptor">A property descriptor describing the property being set</param> /// <param name="instance">The object instance being edited</param> /// <param name="editControlStyle">The type of control to show in the edit area.</param> /// <returns>A TypeEditorHost instance if the given property descriptor supports it, null otherwise.</returns> public static TypeEditorHost Create( PropertyDescriptor propertyDescriptor, object instance, TypeEditorHostEditControlStyle editControlStyle) { TypeEditorHost dropDown = null; if (propertyDescriptor != null) { var uiTypeEditor = propertyDescriptor.GetEditor(typeof(UITypeEditor)) as UITypeEditor; if (uiTypeEditor != null) // UITypeEditor case { dropDown = new TypeEditorHost(uiTypeEditor, propertyDescriptor, instance, editControlStyle); } else { var converter = propertyDescriptor.Converter; if (converter != null && converter.GetStandardValuesSupported(null)) // converter case { dropDown = new TypeEditorHostListBox(converter, propertyDescriptor, instance, editControlStyle); } } } return dropDown; }
/// <summary> /// Invokes the editor for the columns of the designed ImageListView. /// </summary> public void EditColumns() { // TODO: Column editing cannot be undone in the designer. property = TypeDescriptor.GetProperties(imageListView)["Columns"]; UITypeEditor editor = (UITypeEditor)property.GetEditor(typeof(UITypeEditor)); object value = imageListView.Columns;// property.GetValue(imageListView); value = editor.EditValue(this, this, value); SetProperty("Columns", value); designerService.Refresh(Component); }
/// <summary> /// Factory method for creating the appropriate drop-down control based on the given property descriptor /// </summary> /// <param name="propertyDescriptor"> /// Property descriptor used to create the drop-down. If the property descriptor supports a UITypeEditor, /// that will be used first. Otherwise, the type converter will be used. /// </param> /// <param name="instance">Instance of the object being edited.</param> /// <param name="editStyle"> /// In the case that a UITypeEditor is used, controls the style of drop-down created. This /// parameter is not used in the TypeConverter case. /// </param> /// <returns>A DropDownControl instance if the given property descriptor supports it, null otherwise.</returns> internal static TypeEditorHost CreateTypeEditorHost( PropertyDescriptor propertyDescriptor, object instance, TypeEditorHostEditControlStyle editControlStyle) { TypeEditorHost dropDown = null; if (propertyDescriptor != null) { var uiTypeEditor = propertyDescriptor.GetEditor(typeof(UITypeEditor)) as UITypeEditor; if (uiTypeEditor != null) // UITypeEditor case { dropDown = new TreeGridDesignerInPlaceEditDropDown(uiTypeEditor, propertyDescriptor, instance, editControlStyle); } else { var converter = propertyDescriptor.Converter; if (converter != null && converter.GetStandardValuesSupported(null)) // converter case { dropDown = new TreeGridDesignerInPlaceEditCombo(converter, propertyDescriptor, instance, editControlStyle); } } } return dropDown; }
/// <summary> /// EditRows /// </summary> private void EditRows() { _PropertyDescriptor = TypeDescriptor.GetProperties(_SuperGrid.PrimaryGrid)["Rows"]; UITypeEditor editor = (UITypeEditor)_PropertyDescriptor.GetEditor(typeof(UITypeEditor)); if (editor != null) editor.EditValue(this, this, _SuperGrid.PrimaryGrid.Rows); }
internal static Control CreateEditorControl(PropertyDescriptor descriptor) { if (descriptor == null) throw new ArgumentNullException("descriptor"); var propertyType = descriptor.PropertyType; object editor = null; try { editor = descriptor.GetEditor(typeof(IEditorPartField)); } catch (Exception e) { Logger.WriteException(e); } var propName = descriptor.Name; if (editor != null) { var partField = editor as IEditorPartField; if (partField != null) { partField.Options = GetEditorOptionsAttribute(descriptor.Attributes); partField.TitleContainerCssClass = "sn-iu-label"; partField.TitleCssClass = "sn-iu-title"; partField.DescriptionCssClass = "sn-iu-desc"; partField.ControlWrapperCssClass = "sn-iu-control"; partField.Title = GetDisplayName(descriptor); partField.Description = GetDescription(descriptor); partField.EditorPartCssClass = "sn-inputunit ui-helper-clearfix sn-custom-editorpart-text sn-editorpart-" + propName; partField.PropertyName = propName; if (propertyType == typeof (bool)) partField.EditorPartCssClass = "sn-inputunit ui-helper-clearfix sn-custom-editorpart-boolean sn-editorpart-" + propName; if (typeof (Enum).IsAssignableFrom(propertyType)) { // TODO: fill the instance of the EditorPart control with datas. Best solution is extend the IEditorPartField interface with Fill method } var result = partField as Control; result.ID = "Custom" + propName; return result; } } if (propertyType == typeof (bool)) { var checkBox = new CheckBoxEditorPartField(); checkBox.ID = "CheckBox" + propName; checkBox.Options = GetEditorOptionsAttribute(descriptor.Attributes); checkBox.EditorPartCssClass = "sn-inputunit ui-helper-clearfix sn-custom-editorpart-boolean sn-editorpart-" + propName; checkBox.Title = GetDisplayName(descriptor); checkBox.Description = GetDescription(descriptor); checkBox.TitleContainerCssClass = "sn-iu-label"; checkBox.TitleCssClass = "sn-iu-title"; checkBox.DescriptionCssClass = "sn-iu-desc"; checkBox.ControlWrapperCssClass = "sn-iu-control"; checkBox.PropertyName = propName; return checkBox; } if (typeof (Enum).IsAssignableFrom(propertyType)) { ICollection standardValues = descriptor.Converter.GetStandardValues(); if (standardValues != null) { var list = new DropDownPartField(); list.ID = "DropDown" + propName; list.Options = GetEditorOptionsAttribute(descriptor.Attributes); list.EditorPartCssClass = "sn-inputunit ui-helper-clearfix sn-custom-editorpart-enum sn-editorpart-" + propName; list.Title = GetDisplayName(descriptor); list.Description = GetDescription(descriptor); list.TitleContainerCssClass = "sn-iu-label"; list.TitleCssClass = "sn-iu-title"; list.DescriptionCssClass = "sn-iu-desc"; list.ControlWrapperCssClass = "sn-iu-control"; list.PropertyName = propName; foreach (object value in standardValues) { var resourceKey = String.Concat("Enum-", propName, "-", value.ToString()); var text = SenseNetResourceManager.Current.GetStringOrNull("PortletFramework", resourceKey) as string; if (string.IsNullOrEmpty(text)) text = descriptor.Converter.ConvertToString(value); list.Items.Add(new ListItem(text, value.ToString())); } return list; } return null; } var textBox = new TextEditorPartField(); textBox.ID = "TextBox" + propName; textBox.Options = GetEditorOptionsAttribute(descriptor.Attributes); textBox.EditorPartCssClass = "sn-inputunit ui-helper-clearfix sn-custom-editorpart-text sn-editorpart-" + propName; textBox.Title = GetDisplayName(descriptor); textBox.Description = GetDescription(descriptor); textBox.TitleContainerCssClass = "sn-iu-label"; textBox.TitleCssClass = "sn-iu-title"; textBox.DescriptionCssClass = "sn-iu-desc"; textBox.ControlWrapperCssClass = "sn-iu-control"; textBox.Columns = 30; textBox.PropertyName = propName; return textBox; }