public static MenuItemDataProperty CreateMenuItem(IProperty p, LimnorContextMenuCollection menus)
{
PropertyPointer pp = p as PropertyPointer;
if (pp != null)
{
return(new PropertyItem(p.Name, menus.Owner, pp.Info));
}
else
{
PropertyClass pc = p as PropertyClass;
if (pc != null)
{
return(new PropertyItemClassPointer(p.Name, menus.Owner, pc));
}
else
{
IPropertyWrapper w = p as IPropertyWrapper;
if (w != null)
{
}
}
}
throw new DesignerException("Unsupported property type {0} for CreateMenuItem", p.GetType());
}
protected unsafe object GetObject(IntPtr guid)
{
// NOT WORKING with APPDATA
var prop = new PropertyPointer();
InitHeader <PropertyPointer>(ref prop.Header);
IntPtr value = IntPtr.Zero;
prop.Data = new IntPtr(&value);
Device.GetProperty(guid, new IntPtr(&prop));
if (prop.Data.ToInt64() == -1)
{
return(null);
}
var handle = GCHandle.FromIntPtr(prop.Data);
if (!handle.IsAllocated)
{
return(null);
}
return(handle.Target);
}
protected unsafe void SetObject(IntPtr guid, object value)
{
// NOT WORKING with APPDATA
var prop = new PropertyPointer();
InitHeader <PropertyPointer>(ref prop.Header);
var dataValue = IntPtr.Zero;
prop.Data = new IntPtr(&dataValue);
// Free previous application data if any
Device.GetProperty(guid, new IntPtr(&prop));
GCHandle handle;
if (prop.Data.ToInt64() != -1)
{
handle = GCHandle.FromIntPtr(prop.Data);
if (handle.IsAllocated)
{
handle.Free();
}
}
// Set new object value
handle = GCHandle.Alloc(value, GCHandleType.Pinned);
prop.Data = handle.AddrOfPinnedObject();
Device.SetProperty(guid, new IntPtr(&prop));
}
public override ActionClass CreateSetPropertyAction(ILimnorDesignPane designPane, IClass holder, IMethod scopeMethod, IActionsHolder actsHolder)
{
PropertyPointer pp = new PropertyPointer();
pp.SetPropertyInfo(_val);
pp.Owner = Owner;
return(DesignUtil.CreateSetPropertyAction(pp, designPane, scopeMethod, actsHolder, designPane.PaneHolder.FindForm()));
}
public override bool ExecuteMenuCommand(LimnorProject project, IClass holder, XmlNode node, MultiPanes pane, IMethod scopeMethod, IActionsHolder actsHolder)
{
PropertyPointer pp = new PropertyPointer();
pp.SetPropertyInfo(_val);
pp.Owner = Owner;
return(DesignUtil.CreateSetPropertyAction(pp, pane.Loader.DesignPane, scopeMethod, actsHolder, pane.FindForm()) != null);
}
public override PropertyPointer CreatePropertyPointer(string propertyName)
{
PropertyDescriptor pd = VPLUtil.GetProperty(_type, propertyName);
PropertyPointer pp = new PropertyPointer();
pp.Owner = ClassPointer;
pp.SetPropertyInfo(pd);
return(pp);
}
public bool IsField()
{
PropertyPointer pp = _valuePointer as PropertyPointer;
if (pp != null)
{
return(pp.IsField());
}
return(false);
}
private void buttonCameraStatupPerspective_Click(object sender, EventArgs e)
{
if (!Msg.OkCancel(this, Resources.StoreCameraPerspective, MsgSeverity.Info, Resources.StoreCameraPerspectiveOK, Resources.StoreCameraPerspectiveCancel))
{
return;
}
var cameraStatePointer = new PropertyPointer <CameraState <Vector2> >(() => _universe.CurrentCamera, camera => _universe.CurrentCamera = camera);
ExecuteCommand(new SetValueCommand <CameraState <Vector2> >(cameraStatePointer, _presenter.CameraState));
}
/// <summary>
/// Wraps a <see cref="TimeSpan"/> pointer in a <see cref="string"/> pointer.
/// </summary>
public static PropertyPointer <string> ToStringPointer([NotNull] this PropertyPointer <TimeSpan> pointer)
{
if (pointer == null)
{
throw new ArgumentNullException(nameof(pointer));
}
return(new PropertyPointer <string>(
getValue: () => ((int)pointer.Value.TotalSeconds).ToString(CultureInfo.InvariantCulture),
setValue: value => pointer.Value = TimeSpan.FromSeconds(int.Parse(value)),
defaultValue: ((int)pointer.DefaultValue.TotalSeconds).ToString(CultureInfo.InvariantCulture)));
}
/// <summary>
/// Wraps a <see cref="bool"/> pointer in a <see cref="string"/> pointer.
/// </summary>
public static PropertyPointer <string> ToStringPointer([NotNull] this PropertyPointer <bool> pointer)
{
if (pointer == null)
{
throw new ArgumentNullException(nameof(pointer));
}
return(new PropertyPointer <string>(
getValue: () => pointer.Value.ToString(CultureInfo.InvariantCulture),
setValue: value => pointer.Value = (value == "1" || (value != "0" && bool.Parse(value))),
defaultValue: pointer.DefaultValue.ToString(CultureInfo.InvariantCulture)));
}
/// <summary>
/// Wraps an <see cref="Uri"/> pointer in a <see cref="string"/> pointer.
/// </summary>
public static PropertyPointer <string> ToStringPointer([NotNull] this PropertyPointer <Uri> pointer)
{
if (pointer == null)
{
throw new ArgumentNullException(nameof(pointer));
}
return(new PropertyPointer <string>(
getValue: () => pointer.Value?.ToStringRfc(),
setValue: value => pointer.Value = (value == null) ? null : new Uri(value),
defaultValue: pointer.DefaultValue?.ToStringRfc()));
}
public void LoadData(LimnorContextMenuCollection type)
{
_menus = type;
//
List <MenuItemDataProperty> ps = _menus.PrimaryProperties;
if (ps != null && ps.Count > 0)
{
foreach (MenuItemDataProperty p in ps)
{
lstP.Items.Add(p);
}
}
List <MenuItemDataProperty> sps = _menus.SecondaryProperties;
if (sps != null && sps.Count > 0)
{
foreach (MenuItemDataProperty p in sps)
{
lstS.Items.Add(p);
}
}
SortedDictionary <string, IProperty> all = _menus.GetAllProperties();
SortedDictionary <string, TreeNode> customNodes = new SortedDictionary <string, TreeNode>();
foreach (KeyValuePair <string, IProperty> kv in all)
{
PropertyPointer pi = kv.Value as PropertyPointer;
if (pi != null)
{
treeViewAll.Nodes.Add(new TreeNodeProperty(false, pi));
}
else
{
PropertyClass pc = kv.Value as PropertyClass;
if (pc != null)
{
//use 0 as the scope method Id because property selection does not method scope
TreeNodeCustomProperty tnc = new TreeNodeCustomProperty(treeViewAll, pc.IsStatic, pc, 0);
customNodes.Add(tnc.Text, tnc);
}
}
}
int i = 0;
foreach (KeyValuePair <string, TreeNode> kv in customNodes)
{
treeViewAll.Nodes.Insert(i++, kv.Value);
}
//
}
/// <summary>
/// Wraps a <see cref="FeedUri"/> pointer in a <see cref="string"/> pointer.
/// </summary>
public static PropertyPointer <string> ToStringPointer([NotNull] this PropertyPointer <FeedUri> pointer)
{
#region Sanity checks
if (pointer == null)
{
throw new ArgumentNullException("pointer");
}
#endregion
return(new PropertyPointer <string>(
getValue: () => (pointer.Value == null) ? null : pointer.Value.ToStringRfc(),
setValue: value => pointer.Value = (value == null) ? null : new FeedUri(value),
defaultValue: (pointer.DefaultValue == null) ? null : pointer.DefaultValue.ToStringRfc()));
}
public override CodeExpression ExportIsNotNullCheck(IMethodCompile method)
{
if (_valuePointer != null)
{
PropertyPointer mp = _valuePointer as PropertyPointer;
IDatabaseFieldProvider ep = _valuePointer.Owner as IDatabaseFieldProvider;
if (ep != null && mp != null)
{
CodeExpression propOwner = _valuePointer.Owner.GetReferenceCode(method, method.MethodCode.Statements, true);
return(ep.GetIsNotNullCheck(method, method.MethodCode.Statements, mp.MemberName, propOwner));
}
else
{
CodeExpression ce = _valuePointer.GetReferenceCode(method, method.MethodCode.Statements, true);
return(new CodeBinaryOperatorExpression(ce, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null)));
}
}
else
{
CodeArgumentReferenceExpression ce = new CodeArgumentReferenceExpression(CodeName);
return(new CodeBinaryOperatorExpression(ce, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null)));
}
}
public MethodPointer(PropertyPointer owner, MethodInfo method)
{
_methodOwner = owner;
_method = method;
_name = method.Name;
}
/// <summary> /// Wraps a <see cref="FeedUri"/> pointer in a <see cref="string"/> pointer. Maps empty strings to <c>null</c> URIs. /// </summary> public static PropertyPointer <string> ToStringPointer(this PropertyPointer <FeedUri?> pointer) => PropertyPointer.For(
public FeedStructureEditor()
{
DescribeRoot <FeedEditor>("interface")
.AddPlainList("category", x => x.Categories)
.AddPlainList("feed", x => x.Feeds)
.AddPlainList("feed-for", x => x.FeedFor)
.AddProperty("replaced-by", x => PropertyPointer.For(() => x.ReplacedBy))
.AddPlainList("entry-point", x => x.EntryPoints, new EntryPointEditor())
.AddPlainList("capabilities", x => x.CapabilityLists)
.AddPlainList("splash-screen", x => x.SplashScreens, new IconEditor());
Describe <IIconContainer>()
.AddPlainList("icon", x => x.Icons, new IconEditor());
Describe <IDependencyContainer>()
.AddPlainList("requires", x => x.Dependencies)
.AddPlainList("restricts", x => x.Restrictions);
Describe <IBindingContainer>()
.AddList(x => x.Bindings)
.AddElement("binding", new GenericBinding())
.AddElement("environment", new EnvironmentBinding())
.AddElement("overlay", new OverlayBinding())
.AddElement("executable-in-var", new ExecutableInVar())
.AddElement("executable-in-path", new ExecutableInPath());
Describe <Element>()
.AddPlainList("command", x => x.Commands);
Describe <Implementation>()
.AddList(implementation => implementation.RetrievalMethods)
.AddElement("archive", new Archive(), new ArchiveEditor())
.AddElement("file", new SingleFile(), new SingleFileEditor())
.AddElement("recipe", new Recipe(), new RecipeEditor());
Describe <IElementContainer>()
.AddList(x => x.Elements)
.AddElement("implementation", new Implementation())
.AddElement("package-implementation", new PackageImplementation())
.AddElement("group", new Group());
Describe <Restriction>()
.AddPlainList("version", x => x.Constraints);
Describe <Command>()
.AddProperty("runner", x => PropertyPointer.For(() => x.Runner))
.AddProperty("working-dir", x => PropertyPointer.For(() => x.WorkingDir));
Describe <IArgBaseContainer>()
.AddList(x => x.Arguments)
.AddElement("arg", new Arg())
.AddElement("for-each", new ForEachArgs());
Describe <ForEachArgs>()
.AddPlainList("arg", x => x.Arguments);
Describe <Recipe>()
.AddList(x => x.Steps)
.AddElement("archive", new Archive(), new ArchiveEditor())
.AddElement("file", new SingleFile(), new SingleFileEditor())
.AddElement("rename", new RenameStep())
.AddElement("remove", new RemoveStep())
.AddElement("copy-from", new CopyFromStep());
Describe <CapabilityList>()
.AddList(x => x.Entries)
.AddElement("registration", new AppRegistration())
.AddElement("auto-play", new AutoPlay(), new DescriptionEditor <AutoPlay>())
.AddElement("com-server", new ComServer())
.AddElement("context-menu", new ContextMenu(), new DescriptionEditor <ContextMenu>())
.AddElement("default-program", new DefaultProgram(), new DescriptionEditor <DefaultProgram>())
.AddElement("file-type", new FileType(), new DescriptionEditor <FileType>())
.AddElement("url-protocol", new UrlProtocol(), new DescriptionEditor <UrlProtocol>());
Describe <AutoPlay>()
.AddPlainList("event", x => x.Events)
.AddProperty("verb", x => PropertyPointer.For(() => x.Verb), new DescriptionEditor <Verb>());
Describe <ContextMenu>()
.AddPlainList("extension", x => x.Extensions);
Describe <FileType>()
.AddPlainList("extension", x => x.Extensions);
Describe <UrlProtocol>()
.AddPlainList("known-prefix", x => x.KnownPrefixes);
Describe <VerbCapability>()
.AddPlainList("verb", x => x.Verbs, new DescriptionEditor <Verb>());
Describe <Verb>()
.AddPlainList("arg", x => x.Arguments);
}
/// <summary>
/// Creates a new value-setting command.
/// </summary>
/// <param name="pointer">The object controlling how to read/write the value to be modified.</param>
/// <param name="newValue">The new value to be set.</param>
public SetValueCommand([NotNull] PropertyPointer <T> pointer, T newValue)
{
_newValue = newValue;
_pointer = pointer ?? throw new ArgumentNullException(nameof(pointer));
}
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
if (context != null && context.Instance != null && provider != null)
{
IWindowsFormsEditorService service = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (service != null)
{
IObjectPointer mm = value as IObjectPointer;
if (mm == null)
{
PropertyPointer pp = new PropertyPointer();
IDataScope dv = context.Instance as IDataScope;
if (dv != null)
{
pp.Scope = dv.ScopeDataType;
pp.Owner = dv.ScopeOwner;
}
mm = pp;
}
if (mm != null)
{
IMethod imScope = null;
Type t = service.GetType();
PropertyInfo pif0 = t.GetProperty("OwnerGrid");
if (pif0 != null)
{
object pv = pif0.GetValue(service, null);
MathPropertyGrid pg = pv as MathPropertyGrid;
if (pg != null)
{
imScope = pg.ScopeMethod;
}
}
if (imScope == null)
{
IScopeMethodHolder mh = context.Instance as IScopeMethodHolder;
if (mh != null)
{
imScope = mh.GetScopeMethod();
}
}
DataTypePointer scope = null;
IOwnerScope ios = context.Instance as IOwnerScope;
if (ios != null)
{
scope = ios.OwnerScope;
}
if (scope == null)
{
ParameterValue pv = context.Instance as ParameterValue;
if (pv != null && pv.DataType != null && pv.DataType.BaseClassType != null)
{
if (typeof(Delegate).IsAssignableFrom(pv.DataType.BaseClassType))
{
scope = pv.DataType;
}
}
}
FrmObjectExplorer dlg = DesignUtil.GetPropertySelector(mm, imScope, scope);
if (dlg != null)
{
OnDialogCreated(dlg);
if (service.ShowDialog(dlg) == System.Windows.Forms.DialogResult.OK)
{
bool isValid = true;
string msg = string.Empty;
if (MethodEditContext.IsWebPage)
{
IObjectPointer iop = dlg.SelectedObject as IObjectPointer;
if (iop != null)
{
if (MethodEditContext.UseClientPropertyOnly)
{
if (iop.RunAt == EnumWebRunAt.Server)
{
isValid = false;
msg = "Server value is not allowed";
}
}
else if (MethodEditContext.UseServerPropertyOnly)
{
if (iop.RunAt == EnumWebRunAt.Client)
{
isValid = false;
msg = "Client value is not allowed";
}
}
}
}
if (!isValid)
{
MessageBox.Show(msg, "Select value", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
else
{
value = dlg.SelectedObject;
if (context.PropertyDescriptor.IsReadOnly)
{
//manually set it
PropertyInfo pif = context.Instance.GetType().GetProperty(context.PropertyDescriptor.Name);
pif.SetValue(context.Instance, value, new object[] { });
}
}
}
dlg.ResetSelectLValue();
}
}
}
}
return(value);
}
public override void LoadNextLevel(TreeViewObjectExplorer tv, TreeNodeObject parentNode)
{
UInt32 scopeId = parentNode.ScopeMethodId;
SortedList <string, TreeNode> newNodes = new SortedList <string, TreeNode>();
HtmlElement_BodyBase heb = (HtmlElement_BodyBase)parentNode.OwnerIdentity;
PropertyDescriptorCollection pifs = TypeDescriptor.GetProperties(heb.GetType());
TreeNodeClassRoot topClass = parentNode.TopLevelRootClassNode;
Dictionary <UInt32, IAction> actions = null;
if (topClass != null)
{
if (!topClass.StaticScope)
{
actions = topClass.GetActions();
}
}
else
{
if (tv != null)
{
if (tv.RootClassNode != null)
{
actions = tv.RootClassNode.GetActions();
}
}
if (actions == null)
{
TreeNodeClassType rootType = parentNode.TopLevelNode as TreeNodeClassType;
if (rootType != null)
{
actions = rootType.GetActions();
}
}
}
for (int i = 0; i < pifs.Count; i++)
{
if (NotForProgrammingAttribute.IsNotForProgramming(pifs[i]))
{
continue;
}
if (!WebClientMemberAttribute.IsClientProperty(pifs[i]) && !WebServerMemberAttribute.IsServerProperty(pifs[i]))
{
continue;
}
TreeNodeProperty nodeProperty;
PropertyPointer pp;
pp = new PropertyPointer();
pp.Owner = new HtmlElementPointer(heb);
pp.SetPropertyInfo(pifs[i]);
if (!newNodes.ContainsKey(pp.Name))
{
nodeProperty = new TreeNodeProperty(ForStatic, pp);
try
{
newNodes.Add(pp.Name, nodeProperty);
}
catch (Exception err)
{
MathNode.Log(tv != null ? tv.FindForm() : null, err);
}
//load actions
bool bHasActions = false;
if (string.CompareOrdinal(pp.Name, "Cursor") == 0)
{
bHasActions = false;
}
if (actions != null)
{
foreach (IAction a in actions.Values)
{
if (a != null && a.IsStatic == parentNode.IsStatic)
{
if (nodeProperty.IncludeAction(a, tv, scopeId, false))
{
bHasActions = true;
break;
}
}
}
if (bHasActions)
{
nodeProperty.OnShowActionIcon();
}
}
}
}
parentNode.AddSortedNodes(newNodes);
}
