/// ------------------------------------------------------------------------------------
public ComponentEditorTabPage(IEditorProvider provider, Color borderColor)
{
DoubleBuffered = true;
SetProvider(provider);
Padding = new Padding(3, 5, 5, 4);
_borderColor = borderColor;
}
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);
}
public PanelViewModel(IEditorProvider provider, TargetPlatform targetPlatform)
: base(provider, targetPlatform)
{
ArrangeModes = new List <ArrangeModeViewModel> {
new ArrangeModeViewModel(PropertyArrangeMode.Name, this),
new ArrangeModeViewModel(PropertyArrangeMode.Category, this)
};
}
public CachedEditorProvider(IEditorProvider realProvider)
{
if (realProvider == null)
{
throw new ArgumentNullException(nameof(realProvider));
}
this.realProvider = realProvider;
}
public TargetPlatform(IEditorProvider editorProvider)
{
if (editorProvider == null)
{
throw new ArgumentNullException(nameof(editorProvider));
}
EditorProvider = editorProvider;
}
private PropertyTreeElement(IEditorProvider provider, IPropertyInfo property, PropertyTreeElement parent)
: this(provider, property)
{
if (parent == null)
{
throw new ArgumentNullException(nameof(parent));
}
Parent = parent;
}
public TargetPlatform(IEditorProvider editorProvider, IResourceProvider resourceProvider, IBindingProvider bindingProvider)
: this(editorProvider, resourceProvider)
{
if (bindingProvider == null)
{
throw new ArgumentNullException(nameof(bindingProvider));
}
BindingProvider = bindingProvider;
}
public EditorProviderObject(Env env, CommonObject prototype, IEditorProvider provider)
: base(env, env.Maps.Base, prototype)
{
this.provider = provider;
this.editorPrototype = EditorObject.CreatePrototype(env);
var newEditor = Utils.CreateFunction(env, 0,
(Func<FunctionObject, CommonObject, CommonObject>)NewEditor);
this.Put("newEditor", newEditor, DescriptorAttrs.Immutable);
}
private async Task <IReadOnlyList <ObjectTreeElement> > QueryChildrenAsync(IEditorProvider provider)
{
var targets = await provider.GetChildrenAsync(Editor.Target);
List <Task <IObjectEditor> > editorTasks = new List <Task <IObjectEditor> > ();
foreach (object target in targets)
{
editorTasks.Add(provider.GetObjectEditorAsync(target));
}
IObjectEditor[] editors = await Task.WhenAll(editorTasks);
return(editors.Select(e => new ObjectTreeElement(provider, e)).ToArray());
}
internal PropertyTreeElement(IEditorProvider provider, IPropertyInfo property)
{
if (provider == null)
{
throw new ArgumentNullException(nameof(provider));
}
if (property == null)
{
throw new ArgumentNullException(nameof(property));
}
Property = property;
this.provider = provider;
this.properties = this.provider.GetPropertiesForTypeAsync(property.RealType);
}
public PropertiesViewModel(IEditorProvider provider, TargetPlatform targetPlatform)
{
if (provider == null)
{
throw new ArgumentNullException(nameof(provider));
}
if (targetPlatform == null)
{
throw new ArgumentNullException(nameof(targetPlatform));
}
EditorProvider = provider;
TargetPlatform = targetPlatform;
this.selectedObjects.CollectionChanged += OnSelectedObjectsChanged;
}
/// ------------------------------------------------------------------------------------
public void SetProvider(IEditorProvider provider)
{
if (EditorProvider != null)
{
EditorProvider.TabTextChanged -= HandleEditorTextChanged;
}
EditorProvider = provider;
Text = provider.TabText;
provider.TabTextChanged += HandleEditorTextChanged;
var control = EditorProvider.Control;
control.Dock = DockStyle.Fill;
Controls.Add(control);
ImageKey = EditorProvider.ImageKey;
}
internal PropertyTreeRoot(IEditorProvider provider, ITypeInfo type, IReadOnlyCollection <IPropertyInfo> properties)
{
if (provider == null)
{
throw new ArgumentNullException(nameof(provider));
}
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
if (properties == null)
{
throw new ArgumentNullException(nameof(properties));
}
TargetType = type;
Children = properties.Select(pi => new PropertyTreeElement(provider, pi)).ToArray();
}
public virtual IInputEditor GetDefaultEditor(IEditorProvider provider)
{
if (provider == null)
{
return((IInputEditor)null);
}
EditorRequiredEventArgs args = new EditorRequiredEventArgs(provider.GetDefaultEditorType());
this.gridViewElement.Template.EventDispatcher.RaiseEvent <EditorRequiredEventArgs>(EventDispatcher.EditorRequired, (object)this, args);
bool flag = this.IsPermanentEditor(args.EditorType);
if ((object)args.EditorType == null || flag)
{
return((IInputEditor)null);
}
if (args.Editor is IInputEditor)
{
IInputEditor editor = args.Editor as IInputEditor;
editor.EditorManager = (IEditorManager)this;
return(editor);
}
IInputEditor editor1 = (IInputEditor)null;
if (!this.cachedEditors.TryGetValue(args.EditorType, out editor1))
{
editor1 = Activator.CreateInstance(args.EditorType) as IInputEditor;
}
else
{
RadItem editorElement = this.GetEditorElement(editor1);
if (editorElement != null && editorElement.IsDisposed)
{
this.cachedEditors.Remove(args.EditorType);
editor1 = Activator.CreateInstance(args.EditorType) as IInputEditor;
}
}
if (editor1 != null && !this.cachedEditors.ContainsValue(editor1))
{
this.cachedEditors.Add(args.EditorType, editor1);
}
editor1.EditorManager = (IEditorManager)this;
return(editor1);
}
public ObjectPropertyViewModel(IEditorProvider provider, TargetPlatform targetPlatform, IPropertyInfo property, IEnumerable <IObjectEditor> editors)
: base(targetPlatform, property, editors)
{
if (provider == null)
{
throw new ArgumentNullException(nameof(provider));
}
if (targetPlatform == null)
{
throw new ArgumentNullException(nameof(targetPlatform));
}
this.provider = provider;
ValueModel = new ObjectViewModel(provider, targetPlatform);
RequestCurrentValueUpdate();
QueryTypes();
CreateInstanceCommand = new RelayCommand(CreateInstance, () => IsAvailable && !IsCreateInstancePending);
ClearValueCommand = new RelayCommand(OnClearValue, CanClearValue);
}
internal TargetPlatform WithProvider(IEditorProvider provider)
{
if (provider == null)
{
throw new ArgumentNullException(nameof(provider));
}
return(new TargetPlatform(provider)
{
ResourceProvider = ResourceProvider,
BindingProvider = BindingProvider,
IconProvider = IconProvider,
SupportsMaterialDesign = SupportsMaterialDesign,
SupportsCustomExpressions = SupportsCustomExpressions,
SupportsBrushOpacity = SupportsBrushOpacity,
GroupedTypes = GroupedTypes,
AutoExpandGroups = AutoExpandGroups,
ArrangeModes = ArrangeModes,
ErrorHandler = ErrorHandler
});
}
internal abstract TViewModel CreateVm(IEditorProvider provider);
public ObjectViewModel(IEditorProvider provider, TargetPlatform targetPlatform)
: base(provider, targetPlatform)
{
}
public MacPanelViewModel(IEditorProvider provider)
: base(provider)
{
ViewModelMap.Add(typeof(CoreGraphics.CGPoint), (p, e) => new PropertyViewModel <CoreGraphics.CGPoint> (p, e));
}
public CodeCompiler(IEditorProvider editorProvider, IOutput output, IErrorList errorList)
{
_editorProvider = editorProvider;
_output = output;
_errorList = errorList;
}
internal override PanelViewModel CreateVm(IEditorProvider provider)
{
return(new PanelViewModel(provider, TargetPlatform.Default));
}
public OpenFileService(IEditorProvider editorProvider, IMruFilePackage mruFilePackage)
{
_editorProvider = editorProvider;
_mruFilePackage = mruFilePackage;
}
public CodeCompiler(IEditorProvider editorProvider, IOutput output, IErrorList errorList)
{
_editorProvider = editorProvider;
_output = output;
_errorList = errorList;
}
