public CreateBindingViewModel(TargetPlatform platform, IObjectEditor targetEditor, IPropertyInfo property, PropertyVariation variations = null) : base(platform) { if (platform == null) { throw new ArgumentNullException(nameof(platform)); } if (targetEditor == null) { throw new ArgumentNullException(nameof(targetEditor)); } if (platform.BindingProvider == null) { throw new ArgumentException("Null BindingProvider on TargetPlatform", nameof(platform)); } if (property == null) { throw new ArgumentNullException(nameof(property)); } this.editorProvider = platform.EditorProvider; this.targetEditor = targetEditor; this.property = property; this.provider = platform.BindingProvider; this.variations = variations; PropertyDisplay = String.Format(Resources.CreateDataBindingTitle, $"[{this.targetEditor.TargetType.Name}].{property.Name}"); RequestNamedDisplay(); BindingSources = new AsyncValue <IReadOnlyList <BindingSource> > ( platform.BindingProvider.GetBindingSourcesAsync(targetEditor.Target, property)); RequestBindingObject(); }
private async Task <IObjectEditor[]> AddEditorsAsync(IList newItems) { Task <IObjectEditor>[] newEditorTasks = new Task <IObjectEditor> [newItems.Count]; for (int i = 0; i < newEditorTasks.Length; i++) { newEditorTasks[i] = EditorProvider.GetObjectEditorAsync(newItems[i]); } IObjectEditor[] newEditors = await Task.WhenAll(newEditorTasks); for (int i = 0; i < newEditors.Length; i++) { IObjectEditor editor = newEditors[i]; if (editor == null) { continue; } var notifier = editor.Properties as INotifyCollectionChanged; if (notifier != null) { notifier.CollectionChanged += OnObjectEditorPropertiesChanged; } } this.objEditors.AddRange(newEditors); return(newEditors); }
public async Task PropertyChanged() { var obj = new TestClass(); var provider = new ReflectionEditorProvider(); IObjectEditor editor = await provider.GetObjectEditorAsync(obj); const string value = "value"; var property = editor.Properties.Single(); bool changed = false; editor.PropertyChanged += (sender, args) => { if (Equals(args.Property, property)) { changed = true; } }; await editor.SetValueAsync(property, new ValueInfo <string> { Value = value }); Assert.That(changed, Is.True, "PropertyChanged was not raised for the given property"); }
public async Task CombinableEnum() { var enumObj = new EnumClass(); var provider = new ReflectionEditorProvider(); IObjectEditor editor = await provider.GetObjectEditorAsync(enumObj); List <int> values = new List <int> (); values.Add((int)FlagsTestEnum.Flag1); values.Add((int)FlagsTestEnum.Flag3); FlagsTestEnum expected = FlagsTestEnum.Flag1 | FlagsTestEnum.Flag3; await editor.SetValueAsync(editor.Properties.First(), new ValueInfo <IReadOnlyList <int> > { Value = values }); ValueInfo <int> underlying = await editor.GetValueAsync <int> (editor.Properties.First()); Assert.That((FlagsTestEnum)underlying.Value, Is.EqualTo(expected)); ValueInfo <IReadOnlyList <int> > underlyingList = await editor.GetValueAsync <IReadOnlyList <int> > (editor.Properties.First()); Assert.That(underlyingList.Value, Contains.Item((int)FlagsTestEnum.Flag1)); Assert.That(underlyingList.Value, Contains.Item((int)FlagsTestEnum.Flag3)); }
public ObjectTreeElement(IEditorProvider provider, IObjectEditor editor) { if (provider == null) { throw new ArgumentNullException(nameof(provider)); } if (editor == null) { throw new ArgumentNullException(nameof(editor)); } Editor = editor; Children = new AsyncValue <IReadOnlyList <ObjectTreeElement> > (QueryChildrenAsync(provider)); string typeName = $"[{Editor.TargetType.Name}]"; Task <string> nameTask; INameableObject nameable = Editor as INameableObject; if (nameable != null) { nameTask = nameable.GetNameAsync().ContinueWith(t => (!String.IsNullOrWhiteSpace(t.Result)) ? $"{typeName} \"{t.Result}\"" : typeName, TaskScheduler.Default); } else { nameTask = Task.FromResult(typeName); } Name = new AsyncValue <string> (nameTask, typeName); }
private Mock <IEditorProvider> CreateProviderMock(object value, IObjectEditor editor) { var m = new Mock <IEditorProvider> (); m.Setup(e => e.GetObjectEditorAsync(value)).ReturnsAsync(editor); return(m); }
public static void ObjectEdit(JMXObject objSource, bool isNew, IObjectHost host, string actionID, Action <IObjectEditor> RefreshHostDelegate, IObjectEditor editor) { IObjectEditor oe; if (editor == null) { editor = new MultiEdit(objSource.ObjectName); } oe = editor; oe.IsNew = isNew; oe.EditObject = objSource; if (oe.EditObject != null) { oe.Owner = host == null ? null : (host as Control).FindForm(); oe.ObjectHost = host; oe.DataSaved += (sender, e) => { IObjectEditor _oe = (sender as IObjectEditor); if (_oe != null && _oe.TrueSaved && _oe.RefreshHostOnSaved && RefreshHostDelegate != null) { RefreshHostDelegate(oe); } }; oe.ContinuousEditing = true; Form form = (oe as Form); if (form != null) { form.FormClosed += (sender, e) => { IObjectEditor _oe = (sender as IObjectEditor); if (_oe != null && _oe.TrueSaved && _oe.RefreshHostOnExit && RefreshHostDelegate != null) { RefreshHostDelegate(oe); } Control _host = (_oe.ObjectHost as Control); if (_host != null) { _host.Focus(); } } } ; if (oe.Owner != null && !oe.Owner.Modal) { form.Show(); } else { form.ShowDialog(); form.Dispose(); } } } }
private void AddEditors(IList editors) { for (int i = 0; i < editors.Count; i++) { IObjectEditor editor = (IObjectEditor)editors[i]; this.subscribedEditors.Add(editor); SetupEditor(editor); } }
private void RemoveEditors(IList editors) { for (int i = 0; i < editors.Count; i++) { IObjectEditor editor = (IObjectEditor)editors[i]; this.subscribedEditors.Remove(editor); TeardownEditor(editor); } }
public Task <IObjectEditor> GetObjectEditorAsync(object item) { if (item is Tuple <object, object []> tuple) { this.currentObject = tuple; this.currentEditor = new PropertyPadObjectEditor(tuple);; return(Task.FromResult(currentEditor)); } return(Task.FromResult <IObjectEditor> (null)); }
private GeometryEdit() { this._app = DF3DApplication.Application; if (this._app != null && this._app.Current3DMapControl != null) { this._geoEditor = this._app.Current3DMapControl.ObjectEditor; this._app.Current3DMapControl.RcObjectEditFinish += new System.EventHandler(this.AxRenderControl_RcObjectEditFinish); this._app.Current3DMapControl.RcObjectEditing += new Gvitech.CityMaker.Controls._IRenderControlEvents_RcObjectEditingEventHandler(this.AxRenderControl_RcObjectEditing); } }
private void ToolStripMenuItemEditPolyline_Click(object sender, EventArgs e) { Guid g = this.axRenderControl1.ProjectTree.FindItem("root\\å›¾æ ‡æ ‡ç¾\\RenderPolyline"); IRenderPolyline rpl = this.axRenderControl1.ObjectManager.GetObjectById(g) as IRenderPolyline; this.axRenderControl1.InteractMode = gviInteractMode.gviInteractEdit; IObjectEditor objEditor = this.axRenderControl1.ObjectEditor; objEditor.StartEditRenderGeometry(rpl, gviGeoEditType.gviGeoEditVertex); }
public async Task DontSetupPropertiesMarkedUnbrowsable() { var unbrowsable = new Unbrowsable(); var provider = new ReflectionEditorProvider(); IObjectEditor editor = await provider.GetObjectEditorAsync(unbrowsable); Assert.That(editor.Properties.Count, Is.EqualTo(1), "Wrong number of properties"); Assert.That(editor.Properties.Single().Name, Is.EqualTo(nameof(Unbrowsable.VisibleProperty))); }
public ObjectEditorCore(IObjectEditor <TEditor, TTemplate> objectEditor, Func <TTemplate, PropertyInfo, IList <object>, PropertyItem <TEditor> > propertyItemFactory, Func <TTemplate> getTemplate) { this.objectEditor = objectEditor; this.propertyItemFactory = propertyItemFactory; editorTemplateMatcher = new NameAndTypeTemplateMatcher <TTemplate>() .Chain(new TypeTemplateMatcher <TTemplate>() .Chain(new EnumTemplateMatcher <TTemplate>() .Chain(new ReturnTemplateMatcher <TTemplate>(getTemplate)))); }
public Task <IObjectEditor> GetObjectEditorAsync(object item) { if (this.editorCache.TryGetValue(item, out IObjectEditor cachedEditor)) { return(Task.FromResult(cachedEditor)); } IObjectEditor editor = ChooseEditor(item); this.editorCache.Add(item, editor); return(Task.FromResult(editor)); }
public void AvailabilityUpdates() { IObjectEditor editor = null; var constraint = new Mock <IAvailabilityConstraint>(); var prop = new Mock <IPropertyInfo> (); prop.SetupGet(p => p.Type).Returns(typeof(int)); prop.SetupGet(p => p.AvailabilityConstraints).Returns(new[] { constraint.Object }); bool isAvailable = false; var constraint2 = new Mock <IAvailabilityConstraint> (); constraint2.SetupGet(a => a.ConstrainingProperties).Returns(new[] { prop.Object }); var prop2 = new Mock <IPropertyInfo> (); prop2.SetupGet(p => p.Type).Returns(typeof(int)); prop2.SetupGet(p => p.AvailabilityConstraints).Returns(new[] { constraint2.Object }); editor = new MockObjectEditor(prop.Object, prop2.Object); constraint.Setup(c => c.GetIsAvailableAsync(editor)).ReturnsAsync(true); constraint2.Setup(c => c.GetIsAvailableAsync(editor)).ReturnsAsync(() => isAvailable); var pvm = new PropertyViewModel <int> (TargetPlatform.Default, prop.Object, new[] { editor }); var pvm2 = new PropertyViewModel <int> (TargetPlatform.Default, prop2.Object, new[] { editor }); var vm = new PropertyGroupViewModel(TargetPlatform.Default, "category", new[] { pvm, pvm2 }, new [] { editor }); Assume.That(vm.Properties, Contains.Item(pvm)); Assume.That(vm.Properties, Does.Not.Contain(pvm2)); INotifyCollectionChanged notify = vm.Properties as INotifyCollectionChanged; Assume.That(notify, Is.Not.Null); bool changed = false; notify.CollectionChanged += (sender, args) => { if (args.Action == NotifyCollectionChangedAction.Add && args.NewItems[0] == pvm2) { changed = true; } }; isAvailable = true; // Bit of integration here, constrainting property changes will trigger availability requery pvm.Value = 5; Assert.That(changed, Is.True); Assert.That(vm.Properties, Contains.Item(pvm)); Assert.That(vm.Properties, Contains.Item(pvm2)); }
public async Task SetReadOnlyBrushInitialValueAsync(IObjectEditor editor, CommonBrush brush) { if (this.readOnlyBrushSet) { return; } await editor.SetValueAsync(this.readOnlyBrushPropertyInfo, new ValueInfo <CommonBrush> { Value = brush }); this.readOnlyBrushSet = true; }
public async Task EditorHasSimpleProperty() { var provider = new ReflectionEditorProvider(); IObjectEditor editor = await provider.GetObjectEditorAsync(new TestClass()); Assume.That(editor, Is.Not.Null); Assert.That(editor.Properties.Count, Is.EqualTo(1)); var property = editor.Properties.Single(); Assert.That(property.Name, Is.EqualTo(nameof(TestClass.Property))); Assert.That(property.Type, Is.EqualTo(typeof(string))); }
public void ShowEditor(IObjectEditor editor) { ObjectEditorForm f = FindObjectEditor(editor); if (f == null) { f = new ObjectEditorForm((IObjectEditor)editor); try { f.Show(((IMdiContainer)_mdiParent).DockPanel); } catch (Exception ex) { MessageBox.Show(ex.ToString()); } } else { f.Activate(); } }
public async Task GetValueConvert() { const string value = "1"; var obj = new TestClass { Property = value }; var provider = new ReflectionEditorProvider(); IObjectEditor editor = await provider.GetObjectEditorAsync(obj); ValueInfo <int> info = await editor.GetValueAsync <int> (editor.Properties.Single()); Assert.That(info.Value, Is.EqualTo(1)); Assert.That(info.Source, Is.EqualTo(ValueSource.Local)); }
public async Task SetValueConvert() { var obj = new TestClass(); var provider = new ReflectionEditorProvider(); IObjectEditor editor = await provider.GetObjectEditorAsync(obj); const string value = "1"; await editor.SetValueAsync(editor.Properties.Single(), new ValueInfo <int> { Value = 1 }); Assert.That(obj.Property, Is.EqualTo(value)); }
public void FilteredOutOfChildren() { IObjectEditor editor = null; var prop = new Mock <IPropertyInfo> (); prop.SetupGet(p => p.Type).Returns(typeof(int)); prop.SetupGet(p => p.Name).Returns("one"); var prop2 = new Mock <IPropertyInfo> (); prop2.SetupGet(p => p.Type).Returns(typeof(int)); prop2.SetupGet(p => p.Name).Returns("two"); editor = new MockObjectEditor(prop.Object, prop2.Object); var pvm = new PropertyViewModel <int> (TargetPlatform.Default, prop.Object, new[] { editor }); var pvm2 = new PropertyViewModel <int> (TargetPlatform.Default, prop2.Object, new[] { editor }); var vm = new PropertyGroupViewModel(TargetPlatform.Default, "category", new[] { pvm, pvm2 }, new [] { editor }); Assume.That(vm.Properties, Contains.Item(pvm)); Assume.That(vm.Properties, Contains.Item(pvm2)); bool changed = false; vm.PropertyChanged += (sender, args) => { if (args.PropertyName == nameof(PropertyGroupViewModel.HasChildElements)) { changed = true; } }; vm.FilterText = "1"; Assert.That(changed, Is.True, "HasChildElements didn't change"); Assert.That(vm.HasChildElements, Is.False); Assert.That(vm.Properties, Does.Not.Contain(pvm2)); Assert.That(vm.Properties, Does.Not.Contain(pvm)); changed = false; vm.FilterText = null; Assert.That(changed, Is.True, "HasChildElements didn't change"); Assert.That(vm.HasChildElements, Is.True); Assert.That(vm.Properties, Contains.Item(pvm2)); Assert.That(vm.Properties, Contains.Item(pvm)); }
private async Task <IReadOnlyList <CollectionPropertyItemViewModel> > GetViewsFromValueAsync() { var items = new List <CollectionPropertyItemViewModel> (Value.Count); for (int i = 0; i < Value.Count; i++) { object target = Value[i]; IObjectEditor editor = await this.cachedProvider.GetAndCacheEditorAsync(target); items.Add(new CollectionPropertyItemViewModel(target, editor.TargetType) { Row = i }); } return(items); }
async Task SetInitialValuesAsync(MockedSampleControlButton mocked) { if (mocked == null) { return; } IObjectEditor editor = await PropertyPanel.TargetPlatform.EditorProvider.GetObjectEditorAsync(mocked.MockedControl); await mocked.MockedControl.SetInitialValuesAsync(editor); await mocked.MockedControl.SetBrushInitialValueAsync(editor, new CommonSolidBrush (20, 120, 220, 240, "sRGB")); await mocked.MockedControl.SetMaterialDesignBrushInitialValueAsync(editor, new CommonSolidBrush (0x65, 0x1F, 0xFF, 200)); await mocked.MockedControl.SetReadOnlyBrushInitialValueAsync(editor, new CommonSolidBrush (240, 220, 15, 190)); }
public async Task TypeConvertFromPropertyAttribute() { const string value = "value"; var obj = new ConversionClass2(); var provider = new ReflectionEditorProvider(); IObjectEditor editor = await provider.GetObjectEditorAsync(obj); Assume.That(editor.Properties.Count, Is.EqualTo(1)); await editor.SetValueAsync(editor.Properties.Single(), new ValueInfo <string> { Value = value, Source = ValueSource.Local }); Assert.That(obj.Property, Is.Not.Null); Assert.That(obj.Property.Property, Is.EqualTo(value)); }
public async Task SetInitialValuesAsync(IObjectEditor editor) { await editor.SetValueAsync(Properties["FilePath"], new ValueInfo <FilePath> { Value = new FilePath("/Desktop/MyTestFile") }); await editor.SetValueAsync(Properties["DateTime"], new ValueInfo <DateTime> { Value = DateTime.Now }); await editor.SetValueAsync(Properties["Date"], new ValueInfo <Date> { Value = new Date(DateTime.Now) }); await editor.SetValueAsync(Properties["Time"], new ValueInfo <Time> { Value = new Time(DateTime.Now) }); }
public async Task TypeConverterToPropertyAttribute() { const string value = "value"; var obj = new ConversionClass2 { Property = new TestClass2 { Property = value } }; var provider = new ReflectionEditorProvider(); IObjectEditor editor = await provider.GetObjectEditorAsync(obj); Assume.That(editor.Properties.Count, Is.EqualTo(1)); ValueInfo <string> info = await editor.GetValueAsync <string> (editor.Properties.Single()); Assert.That(info.Value, Is.EqualTo(value)); Assert.That(info.Source, Is.EqualTo(ValueSource.Local)); }
public ObjectEditorForm(IObjectEditor editor) { // // The InitializeComponent() call is required for Windows Forms designer support. // InitializeComponent(); ObjectEditor = editor; this.Controls.Add((Control)editor); if (editor is ContainerControl) { ContainerControl control = (ContainerControl) editor; this.Text = control.ToString(); control.TextChanged += new EventHandler(control_TextChanged); } else { this.Text = editor.ToString(); } this.Icon = editor.Icon; }
public void Filtered() { IObjectEditor editor = null; var prop = new Mock <IPropertyInfo> (); prop.SetupGet(p => p.Type).Returns(typeof(int)); prop.SetupGet(p => p.Name).Returns("one"); var prop2 = new Mock <IPropertyInfo> (); prop2.SetupGet(p => p.Type).Returns(typeof(int)); prop2.SetupGet(p => p.Name).Returns("two"); editor = new MockObjectEditor(prop.Object, prop2.Object); var pvm = new PropertyViewModel <int> (TargetPlatform.Default, prop.Object, new[] { editor }); var pvm2 = new PropertyViewModel <int> (TargetPlatform.Default, prop2.Object, new[] { editor }); var vm = new PropertyGroupViewModel(TargetPlatform.Default, "category", new[] { pvm, pvm2 }, new [] { editor }); Assume.That(vm.Properties, Contains.Item(pvm)); Assume.That(vm.Properties, Contains.Item(pvm2)); INotifyCollectionChanged notify = vm.Properties as INotifyCollectionChanged; Assume.That(notify, Is.Not.Null); bool changed = false; notify.CollectionChanged += (sender, args) => { if (args.Action == NotifyCollectionChangedAction.Remove && args.OldItems[0] == pvm) { changed = true; } }; vm.FilterText = "t"; Assert.That(changed, Is.True, "Collection changed event didn't trigger correctly"); Assert.That(vm.Properties, Contains.Item(pvm2)); Assert.That(vm.Properties, Does.Not.Contain(pvm)); Assert.That(vm.HasChildElements, Is.True); }
public async Task <IReadOnlyCollection <IPropertyInfo> > GetPropertiesForTypeAsync(ITypeInfo type) { Type realType = ReflectionEditorProvider.GetRealType(type); if (realType == null) { return(Array.Empty <IPropertyInfo> ()); } if (typeof(MockControl).IsAssignableFrom(realType)) { object item = await CreateObjectAsync(type); IObjectEditor editor = ChooseEditor(item); return(editor.Properties); } return(ReflectionEditorProvider.GetPropertiesForType(realType)); }
private void btnRotateMotionObject_Click(object sender, EventArgs e) { if (renderModelPoint != null) { if (_geoEditor == null) { _geoEditor = this.axRenderControl1.ObjectEditor; } _geoEditor.FinishEdit(); axRenderControl1.FeatureManager.UnhighlightAll(); axRenderControl1.InteractMode = gviInteractMode.gviInteractEdit; resultCode = _geoEditor.StartEditRenderGeometry(renderModelPoint, gviGeoEditType.gviGeoEdit3DRotate); if (!resultCode) { MessageBox.Show(this.axRenderControl1.GetLastError().ToString()); } } }
public void PropertyGroup() { IObjectEditor editor = null; var prop = new Mock <IPropertyInfo> (); prop.SetupGet(p => p.Type).Returns(typeof(int)); var prop2 = new Mock <IPropertyInfo> (); prop2.SetupGet(p => p.Type).Returns(typeof(int)); editor = new MockObjectEditor(prop.Object, prop2.Object); var pvm = new PropertyViewModel <int> (TargetPlatform.Default, prop.Object, new[] { editor }); var pvm2 = new PropertyViewModel <int> (TargetPlatform.Default, prop2.Object, new[] { editor }); var vm = new PropertyGroupViewModel(TargetPlatform.Default, "category", new[] { pvm, pvm2 }, new [] { editor }); Assert.That(vm.Properties, Contains.Item(pvm)); Assert.That(vm.Properties, Contains.Item(pvm2)); }
public DialogResult ShowEditorDialog(IObjectEditor editor) { ObjectEditorForm f = new ObjectEditorForm((IObjectEditor)editor); f.StartPosition = FormStartPosition.CenterScreen; return f.ShowDialog(_mdiParent); }
private ObjectEditorForm FindObjectEditor(IObjectEditor editor) { if (_mdiParent == null) { return null; } foreach(Object form in ((IMdiContainer) _mdiParent).DockPanel.Contents) { if (form.GetType() == typeof(ObjectEditorForm)) { if ( ((ObjectEditorForm)form).ObjectEditor.SelectedObject == editor.SelectedObject && ((ObjectEditorForm)form).ObjectEditor.GetType() == editor.GetType()) { return (ObjectEditorForm)form; } } } return null; }
public void UnloadEditorPanel(out bool cancel) { cancel = false; if (_objectEditor != null) { _objectEditor.QueryUnload(out cancel); if ( !cancel ) { _objectEditor = null; } } }
public static void OpenObjectEditor(IObjectEditor editor) { _handlingStrategy.ShowEditor(editor); }
public static DialogResult OpenObjectEditorDialog(IObjectEditor editor) { return _handlingStrategy.ShowEditorDialog(editor); }