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);
}
