public PropertyEditorRegistry(IPropertyEditor[] propertyEditors) { this.propertyEditors = new Dictionary<string, IPropertyEditor>(); foreach (IPropertyEditor editor in propertyEditors) { Register(editor); } }
public EditSession StartEditing(Gdk.Rectangle cell_area, StateType state) { IPropertyEditor ed = CreateEditor(cell_area, state); if (ed == null) { return(null); } return(new EditSession(container, obj, property, ed)); }
public object Edit(Rect region, GUIContent label, object element, fiGraphMetadata metadata) { metadata.Enter("AbstractTypeEditor").Metadata.GetPersistentMetadata <fiDropdownMetadata>().ForceDisable(); try { fiEditorGUI.AnimatedBegin(ref region, metadata); _options.RemoveExtraneousOptions(); // draw the popup { int popupHeight = (int)EditorStyles.popup.CalcHeight(GUIContent.none, 100); Rect popupRegion = new Rect(region); popupRegion.height = popupHeight; region.y += popupRegion.height; region.height -= popupRegion.height; int selectedIndex = _options.GetDisplayOptionIndex(element); int updatedIndex = EditorGUI.Popup(popupRegion, label, selectedIndex, _options.GetDisplayOptions()); if (selectedIndex != updatedIndex) { metadata.GetMetadata <AbstractTypeAnimationMetadata>().ChangedTypes = true; } element = _options.UpdateObjectInstance(element, selectedIndex, updatedIndex); } // no element; no editor if (element == null) { return(null); } // draw the instance specific property editor { Rect selectedRegion = new Rect(region); selectedRegion = fiRectUtility.IndentedRect(selectedRegion); region.y += selectedRegion.height; region.height -= selectedRegion.height; // show custom editor PropertyEditorChain chain = PropertyEditor.Get(element.GetType(), null); IPropertyEditor editor = chain.SkipUntilNot(typeof(AbstractTypePropertyEditor)); return(editor.Edit(selectedRegion, GUIContent.none, element, metadata.Enter("AbstractTypeEditor"))); } } finally { fiEditorGUI.AnimatedEnd(metadata); } }
/// <summary> /// Returns the height of the region that needs editing. /// </summary> /// <param name="label">The label that will be used when editing.</param> /// <param name="element">The element that will be edited.</param> /// <returns>The height of the region that needs editing.</returns> public static float GetElementHeight <T>(this IPropertyEditor editor, GUIContent label, T element, fiGraphMetadataChild metadata) { bool hasCachedHeight; CachedHeightMedatadata cachedHeight = metadata.Metadata.GetMetadata <CachedHeightMedatadata>(out hasCachedHeight); hasCachedHeight = !hasCachedHeight; // If we're calling from an Edit method, just reuse the last height // computation (if we have a previous height computation). if (hasCachedHeight && BaseMethod == BaseMethodCall.Edit) { return(cachedHeight.CachedHeight); } // If we're a dropdown that is not active, show the general foldout // height var dropdown = GetDropdownMetadata(editor, metadata.Metadata); if (dropdown.ShouldDisplayDropdownArrow && dropdown.IsAnimating == false && dropdown.IsActive == false) { cachedHeight.CachedHeight = FoldoutHeight; return(FoldoutHeight); } bool setBaseMethod = false; if (hasCachedHeight) { BeginMethodSet(BaseMethodCall.GetElementHeight, out setBaseMethod); } try { // We begin (but do not end) the cull zone here. The cull zone is // terminated inside of Edit(). It is safe to call // BeginCullZone() multiple times -- it has no effect past the // first call. metadata.Metadata.BeginCullZone(); var api = GetEditingAPI(editor); float height = api.GetElementHeight(label, element, metadata.Metadata); if (dropdown.IsAnimating) { fiEditorUtility.RepaintAllEditors(); fiEditorGUI.UpdateFadeGroupHeight(ref height, FoldoutHeight, dropdown.AnimPercentage); } return(metadata.Metadata.GetMetadata <CachedHeightMedatadata>().CachedHeight = height); } finally { if (hasCachedHeight) { EndMethodSet(setBaseMethod); } } }
/// <summary> /// Adds an editor to the end of this chain. /// </summary> internal void AddEditor(IPropertyEditor editor) { if (editor.EditorChain != null) { throw new InvalidOperationException("Editor " + editor + " is already part of " + "another PropertyEditorChain"); } _editors.Add(editor); editor.EditorChain = this; }
private void Register(IPropertyEditor propertyEditor) { if (!propertyEditors.ContainsKey(propertyEditor.PropertyType)) { propertyEditors.Add(propertyEditor.PropertyType, propertyEditor); } else { throw new CmsException("Duplicate editor property type: " + propertyEditor.PropertyType); } }
public object OnSceneGUI(object element) { if (element != null) { PropertyEditorChain chain = PropertyEditor.Get(element.GetType(), null); IPropertyEditor editor = chain.SkipUntilNot(typeof(AbstractTypePropertyEditor)); return(editor.OnSceneGUI(element)); } return(element); }
private IEnumerable <IPropertyEditor> PopulatePropertyEditors(Type type, IEnumerable <object> objects, IEnumerable <object> rootObjects, Widget widget, Dictionary <string, List <PropertyEditorParams> > editorParams) { foreach (var header in editorParams.Keys.OrderBy((s) => s)) { AddGroupHeader(header, widget); foreach (var param in editorParams[header]) { bool isPropertyRegistered = false; IPropertyEditor editor = null; foreach (var i in InspectorPropertyRegistry.Instance.Items) { if (i.Condition(param)) { isPropertyRegistered = true; editor = i.Builder(param); break; } } if (!isPropertyRegistered) { var propertyType = param.PropertyInfo.PropertyType; var iListInterface = propertyType.GetInterfaces().FirstOrDefault(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IList <>)); if (propertyType.IsEnum) { editor = CreateEditorForEnum(param); } else if (iListInterface != null) { editor = PopulateEditorsForListType(objects, rootObjects, param, iListInterface); } else if ((propertyType.IsClass || propertyType.IsInterface) && !propertyType.GetInterfaces().Contains(typeof(IEnumerable))) { editor = PopulateEditorsForInstanceType(objects, rootObjects, param); } } if (editor != null) { DecoratePropertyEditor(editor, row++); editors.Add(editor); var showCondition = PropertyAttributes <TangerineIgnoreIfAttribute> .Get(type, param.PropertyInfo.Name); if (showCondition != null) { editor.ContainerWidget.Updated += (delta) => { editor.ContainerWidget.Visible = !showCondition.Check(param.Objects.First()); }; } yield return(editor); } } } }
/// <summary> /// 焦点定位到指定的属性编辑器 /// </summary> /// <param name="editor"></param> public bool FocusToEditor(IPropertyEditor editor) { /*********************** 代码块解释 ********************************* * 由于表单中可以使用了页签控件来作为许多属性的划分容器, * 所以此时需要找到指定属性对应的 TabItem,先激活该页签, * 然后才能对其中的属性编辑器进行设置焦点的操作。 **********************************************************************/ var editorControl = editor.Control; var form = this.Control; //查找 Form 中的 TabControl 控件。 //如果还没有生成完毕,则先更新布局,再尝试查找一次。 var tabControl = form.GetVisualChild <TabControl>(); if (tabControl == null) { form.UpdateLayout(); tabControl = form.GetVisualChild <TabControl>(); } if (tabControl != null) { //找到编辑器对应的 TabItem,设置为选中状态,然后焦点选中。 //方法:编辑器的可视根元素应该与 TabItem 的 Content 属性一致。 foreach (var item in tabControl.Items) { var tabItem = tabControl.ItemContainerGenerator.ContainerFromItem(item) as TabItem; if (tabItem != null) { //如果 TabItem 包含了这个编辑器。 var content = tabItem.Content as Visual; if (content != null && content.IsAncestorOf(editorControl)) { tabItem.IsSelected = true; //如果 TabItem 已经生成了可视树,则可以直接设置焦点成功。 //否则,则应该先更新布局,再设置编辑器的焦点。 var res = editorControl.Focus(); if (!res) { tabItem.UpdateLayout(); res = editorControl.Focus(); } //简单处理:异步设置焦点的情况下,直接视为成功。 return(res); } } } } return(editorControl.Focus()); }
/// <summary> /// This method makes it easy to use a typical property editor as a GUILayout style method, /// where the rect is taken care of. /// </summary> /// <param name="editor">The editor that is being used.</param> /// <param name="label">The label to edit the region with.</param> /// <param name="element">The element that is being edited.</param> public static T EditWithGUILayout <T>(this IPropertyEditor editor, GUIContent label, T element, fiGraphMetadataChild metadata) { float height = editor.GetElementHeight(label, element, metadata); Rect region = EditorGUILayout.GetControlRect(false, height); if (Event.current.type != EventType.Layout) { return(editor.Edit(region, label, element, metadata)); } return(element); }
/// <summary> /// Helper method to fetch the editing API for an IPropertyEditor. /// </summary> private static IPropertyEditorEditAPI GetEditingAPI(IPropertyEditor editor) { var api = editor as IPropertyEditorEditAPI; if (api == null) { throw new InvalidOperationException(string.Format("Type {0} needs to extend " + "IPropertyEditorEditAPI", editor.GetType())); } return(api); }
internal EditSession(Widget container, ITypeDescriptorContext context, IPropertyEditor currentEditor) { this.context = context; this.container = container; this.currentEditor = currentEditor; currentEditor.Initialize(this); if (Instance != null) { currentEditor.Value = context.PropertyDescriptor.GetValue(Instance); } currentEditor.ValueChanged += OnValueChanged; }
protected override void OnActivated() { base.OnActivated(); if (View.ViewEditMode == ViewEditMode.Edit) { _dashboardTypesEditor = View.GetItems <IPropertyEditor>().First(editor => editor.MemberInfo.Name == "DashboardTypes"); _dashboardTypesEditor.ValueRead += DashboardTypesEditorOnValueRead; _xmlPropertyEditor = View.GetItems <IPropertyEditor>().FirstOrDefault(editor => editor.MemberInfo.Name == "Xml"); if (_xmlPropertyEditor != null) { _xmlPropertyEditor.ValueRead += XMLPropertyEditorOnValueRead; } } }
/// <summary> /// Returns the next editor that will be used, or null if the given /// editor is either the last one or was not found in the chain. /// </summary> /// <param name="editor">The editor that is currently being used.</param> /// <returns>The next editor, or null if there is no next one.</returns> public IPropertyEditor GetNextEditor(IPropertyEditor editor) { for (int i = 0; i < _editors.Count; ++i) { if (_editors[i] == editor) { if ((i + 1) >= _editors.Count) { return null; } return _editors[i + 1]; } } return null; }
public object OnSceneGUI(object element) { try { if (_cycleScene == null) { _cycleScene = new fiCycleDetector(_cycleEdit, _cycleHeight); } _cycleScene.Enter(); // cycle; don't do anything if (_cycleScene.TryMark(element) == false) { return(element); } // Not showing a scene GUI for the object for this frame should be fine if (element == null) { return(element); } var inspectedProperties = _metadata.GetProperties(InspectedMemberFilters.InspectableMembers); for (int i = 0; i < inspectedProperties.Count; ++i) { var property = inspectedProperties[i]; var editorChain = PropertyEditor.Get(property.StorageType, property.MemberInfo); IPropertyEditor editor = editorChain.FirstEditor; object currentValue = property.Read(element); object updatedValue = editor.OnSceneGUI(currentValue); // We use EqualityComparer instead of == because EqualityComparer will properly unbox structs if (EqualityComparer <object> .Default.Equals(currentValue, updatedValue) == false) { property.Write(element, updatedValue); } } return(element); } finally { _cycleScene.Exit(); if (_cycleScene.Depth == 0) { _cycleScene = null; } } }
public float GetElementHeight(GUIContent label, object element, fiGraphMetadata metadata) { float height = EditorStyles.label.CalcHeight(label, 100); if (element != null) { PropertyEditorChain chain = PropertyEditor.Get(element.GetType(), null); IPropertyEditor editor = chain.SkipUntilNot(typeof(NullablePropertyEditor)); height += fiRectUtility.IndentVertical; height += editor.GetElementHeight(GUIContent.none, element, metadata.Enter("NullableEditor", metadata.Context)); } return(height); }
public EditSession(Gtk.Widget container, object instance, PropertyDescriptor property, IPropertyEditor currentEditor) { this.property = property; this.obj = instance; this.container = container; this.currentEditor = currentEditor; currentEditor.Initialize(this); if (instance != null) { currentEditor.Value = property.GetValue(instance); } currentEditor.ValueChanged += OnValueChanged; }
public EditSession StartEditing(Gdk.Rectangle cell_area, StateType state) { IPropertyEditor ed = CreateEditor(cell_area, state); if (ed == null) { return(null); } ed.Initialize(property); if (obj != null) { ed.AttachObject(obj); ed.Value = property.GetValue(obj); } return(new EditSession(container, obj, property, ed)); }
/// <summary> /// Method called after the schema set has been loaded and the DomNodeTypes have been created, but /// before the DomNodeTypes have been frozen. This means that DomNodeType.SetIdAttribute, for example, has /// not been called on the DomNodeTypes. Is called shortly before OnDomNodeTypesFrozen. /// Defines DOM adapters on the DOM types.</summary> /// <param name="schemaSet">XML schema sets being loaded</param> protected override void OnSchemaSetLoaded(XmlSchemaSet schemaSet) { foreach (XmlSchemaTypeCollection typeCollection in GetTypeCollections()) { m_namespace = typeCollection.TargetNamespace; m_typeCollection = typeCollection; bitBoxSchema.Initialize(typeCollection); bitBoxSchema.graphType.Type.Define(new ExtensionInfo <SceneEditingContext>()); bitBoxSchema.graphType.Type.Define(new ExtensionInfo <NodeEditingContext>()); bitBoxSchema.graphType.Type.Define(new ExtensionInfo <SceneDocument>()); //bitBoxSchema.graphType.Type.Define(new ExtensionInfo<UniqueIdValidator>()); // register extensions //bitBoxSchema.graphType.Type.Define(new ExtensionInfo<Game>()); //bitBoxSchema.graphType.Type.Define(new ExtensionInfo<ReferenceValidator>()); //bitBoxSchema.graphType.Type.Define(new ExtensionInfo<UniqueIdValidator>()); // //bitBoxSchema.nodeType.Type.Define(new ExtensionInfo<GameObject>()); //bitBoxSchema.MeshNode.Type.Define(new ExtensionInfo<Dwarf>()); //bitBoxSchema.MeshNode.Type.Define(new ExtensionInfo<MeshNode>()); var creator = new AdapterCreator <CustomTypeDescriptorNodeAdapter>(); foreach (DomNodeType type in GetNodeTypes(bitBoxSchema.nodeType.Type)) { type.AddAdapterCreator(creator); string defaultNodeName = type.Name.Split(':').Last().Replace("Node", ""); type.SetTag(new NodeTypePaletteItem(type, defaultNodeName, defaultNodeName.Localize(), null)); PropertyDescriptorCollection propDescs = new PropertyDescriptorCollection(null); foreach (AttributeInfo attr in type.Attributes) { IPropertyEditor editor = PropertyEditorFactory.createEditorForAttribute(attr); AttributePropertyDescriptor attributePropDesc = new AttributePropertyDescriptor(attr.Name.Localize(), attr, "Attributes".Localize(), null, false, editor); propDescs.Add(attributePropDesc); } type.SetTag(propDescs); } break; } }
/// <summary> /// Fetches the dropdown metadata instance that should be used. This performs any necessary initialization. /// </summary> private static fiDropdownMetadata GetDropdownMetadata(IPropertyEditor editor, fiGraphMetadata metadata) { bool wasCreated; var dropdown = metadata.GetPersistentMetadata <fiDropdownMetadata>(out wasCreated); if (wasCreated && editor is IPropertyEditorDefaultFoldoutState) { dropdown.InvertDefaultState(); if (((IPropertyEditorDefaultFoldoutState)editor).DefaultFoldoutState == false) { dropdown.ForceHideWithoutAnimation(); } } return(dropdown); }
/// <summary> /// Returns the next editor that will be used, or null if the given editor is either the /// last one or was not found in the chain. /// </summary> /// <param name="editor">The editor that is currently being used.</param> /// <returns>The next editor, or null if there is no next one.</returns> public IPropertyEditor GetNextEditor(IPropertyEditor editor) { for (int i = 0; i < _editors.Count; ++i) { if (_editors[i] == editor) { if ((i + 1) >= _editors.Count) { return(null); } return(_editors[i + 1]); } } return(null); }
public object Edit(Rect region, GUIContent label, object element, fiGraphMetadata metadata) { // draw the nullable type toggle { int labelHeight = (int)EditorStyles.label.CalcHeight(GUIContent.none, 100); Rect toggleRegion = new Rect(region); toggleRegion.height = labelHeight; region.y += toggleRegion.height; region.height -= toggleRegion.height; if (EditorGUI.Toggle(toggleRegion, label, element != null)) { if (element == null) { element = _elementType.CreateInstance(); GUI.changed = true; } } else { element = null; } } // no element; no editor if (element == null) { return(null); } // we have a value for the nullable type; draw the property editor { Rect selectedRegion = new Rect(region); selectedRegion = fiRectUtility.IndentedRect(selectedRegion); region.y += selectedRegion.height; region.height -= selectedRegion.height; // show custom editor PropertyEditorChain chain = PropertyEditor.Get(element.GetType(), null); IPropertyEditor editor = chain.SkipUntilNot(typeof(NullablePropertyEditor)); return(editor.Edit(selectedRegion, GUIContent.none, element, metadata.Enter("NullableEditor", metadata.Context))); } }
protected override void OnEdit(Rect rect, UnityObject behavior, fiGraphMetadata metadata) { fiGraphMetadataChild childMetadata = metadata.Enter("DefaultBehaviorEditor"); childMetadata.Metadata.GetPersistentMetadata <fiDropdownMetadata>().ForceDisable(); // We don't want to get the IObjectPropertyEditor for the given target, which extends // UnityObject, so that we can actually edit the property instead of getting a Unity // reference field. We also don't want the AbstractTypePropertyEditor, which we will get // if the behavior has any derived types. PropertyEditorChain editorChain = PropertyEditor.Get(behavior.GetType(), null); IPropertyEditor editor = editorChain.SkipUntilNot( typeof(IObjectPropertyEditor), typeof(AbstractTypePropertyEditor)); // Run the editor editor.Edit(rect, GUIContent.none, behavior, childMetadata); }
private void DecoratePropertyEditor(IPropertyEditor editor, int row) { var ctr = editor.ContainerWidget; if (!(editor is IExpandablePropertyEditor)) { ctr.Nodes.Insert(0, new HSpacer(20)); } var index = ctr.Nodes.Count() - 1; if (PropertyAttributes <TangerineStaticPropertyAttribute> .Get(editor.EditorParams.PropertyInfo) == null) { var keyFunctionButton = new KeyFunctionButton { LayoutCell = new LayoutCell(Alignment.LeftCenter, stretchX: 0), }; var keyframeButton = new KeyframeButton { LayoutCell = new LayoutCell(Alignment.LeftCenter, stretchX: 0), KeyColor = KeyframePalette.Colors[editor.EditorParams.TangerineAttribute.ColorIndex], }; keyFunctionButton.Clicked += editor.SetFocus; keyframeButton.Clicked += editor.SetFocus; ctr.Nodes.Insert(index++, keyFunctionButton); ctr.Nodes.Insert(index++, keyframeButton); ctr.Nodes.Insert(index, new HSpacer(4)); ctr.Tasks.Add(new KeyframeButtonBinding(editor.EditorParams, keyframeButton)); ctr.Tasks.Add(new KeyFunctionButtonBinding(editor.EditorParams, keyFunctionButton)); } else { ctr.Nodes.Insert(2, new HSpacer(42)); } editor.ContainerWidget.Padding = new Thickness { Left = 4, Top = 1, Right = 12, Bottom = 1 }; editor.ContainerWidget.CompoundPresenter.Add(new WidgetFlatFillPresenter( row % 2 == 0 ? ColorTheme.Current.Inspector.StripeBackground1 : ColorTheme.Current.Inspector.StripeBackground2 ) { IgnorePadding = true }); }
public IPropertyEditor GetNextEditor(IPropertyEditor editor) { int i = 0; while (i < this._editors.Count) { if (this._editors[i] == editor) { if (i + 1 >= this._editors.Count) { return null; } return this._editors[i + 1]; } else { i++; } } return null; }
public float GetElementHeight(GUIContent label, object element, fiGraphMetadata metadata) { float height = EditorStyles.popup.CalcHeight(label, 100); height += fiRectUtility.IndentVertical; if (element != null) { PropertyEditorChain chain = PropertyEditor.Get(element.GetType(), null); IPropertyEditor editor = chain.SkipUntilNot(typeof(AbstractTypePropertyEditor)); height += editor.GetElementHeight(GUIContent.none, element, metadata.Enter("AbstractTypeEditor")); } var abstractTypeMetadata = metadata.GetMetadata <AbstractTypeAnimationMetadata>(); height = fiEditorGUI.AnimatedHeight(height, abstractTypeMetadata.ChangedTypes, metadata); abstractTypeMetadata.ChangedTypes = false; return(height); }
private static bool TryCreateInstance(Type editorType, Type usedEditedType, Type actualEditedType, out IPropertyEditor editor) { if (editorType.GetConstructor(Type.EmptyTypes) == null) { Debug.LogWarning("Type " + editorType + " can serve as a property editor if it has a default constructor"); editor = null; return false; } editor = (IPropertyEditor)Activator.CreateInstance(editorType); if (!PropertyEditorTools.CanEdit(usedEditedType, editorType.GetAttribute<CustomPropertyEditorAttribute>())) { editor = null; return false; } if (!editor.CanEdit(actualEditedType)) { editor = null; return false; } return true; }
protected virtual IPropertyEditor CreateEditor(Gdk.Rectangle cell_area, StateType state) { Type editorType = property.EditorType; if (editorType == null) { editorType = GetEditorForType(property.PropertyType); if (editorType == null) { return(null); } } IPropertyEditor editor = Activator.CreateInstance(editorType) as IPropertyEditor; if (editor == null) { throw new Exception("The property editor '" + editorType + "' must implement the interface IPropertyEditor"); } return(editor); }
protected virtual IPropertyEditor CreateEditor(Gdk.Rectangle cell_area, StateType state) { if (DialogueEdit && (!property.IsReadOnly || EditsReadOnlyObject)) { return(new PropertyDialogueEditor(this)); } else { Type editorType = editorManager.GetEditorType(property); if (editorType == null) { return(null); } IPropertyEditor editor = Activator.CreateInstance(editorType) as IPropertyEditor; if (editor == null) { throw new Exception("The property editor '" + editorType + "' must implement the interface IPropertyEditor"); } return(editor); } }
/// <summary> /// Creates a new instance of the given editorType. It is assumed that editorType extends /// IPropertyEditor. /// </summary> private static bool TryCreateInstance(Type editorType, Type usedEditedType, Type actualEditedType, ICustomAttributeProvider attributes, out IPropertyEditor editor) { if (editorType.GetConstructor(fsPortableReflection.EmptyTypes) == null && editorType.GetConstructor(NonEmptyConstructorArgs) == null) { Debug.LogWarning("Type " + editorType + " can serve as a property editor if it " + "has a default constructor or a constructor that takes a Type and an ICustomAttributeProvider arguments"); editor = null; return false; } if (CanEdit(usedEditedType, fsPortableReflection.GetAttribute<CustomPropertyEditorAttribute>(editorType)) == false) { editor = null; return false; } try { if (editorType.GetConstructor(NonEmptyConstructorArgs) != null) { editor = (IPropertyEditor)Activator.CreateInstance(editorType, new object[] { actualEditedType, attributes }); } else { editor = (IPropertyEditor)Activator.CreateInstance(editorType); } } catch (Exception e) { Debug.LogException(e); editor = null; return false; } if (editor.CanEdit(actualEditedType) == false) { editor = null; return false; } return true; }
/// <summary> /// Constructs the main form. /// </summary> public MainForm() { InitializeComponent(); MapUtils.SetPROJ_LIB(Environment.CurrentDirectory + "\\ProjLib"); Gdal.SetConfigOption("GDAL_DATA", Environment.CurrentDirectory); LocateDependencies(); textChanged = false; scrollPos = 0; caretPos = 0; dirtyFlag = false; isTemplate = false; fileHasChanged = false; selectedEditor = null; LoadSettings(); selectListForm = new SelectListForm(); selectListForm.VisibleChanged += new EventHandler(selectListForm_VisibleChanged); selectListForm.HelpRequested += new HelpEventHandler(editor_HelpRequested); EventProvider.EventMessage += new EventProvider.EventMessageEventHandler(EventProvider_EventMessage); this.splitContainer1.Panel1.Click += new EventHandler(LeftPanel_Click); this.splitContainer1.Panel2.Click += new EventHandler(LeftPanel_Click); // add render checkbox to status bar checkBoxRender = new CheckBox(); checkBoxRender.Text = ""; checkBoxRender.Checked = true; checkBoxRender.CheckedChanged += checkBoxRender_CheckedChanged; ToolStripControlHost cbItem = new ToolStripControlHost(checkBoxRender); //statusStripMain.Items.Add(cbItem); statusStripMain.Items.Insert(1, cbItem); UpdateMRU(); }
protected override float OnGetHeight(UnityObject behavior, fiGraphMetadata metadata) { fiGraphMetadataChild childMetadata = metadata.Enter("DefaultBehaviorEditor", null); childMetadata.Metadata.GetPersistentMetadata <fiDropdownMetadata>().ForceDisable(); float height = 0; // We don't want to get the IObjectPropertyEditor for the given // target, which extends UnityObject, so that we can actually edit // the property instead of getting a Unity reference field. We also // don't want the AbstractTypePropertyEditor, which we will get if // the behavior has any derived types. PropertyEditorChain editorChain = PropertyEditor.Get(behavior.GetType(), null); IPropertyEditor editor = editorChain.SkipUntilNot( typeof(IObjectPropertyEditor), typeof(AbstractTypePropertyEditor)); height += editor.GetElementHeight(GUIContent.none, behavior, childMetadata); return(height); }
/// <summary> /// Draws a GUI for editing the given property and returns the updated /// value. This does /// *not* write the updated value to a container. /// </summary> /// <param name="context"> /// An optional context that the property value came from. If this is not /// given, then a prefab context menu will not be displayable. /// </param> public static object EditPropertyDirect(Rect region, InspectedProperty property, object propertyValue, fiGraphMetadataChild metadataChild, object context) { fiGraphMetadata metadata = metadataChild.Metadata; // Show a "revert to prefab" value context-menu if possible if (context != null) { RevertPrefabContextMenu(region, context, property); } // get the label / tooltip GUIContent label = new GUIContent(property.DisplayName, InspectorTooltipAttribute.GetTooltip(property.MemberInfo)); var editorChain = PropertyEditor.Get(property.StorageType, property.MemberInfo); IPropertyEditor editor = editorChain.FirstEditor; EditorGUI.BeginDisabledGroup(property.CanWrite == false); propertyValue = editor.Edit(region, label, propertyValue, metadata.Enter("EditProperty", metadata.Context)); EditorGUI.EndDisabledGroup(); return(propertyValue); }
/// <summary> /// Attempts to create a property editor for the given edited data type /// from the given editor type. /// </summary> /// <param name="editedType">The type that is being edited.</param> /// <param name="editorType">The editor type.</param> /// <param name="attributes"> /// The attributes that were specified for the type. /// </param> /// <param name="forceInherit"> /// Should inheritance behavior be forced? The expected value is false. /// </param> /// <returns> /// A property editor that can edit the given edited type. /// </returns> public static IPropertyEditor TryCreateEditor(Type editedType, Type editorType, ICustomAttributeProvider attributes, bool forceInherit) { // If our editor isn't inherited, then we only want to create a // specific editor var customPropertyEditorAttribute = fsPortableReflection.GetAttribute <CustomPropertyEditorAttribute>(editorType); if (!forceInherit && (customPropertyEditorAttribute == null || customPropertyEditorAttribute.Inherit == false)) { return(TryCreateSpecificEditor(editedType, editedType, editorType, attributes)); } // Otherwise we want to try to create a property editor from any of // the edited type's associated types. Type baseType = editedType; while (baseType != null) { IPropertyEditor editor = TryCreateSpecificEditor(baseType, editedType, editorType, attributes); if (editor != null) { return(editor); } foreach (Type iface in baseType.GetInterfaces()) { editor = TryCreateSpecificEditor(iface, editedType, editorType, attributes); if (editor != null) { return(editor); } } baseType = baseType.BaseType; } return(null); }
public EditSession(Gtk.Widget container, object instance, PropertyDescriptor property, IPropertyEditor currentEditor) : this(container,instance,property,currentEditor,property.Converter) { }
/// <summary> /// 焦点定位到指定的属性编辑器 /// </summary> /// <param name="editor"></param> public bool FocusToEditor(IPropertyEditor editor) { /*********************** 代码块解释 ********************************* * 由于表单中可以使用了页签控件来作为许多属性的划分容器, * 所以此时需要找到指定属性对应的 TabItem,先激活该页签, * 然后才能对其中的属性编辑器进行设置焦点的操作。 **********************************************************************/ var editorControl = editor.Control; var form = this.Control; //查找 Form 中的 TabControl 控件。 //如果还没有生成完毕,则先更新布局,再尝试查找一次。 var tabControl = form.GetVisualChild<TabControl>(); if (tabControl == null) { form.UpdateLayout(); tabControl = form.GetVisualChild<TabControl>(); } if (tabControl != null) { //找到编辑器对应的 TabItem,设置为选中状态,然后焦点选中。 //方法:编辑器的可视根元素应该与 TabItem 的 Content 属性一致。 foreach (var item in tabControl.Items) { var tabItem = tabControl.ItemContainerGenerator.ContainerFromItem(item) as TabItem; if (tabItem != null) { //如果 TabItem 包含了这个编辑器。 var content = tabItem.Content as Visual; if (content != null && content.IsAncestorOf(editorControl)) { tabItem.IsSelected = true; //如果 TabItem 已经生成了可视树,则可以直接设置焦点成功。 //否则,则应该先更新布局,再设置编辑器的焦点。 var res = editorControl.Focus(); if (!res) { tabItem.UpdateLayout(); res = editorControl.Focus(); } //简单处理:异步设置焦点的情况下,直接视为成功。 return res; } } } } return editorControl.Focus(); }
/// <summary> /// 添加某个编辑器。 /// </summary> /// <param name="editor"></param> /// <returns></returns> internal void AddPropertyEditor(IPropertyEditor editor) { this._editors.Add(editor); }
public PropertyEditor (PropertyDescriptor prop) : base (false, 0) { propEditor = CreateEditor (prop); Add ((Gtk.Widget) propEditor); }
/// <summary> /// The ItemSelect event handler of the layer control. /// </summary> /// <param name="sender">The source object of this event.</param> /// <param name="target">The object which have been selected.</param> private void layerControl_ItemSelect(object sender, MapObjectHolder target) { ConfirmChanges(); layerPropertyEditor.Visible = false; mapPropertyEditor.Visible = false; selectedEditor = null; if (target == null) { } else if (target.GetType() == typeof(mapObj)) { mapPropertyEditor.Target = target; mapPropertyEditor.Visible = true; selectedEditor = mapPropertyEditor; } else if (target.GetType() == typeof(layerObj) || target.GetType() == typeof(classObj) || target.GetType() == typeof(styleObj) || target.GetType() == typeof(labelObj)) { layerPropertyEditor.Target = target; layerPropertyEditor.Visible = true; selectedEditor = layerPropertyEditor; } }
/// <summary> /// Returns true if there is another editor after the given one. /// </summary> public bool HasNextEditor(IPropertyEditor editor) { return GetNextEditor(editor) != null; }
void SetupPropertyEditor (IPropertyEditor peditor) { // Ensure the key exists Preferences.Get (peditor.Key); peditor.Setup (); }
public EditSession (Gtk.Widget container, object instance, PropertyDescriptor property, IPropertyEditor currentEditor) { this.property = property; this.obj = instance; this.container = container; this.currentEditor = currentEditor; currentEditor.ValueChanged += OnValueChanged; initialVal = currentEditor.Value; }
internal EditSession (Widget container, ITypeDescriptorContext context, IPropertyEditor currentEditor) { this.context = context; this.container = container; this.currentEditor = currentEditor; currentEditor.Initialize (this); if (Instance != null) currentEditor.Value = context.PropertyDescriptor.GetValue (Instance); currentEditor.ValueChanged += OnValueChanged; }
public EditSession (Gtk.Widget container, object instance, PropertyDescriptor property, IPropertyEditor currentEditor) { this.property = property; this.obj = instance; this.container = container; this.currentEditor = currentEditor; currentEditor.Initialize (this); if (instance != null) currentEditor.Value = property.GetValue (instance); currentEditor.ValueChanged += OnValueChanged; }
/// <summary> /// Constructs a new MapPropertyEditorForm object. /// </summary> /// <param name="target">The target object to be edited.</param> /// <param name="editor">The editor to be used.</param> public MapPropertyEditorForm(MapObjectHolder target, IPropertyEditor editor) { InitializeComponent(); this.SuspendLayout(); if (target.GetType() == typeof(mapObj)) { if (editor == null) { editor = new MapPropertyEditor(); ((MapPropertyEditor)editor).HelpRequested += new HelpEventHandler(mapPropertyEditor_HelpRequested); } this.Text = "Map Properties"; mapObj map = (mapObj)target; if (map.name != "") { this.Text += " (" + map.name + ")"; } this.editor = editor; } else if (target.GetType() == typeof(layerObj)) { if (editor == null) { editor = new LayerPropertyEditor(); ((LayerPropertyEditor)editor).HelpRequested += new HelpEventHandler(mapPropertyEditor_HelpRequested); } this.Text = "Layer Properties"; layerObj layer = (layerObj)target; if (layer.name != "") { this.Text += " (" + layer.name + ")"; } this.editor = editor; } else if (target.GetType() == typeof(classObj)) { if (editor == null) { editor = new ClassPropertyEditor(); ((ClassPropertyEditor)editor).HelpRequested += new HelpEventHandler(mapPropertyEditor_HelpRequested); } this.Text = "Class Properties"; classObj classObject = (classObj)target; StringBuilder scaledomain = new StringBuilder(""); if (classObject.minscaledenom >= 0) { if (classObject.maxscaledenom >= 0) { scaledomain.Append(" 1:" + classObject.minscaledenom.ToString("#,#", CultureInfo.InvariantCulture)); } else { scaledomain.Append(" from 1:" + classObject.minscaledenom.ToString("#,#", CultureInfo.InvariantCulture)); } } if (classObject.maxscaledenom >= 0) { scaledomain.Append(" to 1:" + classObject.maxscaledenom.ToString("#,#", CultureInfo.InvariantCulture)); } if (classObject.name != "") { this.Text += " (" + classObject.name + scaledomain + ")"; } this.editor = editor; } else if (target.GetType() == typeof(styleObj)) { if (editor == null) { editor = new StylePropertyEditor(); ((StylePropertyEditor)editor).HelpRequested += new HelpEventHandler(mapPropertyEditor_HelpRequested); } this.Text = "Style Properties"; this.editor = editor; } else if (target.GetType() == typeof(labelObj)) { if (editor == null) { editor = new LabelPropertyEditor(); ((LabelPropertyEditor)editor).HelpRequested += new HelpEventHandler(mapPropertyEditor_HelpRequested); } this.Text = "Label Properties"; this.editor = editor; } else if (target.GetType() == typeof(scalebarObj)) { if (editor == null) { editor = new ScalebarPropertyEditor(); ((ScalebarPropertyEditor)editor).HelpRequested += new HelpEventHandler(mapPropertyEditor_HelpRequested); } this.Text = "Scalebar Properties"; this.editor = editor; } else if (target.GetType() == typeof(queryMapObj)) { if (editor == null) { editor = new QueryMapPropertyEditor(); ((QueryMapPropertyEditor)editor).HelpRequested += new HelpEventHandler(mapPropertyEditor_HelpRequested); } this.Text = "Query Map Properties"; this.editor = editor; } else { throw new Exception("No editor have been implemented for this item"); } if (this.editor != null) { Control c = (Control)this.editor; c.Location = new System.Drawing.Point(3, 4); c.TabIndex = 0; editor.Target = target; this.Controls.Add(c); target.PropertyChanging += new EventHandler(target_PropertyChanging); editor.EditProperties += new EditPropertiesEventHandler(editor_EditProperties); buttonOK.Top = c.Bottom + 8; buttonCancel.Top = c.Bottom + 8; buttonApply.Top = c.Bottom + 8; } UpdateButtonState(); this.ResumeLayout(false); }
/// <summary> /// Constructs a new MapPropertyEditorForm object. /// </summary> /// <param name="target">The target object to be edited.</param> /// <param name="editor">The editor to be used.</param> public MapPropertyEditorForm(MapObjectHolder target, IPropertyEditor editor) { InitializeComponent(); this.SuspendLayout(); if (target.GetType() == typeof(mapObj)) { if (editor == null) { editor = new MapPropertyEditor(); ((MapPropertyEditor)editor).HelpRequested += new HelpEventHandler(mapPropertyEditor_HelpRequested); } this.Text = "Map Properties"; mapObj map = (mapObj)target; if (map.name != "") this.Text += " (" + map.name + ")"; this.editor = editor; } else if (target.GetType() == typeof(layerObj)) { if (editor == null) { editor = new LayerPropertyEditor(); ((LayerPropertyEditor)editor).HelpRequested += new HelpEventHandler(mapPropertyEditor_HelpRequested); } this.Text = "Layer Properties"; layerObj layer = (layerObj)target; if (layer.name != "") this.Text += " (" + layer.name + ")"; this.editor = editor; } else if (target.GetType() == typeof(classObj)) { if (editor == null) { editor = new ClassPropertyEditor(); ((ClassPropertyEditor)editor).HelpRequested += new HelpEventHandler(mapPropertyEditor_HelpRequested); } this.Text = "Class Properties"; classObj classObject = (classObj)target; StringBuilder scaledomain = new StringBuilder(""); if (classObject.minscaledenom >= 0) { if (classObject.maxscaledenom >= 0) scaledomain.Append(" 1:" + classObject.minscaledenom.ToString("#,#", CultureInfo.InvariantCulture)); else scaledomain.Append(" from 1:" + classObject.minscaledenom.ToString("#,#", CultureInfo.InvariantCulture)); } if (classObject.maxscaledenom >= 0) { scaledomain.Append(" to 1:" + classObject.maxscaledenom.ToString("#,#", CultureInfo.InvariantCulture)); } if (classObject.name != "") this.Text += " (" + classObject.name + scaledomain + ")"; this.editor = editor; } else if (target.GetType() == typeof(styleObj)) { if (editor == null) { editor = new StylePropertyEditor(); ((StylePropertyEditor)editor).HelpRequested += new HelpEventHandler(mapPropertyEditor_HelpRequested); } this.Text = "Style Properties"; this.editor = editor; } else if (target.GetType() == typeof(labelObj)) { if (editor == null) { editor = new LabelPropertyEditor(); ((LabelPropertyEditor)editor).HelpRequested += new HelpEventHandler(mapPropertyEditor_HelpRequested); } this.Text = "Label Properties"; this.editor = editor; } else if (target.GetType() == typeof(scalebarObj)) { if (editor == null) { editor = new ScalebarPropertyEditor(); ((ScalebarPropertyEditor)editor).HelpRequested += new HelpEventHandler(mapPropertyEditor_HelpRequested); } this.Text = "Scalebar Properties"; this.editor = editor; } else if (target.GetType() == typeof(queryMapObj)) { if (editor == null) { editor = new QueryMapPropertyEditor(); ((QueryMapPropertyEditor)editor).HelpRequested += new HelpEventHandler(mapPropertyEditor_HelpRequested); } this.Text = "Query Map Properties"; this.editor = editor; } else throw new Exception("No editor have been implemented for this item"); if (this.editor != null) { Control c = (Control)this.editor; c.Location = new System.Drawing.Point(3, 4); c.TabIndex = 0; editor.Target = target; this.Controls.Add(c); target.PropertyChanging += new EventHandler(target_PropertyChanging); editor.EditProperties += new EditPropertiesEventHandler(editor_EditProperties); buttonOK.Top = c.Bottom + 8; buttonCancel.Top = c.Bottom + 8; buttonApply.Top = c.Bottom + 8; } UpdateButtonState(); this.ResumeLayout(false); }
public void OnGUI() { EnsureResources(); GUILayout.BeginHorizontal(); GUILayout.FlexibleSpace(); _disablePopups = GUILayout.Toggle(_disablePopups, "Disable Dialog Boxes"); GUILayout.EndHorizontal(); GUILayout.Label("<b><size=25>About</size></b> If you've decided to change serializers (for example, from Json.NET to Full Serializer), then this utility will assist your migration.", RichLabel); fiEditorGUILayout.Splitter(3); IPropertyEditor editor = PropertyEditor.Get(typeof(TypeSpecifier <BaseSerializer>), null).FirstEditor; GUILayout.Label("Select the <i>current</i> serializer and then the <i>new</i> serializer", RichLabel); fiEditorGUILayout.WithIndent(50, () => { WithTemporaryLabelWidth(120, () => { editor.EditWithGUILayout(new GUIContent("Current Serializer"), _currentSerializer, _metadata.Enter(0)); editor.EditWithGUILayout(new GUIContent("New Serializer"), _newSerializer, _metadata.Enter(1)); }); }); fiEditorGUILayout.Splitter(3); if (_currentSerializer.Type == null || _newSerializer.Type == null) { return; } if (_currentSerializer.Type == _newSerializer.Type) { EditorGUILayout.HelpBox("You cannot migrate to the same serializer", MessageType.Error); return; } _selectedMode = GUILayout.SelectionGrid(_selectedMode, new string[] { "Migrate Active Selection", "Migrate Scene Objects", "Migrate Persistent Objects" }, 3); if (_selectedMode == 0) { GameObject[] toMigrate = DisplaySelection(); if (GUILayout.Button("Run Migration") && CheckAnnotationsPopup()) { BeforeMigrate(); foreach (var obj in toMigrate) { fiSerializerMigrationUtility.MigrateUnityObject(obj, _currentSerializer.Type, _newSerializer.Type); } DisplayPostSerializeMessage(); } } else if (_selectedMode == 1) { DisplayScenesGUI(); if (SceneObjectSelections == null) { SceneObjectSelections = new UnityObjectSelectionGroup(fiSerializerMigrationUtility.GetSceneObjects()); } GUILayout.Label("Scene Objects to Process", EditorStyles.boldLabel); SceneObjectSelections.OnGUI(); GUILayout.FlexibleSpace(); if (GUILayout.Button("Run Migration", GUILayout.ExpandWidth(true)) && CheckAnnotationsPopup()) { BeforeMigrate(); foreach (var obj in SceneObjectSelections.Selected) { fiSerializerMigrationUtility.MigrateUnityObject(obj, _currentSerializer.Type, _newSerializer.Type); } DisplayPostSerializeMessage(); } } else if (_selectedMode == 2) { if (PersistentObjectSelections == null) { PersistentObjectSelections = new UnityObjectSelectionGroup(fiSerializerMigrationUtility.GetPersistentObjects()); } GUILayout.Label("Persistent GameObjects to Process", EditorStyles.boldLabel); PersistentObjectSelections.OnGUI(); if (GUILayout.Button("Run Migration", GUILayout.ExpandWidth(true)) && CheckAnnotationsPopup()) { BeforeMigrate(); foreach (var obj in PersistentObjectSelections.Selected) { fiSerializerMigrationUtility.MigrateUnityObject(obj, _currentSerializer.Type, _newSerializer.Type); } DisplayPostSerializeMessage(); } } }
public override void OnApplyTemplate() { /*********************** 代码块解释 ********************************* * * 在应用模板时: * 找到属性界面元数据; * 生成属性编辑器; * 把属性编辑器中的控件加入到本控件模板的相应位置; * **********************************************************************/ base.OnApplyTemplate(); this.InitForm(); if (this._form == null) { return; } var detailView = this._form.DetailView; if (detailView == null) { return; } var property = this.GetPropertyViewMeta(detailView); if (property == null) { return; } //由于这个控件可以被所有属性使用,所以这里还需要对是否在 Detail 中显示进行判断。 if (!property.CanShowIn(ShowInWhere.Detail)) { this.Visibility = Visibility.Collapsed; return; } this.BindVisibility(property); #region 生成编辑器 var editor = AutoUI.BlockUIFactory.PropertyEditorFactory.Create(property, false); //如果还没有给 Form 赋值,则不能给 editor 设置值。 //否则 PropertyEditorFactory 在创建 editor 时为其设置的只读性会在此处被清除。 var ro = this._form.IsReadOnly; if (ro != ReadOnlyStatus.Dynamic) { editor.IsReadOnly = ro; } this.PropertyEditor = editor; detailView.AddPropertyEditor(editor); #endregion #region 把编辑器中的两个控件放到模板控件中 var labelContainer = this.Template.FindName("PART_LabelContainer", this) as ContentControl; var editorControlContainer = this.Template.FindName("PART_EditorControlContainer", this) as ContentControl; if (labelContainer != null) labelContainer.Content = editor.LabelControl; if (editorControlContainer != null) editorControlContainer.Content = editor.Control; #endregion this.SetLayoutValues(detailView, property); #region 处理需要根据实体状态变化的:动态属性编辑器 var dynamicPE = editor as EntityDynamicPropertyEditor; if (dynamicPE != null) { detailView.CurrentChanged += (o, e) => { editor.PrepareElementForEdit(dynamicPE.Control, new RoutedEventArgs()); }; } #endregion #region 支持 UI Test var label = property.Label; if (label != null) { AutomationProperties.SetName(editor.Control, property.Label); } #endregion }