public override async System.Threading.Tasks.Task GCode_CodeDom_GenerateCode(CodeTypeDeclaration codeClass, CodeStatementCollection codeStatementCollection, LinkPinControl element, GenerateCodeContext_Method context)
{
await EngineNS.Thread.AsyncDummyClass.DummyFunc();
Type clipType = typeof(EngineNS.Bricks.Animation.BlendTree.Node.BlendTree_ZeroPose);
CodeVariableDeclarationStatement stateVarDeclaration = new CodeVariableDeclarationStatement(clipType, ValidName, new CodeObjectCreateExpression(new CodeTypeReference(clipType)));
codeStatementCollection.Add(stateVarDeclaration);
}
public static CodeStatementCollection _(this CodeStatementCollection statements, string expression, params object[] args)
{
statements.Add(new CodeSnippetExpression(string.Format(expression, args)));
return(statements);
}
private static CodeAssignStatement FindControlCreateStatement(Type controlType, CodeStatementCollection statements)
{
foreach (var statement in statements)
{
var codeAssignStatement = statement as CodeAssignStatement;
if (codeAssignStatement != null)
{
var objCreateExpr = codeAssignStatement.Right as CodeObjectCreateExpression;
if (objCreateExpr != null && objCreateExpr.CreateType.BaseType == controlType.ToString() && objCreateExpr.Parameters.Count == 0 &&
codeAssignStatement.Left is CodeVariableReferenceExpression)
{
return(codeAssignStatement);
}
}
}
return(null);
}
public static void Return(this CodeStatementCollection statements, CodeExpression expression)
{
statements.Add(Return(expression));
}
static void GenerateProjectActionsCode(CodeNamespace cns, GenerationOptions options, params ProjectBackend[] projects)
{
bool multiProject = projects.Length > 1;
CodeTypeDeclaration type = new CodeTypeDeclaration("ActionGroups");
type.Attributes = MemberAttributes.Private;
type.TypeAttributes = TypeAttributes.NestedAssembly;
cns.Types.Add(type);
// Generate the global action group getter
CodeMemberMethod met = new CodeMemberMethod();
met.Name = "GetActionGroup";
type.Members.Add(met);
met.Parameters.Add(new CodeParameterDeclarationExpression(typeof(Type), "type"));
if (multiProject)
{
met.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "file"));
}
met.ReturnType = new CodeTypeReference(typeof(Gtk.ActionGroup));
met.Attributes = MemberAttributes.Public | MemberAttributes.Static;
CodeMethodInvokeExpression call = new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(
new CodeTypeReferenceExpression(new CodeTypeReference(cns.Name + ".ActionGroups")),
"GetActionGroup"
),
new CodePropertyReferenceExpression(
new CodeArgumentReferenceExpression("type"),
"FullName"
)
);
if (multiProject)
{
call.Parameters.Add(new CodeArgumentReferenceExpression("file"));
}
met.Statements.Add(new CodeMethodReturnStatement(call));
// Generate the global action group getter (overload)
met = new CodeMemberMethod();
met.Name = "GetActionGroup";
type.Members.Add(met);
met.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "name"));
if (multiProject)
{
met.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "file"));
}
met.ReturnType = new CodeTypeReference(typeof(Gtk.ActionGroup));
met.Attributes = MemberAttributes.Public | MemberAttributes.Static;
CodeArgumentReferenceExpression cfile = new CodeArgumentReferenceExpression("file");
CodeArgumentReferenceExpression cid = new CodeArgumentReferenceExpression("name");
CodeStatementCollection projectCol = met.Statements;
int n = 1;
foreach (ProjectBackend gp in projects)
{
CodeStatementCollection widgetCol;
if (multiProject)
{
CodeConditionStatement pcond = new CodeConditionStatement();
pcond.Condition = new CodeBinaryOperatorExpression(
cfile,
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(gp.Id)
);
projectCol.Add(pcond);
widgetCol = pcond.TrueStatements;
projectCol = pcond.FalseStatements;
}
else
{
widgetCol = projectCol;
}
foreach (Wrapper.ActionGroup grp in gp.ActionGroups)
{
string fname = "group" + (n++);
CodeMemberField grpField = new CodeMemberField(new CodeTypeReference(typeof(Gtk.ActionGroup), CodeTypeReferenceOptions.GlobalReference), fname);
grpField.Attributes |= MemberAttributes.Static;
type.Members.Add(grpField);
CodeFieldReferenceExpression grpVar = new CodeFieldReferenceExpression(
new CodeTypeReferenceExpression(new CodeTypeReference(cns.Name + ".ActionGroups", CodeTypeReferenceOptions.GlobalReference)),
fname
);
CodeConditionStatement pcond = new CodeConditionStatement();
pcond.Condition = new CodeBinaryOperatorExpression(
cid,
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(grp.Name)
);
widgetCol.Add(pcond);
// If the group has not yet been created, create it
CodeConditionStatement pcondGrp = new CodeConditionStatement();
pcondGrp.Condition = new CodeBinaryOperatorExpression(
grpVar,
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(null)
);
pcondGrp.TrueStatements.Add(
new CodeAssignStatement(
grpVar,
new CodeObjectCreateExpression(grp.Name)
)
);
pcond.TrueStatements.Add(pcondGrp);
pcond.TrueStatements.Add(new CodeMethodReturnStatement(grpVar));
widgetCol = pcond.FalseStatements;
}
widgetCol.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(null)));
}
if (met.Statements.Count == 0)
{
met.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(null)));
}
}
public static WidgetMap GenerateCreationCode(CodeNamespace cns, CodeTypeDeclaration type, Wrapper.ActionGroup grp, CodeExpression groupVarExp, CodeStatementCollection statements, GenerationOptions options, ArrayList warnings)
{
statements.Add(new CodeCommentStatement("Action group " + grp.Name));
GeneratorContext ctx = new ProjectGeneratorContext(cns, type, statements, options);
ctx.GenerateCreationCode(grp, groupVarExp);
ctx.EndGeneration();
warnings.AddRange(ctx.Warnings);
return(ctx.WidgetMap);
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
if (manager == null)
{
throw new ArgumentNullException("manager");
}
object result = null;
if (value == null)
{
return(result);
}
CodeStatementCollection statements = null;
ExpressionContext cxt = manager.Context[typeof(ExpressionContext)] as ExpressionContext;
if (value.GetType().GetConstructor(new Type[0]) != null)
{
if (value is ICollection)
{
ExpressionContext varExct = null;
if (cxt != null)
{
if (cxt.PresetValue != value)
{
try
{
statements = new CodeStatementCollection();
CodeVariableReferenceExpression varExpression = AddVariableExpression(manager, statements, value);
varExct = new ExpressionContext(varExpression, value.GetType(), cxt.Owner, value);
manager.Context.Push(varExct);
result = this.originalSerializer.Serialize(manager, value);
if (result is CodeStatementCollection)
{
statements.AddRange(result as CodeStatementCollection);
}
else if (result is CodeStatement)
{
statements.Add(result as CodeStatement);
}
else if (result is CodeExpression)
{
// If the returned result is an expression, it mostly likely means the collection
// can not be serialized using statements, instead it has been serialized as resources.
// In this case, we just over-write the variable init expression with the "GetObject"
// expression for resource objects.
statements.Add(new CodeAssignStatement(varExpression, result as CodeExpression));
}
result = statements;
}
finally
{
if (varExct != null)
{
manager.Context.Pop();
}
}
}
else
{
result = this.originalSerializer.Serialize(manager, value);
}
}
}
else
{
statements = new CodeStatementCollection();
CodeVariableReferenceExpression varExpression = AddVariableExpression(manager, statements, value);
SerializeProperties(manager, statements, value, new Attribute[] { DesignOnlyAttribute.No });
SerializeEvents(manager, statements, value, new Attribute[] { DesignOnlyAttribute.No });
result = statements;
}
}
else if (cxt != null)
{
result = this.originalSerializer.Serialize(manager, value);
}
return(result);
}
protected void GenerateStatements(CodeStatementCollection c)
{
foreach (CodeStatement statement in c)
GenerateStatement(statement);
}
/// <summary>
/// Serializes the given object into a CodeDom object.
/// </summary>
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeStatementCollection statements = null;
PropertyDescriptorCollection props = TypeDescriptor.GetProperties(value);
using (TraceScope("ComponentCodeDomSerializer::Serialize"))
{
ArgumentNullException.ThrowIfNull(manager);
ArgumentNullException.ThrowIfNull(value);
if (IsSerialized(manager, value))
{
Debug.Fail("Serialize is being called twice for the same component");
return(GetExpression(manager, value));
}
// If the object is being inherited, we will will not emit a variable declaration. Also, we won't
// do any serialization at all if the object is privately inherited.
InheritanceLevel inheritanceLevel = InheritanceLevel.NotInherited;
InheritanceAttribute inheritanceAttribute = (InheritanceAttribute)TypeDescriptor.GetAttributes(value)[typeof(InheritanceAttribute)];
if (inheritanceAttribute is not null)
{
inheritanceLevel = inheritanceAttribute.InheritanceLevel;
}
// First, skip everything if we're privately inherited. We cannot write any code that would affect this
// component.
TraceIf(inheritanceLevel == InheritanceLevel.InheritedReadOnly, "Skipping read only inherited component");
if (inheritanceLevel != InheritanceLevel.InheritedReadOnly)
{
// Things we need to know:
//
// 1. What expression should we use for the left hand side
// a) already given to us via GetExpression?
// b) a local variable?
// c) a member variable?
//
// 2. Should we generate an init expression for this
// object?
// a) Inherited or existing expression: no
// b) otherwise, yes.
statements = new CodeStatementCollection();
CodeTypeDeclaration typeDecl = manager.Context[typeof(CodeTypeDeclaration)] as CodeTypeDeclaration;
RootContext rootCtx = manager.Context[typeof(RootContext)] as RootContext;
CodeExpression assignLhs = null;
CodeExpression assignRhs;
// Defaults for components
bool generateLocal = false;
bool generateField = true;
bool generateObject = true;
bool isComplete = false;
assignLhs = GetExpression(manager, value);
if (assignLhs is not null)
{
Trace("Existing expression for LHS of value");
generateLocal = false;
generateField = false;
generateObject = false;
// if we have an existing expression and this is not
// a sited component, do not serialize it. We need this for Everett / 1.0
// backwards compat (even though it's wrong).
if (value is IComponent comp && comp.Site is null)
{
// We were in a serialize content
// property and would still serialize it. This code reverses what the
// outer if block does for this specific case. We also need this
// for Everett / 1.0 backwards compat.
if (!(manager.Context[typeof(ExpressionContext)] is ExpressionContext expCtx) || expCtx.PresetValue != value)
{
isComplete = true;
}
}
}
else
{
Trace("Creating LHS expression");
if (inheritanceLevel == InheritanceLevel.NotInherited)
{
// See if there is a "GenerateMember" property. If so,
// we might want to generate a local variable. Otherwise,
// we want to generate a field.
PropertyDescriptor generateProp = props["GenerateMember"];
if (generateProp is not null && generateProp.PropertyType == typeof(bool) && !(bool)generateProp.GetValue(value))
{
Trace("Object GenerateMember property wants a local variable");
generateLocal = true;
generateField = false;
}
}
else
{
generateObject = false;
}
if (rootCtx is null)
{
generateLocal = true;
generateField = false;
}
}
// Push the component being serialized onto the stack. It may be handy to
// be able to discover this.
manager.Context.Push(value);
manager.Context.Push(statements);
try
{
string name = manager.GetName(value);
string typeName = TypeDescriptor.GetClassName(value);
// Output variable / field declarations if we need to
if ((generateField || generateLocal) && name is not null)
{
if (generateField)
{
if (inheritanceLevel == InheritanceLevel.NotInherited)
{
// We need to generate the field declaration. See if there is a modifiers property on
// the object. If not, look for a DefaultModifies, and finally assume it's private.
CodeMemberField field = new CodeMemberField(typeName, name);
PropertyDescriptor modifiersProp = props["Modifiers"];
MemberAttributes fieldAttrs;
if (modifiersProp is null)
{
modifiersProp = props["DefaultModifiers"];
}
if (modifiersProp is not null && modifiersProp.PropertyType == typeof(MemberAttributes))
{
fieldAttrs = (MemberAttributes)modifiersProp.GetValue(value);
}
else
{
TraceWarning("No Modifiers or DefaultModifiers property on component {0}. We must assume private.", name);
fieldAttrs = MemberAttributes.Private;
}
field.Attributes = fieldAttrs;
typeDecl.Members.Add(field);
Trace("Field {0} {1} {2} created.", fieldAttrs, typeName, name);
}
// Next, create a nice LHS for our pending assign statement, when we hook up the variable.
assignLhs = new CodeFieldReferenceExpression(rootCtx.Expression, name);
}
else
{
if (inheritanceLevel == InheritanceLevel.NotInherited)
{
CodeVariableDeclarationStatement local = new CodeVariableDeclarationStatement(typeName, name);
statements.Add(local);
Trace("Local {0} {1} created.", typeName, name);
}
assignLhs = new CodeVariableReferenceExpression(name);
}
}
// Now output an object create if we need to. We always see if there is a
// type converter that can provide us guidance
if (generateObject)
{
// Ok, now that we've decided if we have a local or a member variable, its now time to serialize the rest of the code.
// The first step is to create an assign statement to "new" the object. For that, we need to know if
// the component wants a special IContainer constructor or not. For that to be valid we must also know
// that we can get to an actual IContainer.
IContainer container = manager.GetService(typeof(IContainer)) as IContainer;
ConstructorInfo ctor = null;
if (container is not null)
{
ctor = GetReflectionTypeHelper(manager, value).GetConstructor(BindingFlags.ExactBinding | BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly, null, GetContainerConstructor(manager), null);
}
if (ctor is not null)
{
Trace("Component has IContainer constructor.");
assignRhs = new CodeObjectCreateExpression(typeName, new CodeExpression[]
{
SerializeToExpression(manager, container)
});
}
else
{
// For compat reasons we ignore the isCompleteOld value here.
assignRhs = SerializeCreationExpression(manager, value, out bool isCompleteOld);
Debug.Assert(isCompleteOld == isComplete, "CCDS Differing");
}
TraceErrorIf(assignRhs is null, "No RHS code assign for object {0}", value);
if (assignRhs is not null)
{
if (assignLhs is null)
{
// We cannot do much more for this object. If isComplete is true,
// then the RHS now becomes our LHS. Otherwise, I'm afraid we have
// just failed to serialize this object.
if (isComplete)
{
assignLhs = assignRhs;
}
else
{
TraceError("Incomplete serialization of object, abandoning serialization.");
}
}
else
{
CodeAssignStatement assign = new CodeAssignStatement(assignLhs, assignRhs);
statements.Add(assign);
}
}
}
if (assignLhs is not null)
{
SetExpression(manager, value, assignLhs);
}
// It should practically be an assert that isComplete is false, but someone may
// have an unusual component.
if (assignLhs is not null && !isComplete)
{
// .NET CF needs us to verify that the ISupportInitialize interface exists
// (they do not support this interface and will modify their DSM to resolve the type to null).
bool supportInitialize = (value is ISupportInitialize);
if (supportInitialize)
{
string fullName = typeof(ISupportInitialize).FullName;
supportInitialize = manager.GetType(fullName) is not null;
}
Type reflectionType = null;
if (supportInitialize)
{
// Now verify that this control implements ISupportInitialize in the project target framework
// Don't use operator "is" but rather use IsAssignableFrom on the reflection types.
// We have other places where we use operator "is", for example "is IComponent" to generate
// specific CodeDOM objects, however we don't have cases of objects which were not an IComponent
// in a downlevel framework and became an IComponent in a newer framework, so I'm not replacing
// all instances of operator "is" by IsAssignableFrom.
reflectionType = GetReflectionTypeHelper(manager, value);
supportInitialize = GetReflectionTypeFromTypeHelper(manager, typeof(ISupportInitialize)).IsAssignableFrom(reflectionType);
}
bool persistSettings = (value is IPersistComponentSettings) && ((IPersistComponentSettings)value).SaveSettings;
if (persistSettings)
{
string fullName = typeof(IPersistComponentSettings).FullName;
persistSettings = manager.GetType(fullName) is not null;
}
if (persistSettings)
{
reflectionType = reflectionType ?? GetReflectionTypeHelper(manager, value);
persistSettings = GetReflectionTypeFromTypeHelper(manager, typeof(IPersistComponentSettings)).IsAssignableFrom(reflectionType);
}
// We implement statement caching only for the main code generation phase. We don't implement it for other
// serialization managers. How do we tell the difference? The main serialization manager exists as a service.
IDesignerSerializationManager mainManager = manager.GetService(typeof(IDesignerSerializationManager)) as IDesignerSerializationManager;
if (supportInitialize)
{
Trace("Object implements ISupportInitialize.");
SerializeSupportInitialize(manager, statements, assignLhs, value, "BeginInit");
}
SerializePropertiesToResources(manager, statements, value, _designTimeFilter);
// Writing out properties is expensive. But, we're very smart and we cache the results
// in ComponentCache. See if we have cached results. If so, use 'em. If not, generate
// code and then see if we can cache the results for later.
ComponentCache cache = manager.GetService(typeof(ComponentCache)) as ComponentCache;
ComponentCache.Entry entry = null;
if (cache is null)
{
if (manager.GetService(typeof(IServiceContainer)) is ServiceContainer sc)
{
cache = new ComponentCache(manager);
sc.AddService(typeof(ComponentCache), cache);
}
}
else
{
if (manager == mainManager && cache.Enabled)
{
entry = cache[value];
}
}
if (entry is null || entry.Tracking)
{
// Pushing the entry here allows it to be found by the resource code dom serializer,
// which will add data to the ResourceBlob property on the entry.
if (entry is null)
{
entry = new ComponentCache.Entry(cache);
// We cache components even if they're not valid so dependencies are
// still tracked correctly (see comment below). The problem is, we will create a
// new entry object even if there is still an existing one that is just invalid, and it
// might have dependencies that will be lost.
// we need to make sure we copy over any dependencies that are also tracked.
ComponentCache.Entry oldEntry = cache?.GetEntryAll(value);
if (oldEntry is not null && oldEntry.Dependencies is not null && oldEntry.Dependencies.Count > 0)
{
foreach (object dependency in oldEntry.Dependencies)
{
entry.AddDependency(dependency);
}
}
}
entry.Component = value;
// we need to link the cached entry with its corresponding component right away, before it's put in the context
// see CodeDomSerializerBase.cs::GetExpression for usage
// This entry will only be used if the valid bit is set.
// This is useful because we still need to setup dependency relationships
// between components even if they are not cached. See VSWhidbey 263053.
bool correctManager = manager == mainManager;
entry.Valid = correctManager && CanCacheComponent(manager, value, props);
if (correctManager && cache is not null && cache.Enabled)
{
manager.Context.Push(cache);
manager.Context.Push(entry);
}
try
{
entry.Statements = new CodeStatementCollection();
SerializeProperties(manager, entry.Statements, value, _runTimeFilter);
SerializeEvents(manager, entry.Statements, value, null);
foreach (CodeStatement statement in entry.Statements)
{
if (statement is CodeVariableDeclarationStatement local)
{
entry.Tracking = true;
break;
}
}
if (entry.Statements.Count > 0)
{
// if we added some statements, insert the comments
//
entry.Statements.Insert(0, new CodeCommentStatement(string.Empty));
entry.Statements.Insert(0, new CodeCommentStatement(name));
entry.Statements.Insert(0, new CodeCommentStatement(string.Empty));
//
// cache the statements for future usage if possible. We only do this for the main serialization manager, not
// for any other serialization managers that may be calling us for undo or clipboard functions.
if (correctManager && cache is not null && cache.Enabled)
{
cache[value] = entry;
}
}
}
finally
{
if (correctManager && cache is not null && cache.Enabled)
{
Debug.Assert(manager.Context.Current == entry, "Context stack corrupted");
manager.Context.Pop();
manager.Context.Pop();
}
}
}
else
{
// If we got a cache entry, we will need to take all the resources out of
// it and apply them too.
if ((entry.Resources is not null || entry.Metadata is not null) && cache is not null && cache.Enabled)
{
ResourceCodeDomSerializer res = ResourceCodeDomSerializer.Default;
res.ApplyCacheEntry(manager, entry);
}
}
// Regardless, apply statements. Either we created them or we got them
// out of the cache.
statements.AddRange(entry.Statements);
if (persistSettings)
{
SerializeLoadComponentSettings(manager, statements, assignLhs, value);
}
if (supportInitialize)
{
SerializeSupportInitialize(manager, statements, assignLhs, value, "EndInit");
}
}
}
private CodeVariableReferenceExpression AddVariableExpression(IDesignerSerializationManager manager, CodeStatementCollection statements, object value)
{
string varName = GetUniqueName(manager, value).Replace('`', '_');
CodeVariableDeclarationStatement varDecl = new CodeVariableDeclarationStatement(TypeDescriptor.GetClassName(value), varName);
varDecl.InitExpression = new CodeObjectCreateExpression(TypeDescriptor.GetClassName(value), new CodeExpression[0]);
statements.Add(varDecl);
CodeVariableReferenceExpression varExpression = new CodeVariableReferenceExpression(varName);
SetExpression(manager, value, varExpression);
return(varExpression);
}
bool SerializeProjectResource(IDesignerSerializationManager manager, object value, MemberDescriptor descriptor, CodeStatementCollection statements)
{
var propDesc = descriptor as PropertyDescriptor;
if (propDesc == null) return false;
var component = value as IComponent;
if (component == null || component.Site == null) return false;
if (!propDesc.ShouldSerializeValue(component)) {
return false;
}
var dictService = component.Site.GetService(typeof(IDictionaryService)) as IDictionaryService;
if (dictService == null) return false;
var resourceInfo = dictService.GetValue(ProjectResourceService.ProjectResourceKey + propDesc.Name) as ProjectResourceInfo;
if (resourceInfo == null) return false;
if (!Object.ReferenceEquals(resourceInfo.OriginalValue, propDesc.GetValue(value))) {
LoggingService.Info("Value of property '" + propDesc.Name + "' on component '" + value.ToString() + "' is not equal to stored project resource value. Ignoring this resource.");
return false;
}
// Find the generated file with the resource accessing class.
var prs = manager.GetService(typeof(ProjectResourceService)) as ProjectResourceService;
if (prs == null) {
LoggingService.Warn("ProjectResourceService not found");
return false;
}
IProject project = prs.ProjectContent;
if (project == null) {
LoggingService.Warn("Serializer cannot proceed because project is not an IProject");
return false;
}
string resourceFileDirectory = Path.GetDirectoryName(resourceInfo.ResourceFile);
string resourceFileName = Path.GetFileName(resourceInfo.ResourceFile);
var items = project.Items
.OfType<FileProjectItem>()
.Where(
fpi =>
FileUtility.IsEqualFileName(Path.GetDirectoryName(fpi.FileName), resourceFileDirectory) &&
FileUtility.IsEqualFileName(fpi.DependentUpon, resourceFileName) &&
fpi.ItemType == ItemType.Compile &&
fpi.VirtualName.ToUpperInvariant().Contains("DESIGNER")
).ToList();
if (items.Count != 1) {
LoggingService.Info("Did not find exactly one possible file that contains the generated class for the resource file '" + resourceInfo.ResourceFile + "'. Ignoring this resource.");
return false;
}
FileName resourceCodeFile = items.Single().FileName;
// We expect a single class to be in this file.
var resourceClass = SD.ParserService.GetExistingUnresolvedFile(resourceCodeFile).TopLevelTypeDefinitions.Single();
// Here we assume that VerifyResourceName is the same name transform that
// was used when generating the resource code file.
// This should be true as long as the code is generated using the
// custom tool in SharpDevelop or Visual Studio.
string resourcePropertyName = StronglyTypedResourceBuilder.VerifyResourceName(resourceInfo.ResourceKey, prs.ProjectContent.CreateCodeDomProvider() ?? new CSharpCodeProvider());
if (resourcePropertyName == null) {
throw new InvalidOperationException("The resource name '" + resourceInfo.ResourceKey + "' could not be transformed to a name that is valid in the current programming language.");
}
// Now do the actual serialization.
LoggingService.Debug("Serializing project resource: Component '" + component.ToString() + "', Property: '" + propDesc.Name + "', Resource class: '" + resourceClass.FullName + "', Resource property: '" + resourcePropertyName + "'");
var targetObjectExpr = base.SerializeToExpression(manager, value);
if (targetObjectExpr == null) {
LoggingService.Info("Target object could not be serialized: " + value.ToString());
return false;
}
if (propDesc.SerializationVisibility == DesignerSerializationVisibility.Content) {
LoggingService.Debug("-> is a content property, ignoring this.");
return false;
}
var propRefSource =
Easy.Type(
new CodeTypeReference(resourceClass.FullName, CodeTypeReferenceOptions.GlobalReference)
).Property(resourcePropertyName);
var extAttr = propDesc.Attributes[typeof(ExtenderProvidedPropertyAttribute)] as ExtenderProvidedPropertyAttribute;
if (extAttr != null && extAttr.Provider != null) {
// This is an extender property.
var extProvider = base.SerializeToExpression(manager, extAttr.Provider);
if (extProvider == null) {
throw new InvalidOperationException("Could not serialize the extender provider '" + extAttr.Provider.ToString() + "'.");
}
statements.Add(
extProvider.InvokeMethod(
"Set" + propDesc.Name,
targetObjectExpr,
propRefSource
)
);
} else {
// This is a standard property.
statements.Add(
new CodeAssignStatement(
new CodePropertyReferenceExpression(targetObjectExpr, propDesc.Name),
propRefSource)
);
}
return true;
}
public override void Serialize(IDesignerSerializationManager manager, object value, MemberDescriptor descriptor, CodeStatementCollection statements)
{
if (!this.SerializeProjectResource(manager, value, descriptor, statements)) {
this.baseSerializer.Serialize(manager, value, descriptor, statements);
}
}
public CodeExpression GenerateLoadPixbuf(string name, Gtk.IconSize size)
{
bool found = false;
foreach (CodeTypeDeclaration t in cns.Types)
{
if (t.Name == "IconLoader")
{
found = true;
break;
}
}
if (!found)
{
CodeTypeDeclaration cls = new CodeTypeDeclaration("IconLoader");
cls.Attributes = MemberAttributes.Private;
cls.TypeAttributes = System.Reflection.TypeAttributes.NestedAssembly;
cns.Types.Add(cls);
CodeMemberMethod met = new CodeMemberMethod();
cls.Members.Add(met);
met.Attributes = MemberAttributes.Public | MemberAttributes.Static;
met.Name = "LoadIcon";
met.Parameters.Add(new CodeParameterDeclarationExpression(typeof(Gtk.Widget), "widget"));
met.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "name"));
met.Parameters.Add(new CodeParameterDeclarationExpression(typeof(Gtk.IconSize), "size"));
met.ReturnType = new CodeTypeReference(typeof(Gdk.Pixbuf));
CodeExpression widgetExp = new CodeVariableReferenceExpression("widget");
CodeExpression nameExp = new CodeVariableReferenceExpression("name");
CodeExpression sizeExp = new CodeVariableReferenceExpression("size");
CodeExpression szExp = new CodeVariableReferenceExpression("sz");
CodeExpression mgExp = new CodeBinaryOperatorExpression(szExp, CodeBinaryOperatorType.Divide, new CodePrimitiveExpression(4));
CodeExpression pmapExp = new CodeVariableReferenceExpression("pmap");
CodeExpression gcExp = new CodeVariableReferenceExpression("gc");
CodeExpression szM1Exp = new CodeBinaryOperatorExpression(szExp, CodeBinaryOperatorType.Subtract, new CodePrimitiveExpression(1));
CodeExpression zeroExp = new CodePrimitiveExpression(0);
CodeExpression resExp = new CodeVariableReferenceExpression("res");
met.Statements.Add(
new CodeVariableDeclarationStatement(typeof(Gdk.Pixbuf), "res",
new CodeMethodInvokeExpression(
widgetExp,
"RenderIcon",
nameExp,
sizeExp,
new CodePrimitiveExpression(null)
)
)
);
CodeConditionStatement nullcheck = new CodeConditionStatement();
met.Statements.Add(nullcheck);
nullcheck.Condition = new CodeBinaryOperatorExpression(
resExp,
CodeBinaryOperatorType.IdentityInequality,
new CodePrimitiveExpression(null)
);
nullcheck.TrueStatements.Add(new CodeMethodReturnStatement(resExp));
// int sz, h;
// Gtk.Icon.SizeLookup (size, out sz, out h);
nullcheck.FalseStatements.Add(new CodeVariableDeclarationStatement(typeof(int), "sz"));
nullcheck.FalseStatements.Add(new CodeVariableDeclarationStatement(typeof(int), "sy"));
nullcheck.FalseStatements.Add(new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(Gtk.Icon).ToGlobalTypeRef()),
"SizeLookup",
sizeExp,
new CodeDirectionExpression(FieldDirection.Out, szExp),
new CodeDirectionExpression(FieldDirection.Out, new CodeVariableReferenceExpression("sy"))
));
CodeTryCatchFinallyStatement trycatch = new CodeTryCatchFinallyStatement();
nullcheck.FalseStatements.Add(trycatch);
trycatch.TryStatements.Add(
new CodeMethodReturnStatement(
new CodeMethodInvokeExpression(
new CodePropertyReferenceExpression(
new CodeTypeReferenceExpression(new CodeTypeReference(typeof(Gtk.IconTheme))),
"Default"
),
"LoadIcon",
nameExp,
szExp,
zeroExp
)
)
);
CodeCatchClause ccatch = new CodeCatchClause();
trycatch.CatchClauses.Add(ccatch);
CodeConditionStatement cond = new CodeConditionStatement();
ccatch.Statements.Add(cond);
cond.Condition = new CodeBinaryOperatorExpression(
nameExp,
CodeBinaryOperatorType.IdentityInequality,
new CodePrimitiveExpression("gtk-missing-image")
);
cond.TrueStatements.Add(
new CodeMethodReturnStatement(
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(cns.Name + "." + cls.Name),
"LoadIcon",
widgetExp,
new CodePrimitiveExpression("gtk-missing-image"),
sizeExp
)
)
);
CodeStatementCollection stms = cond.FalseStatements;
stms.Add(
new CodeVariableDeclarationStatement(typeof(Gdk.Pixmap), "pmap",
new CodeObjectCreateExpression(
typeof(Gdk.Pixmap),
new CodePropertyReferenceExpression(
new CodePropertyReferenceExpression(
new CodeTypeReferenceExpression(typeof(Gdk.Screen)),
"Default"
),
"RootWindow"
),
szExp,
szExp
)
)
);
stms.Add(
new CodeVariableDeclarationStatement(typeof(Gdk.GC), "gc",
new CodeObjectCreateExpression(typeof(Gdk.GC), pmapExp)
)
);
stms.Add(
new CodeAssignStatement(
new CodePropertyReferenceExpression(
gcExp,
"RgbFgColor"
),
new CodeObjectCreateExpression(
typeof(Gdk.Color),
new CodePrimitiveExpression(255),
new CodePrimitiveExpression(255),
new CodePrimitiveExpression(255)
)
)
);
stms.Add(
new CodeMethodInvokeExpression(
pmapExp,
"DrawRectangle",
gcExp,
new CodePrimitiveExpression(true),
zeroExp,
zeroExp,
szExp,
szExp
)
);
stms.Add(
new CodeAssignStatement(
new CodePropertyReferenceExpression(
gcExp,
"RgbFgColor"
),
new CodeObjectCreateExpression(
typeof(Gdk.Color),
zeroExp, zeroExp, zeroExp
)
)
);
stms.Add(
new CodeMethodInvokeExpression(
pmapExp,
"DrawRectangle",
gcExp,
new CodePrimitiveExpression(false),
zeroExp,
zeroExp,
szM1Exp,
szM1Exp
)
);
stms.Add(
new CodeMethodInvokeExpression(
gcExp,
"SetLineAttributes",
new CodePrimitiveExpression(3),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(Gdk.LineStyle)), "Solid"),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(Gdk.CapStyle)), "Round"),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(Gdk.JoinStyle)), "Round")
)
);
stms.Add(
new CodeAssignStatement(
new CodePropertyReferenceExpression(
gcExp,
"RgbFgColor"
),
new CodeObjectCreateExpression(
typeof(Gdk.Color),
new CodePrimitiveExpression(255),
zeroExp,
zeroExp
)
)
);
stms.Add(
new CodeMethodInvokeExpression(
pmapExp,
"DrawLine",
gcExp,
mgExp,
mgExp,
new CodeBinaryOperatorExpression(szM1Exp, CodeBinaryOperatorType.Subtract, mgExp),
new CodeBinaryOperatorExpression(szM1Exp, CodeBinaryOperatorType.Subtract, mgExp)
)
);
stms.Add(
new CodeMethodInvokeExpression(
pmapExp,
"DrawLine",
gcExp,
new CodeBinaryOperatorExpression(szM1Exp, CodeBinaryOperatorType.Subtract, mgExp),
mgExp,
mgExp,
new CodeBinaryOperatorExpression(szM1Exp, CodeBinaryOperatorType.Subtract, mgExp)
)
);
stms.Add(
new CodeMethodReturnStatement(
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(Gdk.Pixbuf)),
"FromDrawable",
pmapExp,
new CodePropertyReferenceExpression(pmapExp, "Colormap"),
zeroExp, zeroExp, zeroExp, zeroExp, szExp, szExp
)
)
);
}
int sz, h;
Gtk.Icon.SizeLookup(size, out sz, out h);
return(new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(new CodeTypeReference(cns.Name + ".IconLoader", CodeTypeReferenceOptions.GlobalReference)),
"LoadIcon",
rootObject,
new CodePrimitiveExpression(name),
new CodeFieldReferenceExpression(
new CodeTypeReferenceExpression(new CodeTypeReference(typeof(Gtk.IconSize), CodeTypeReferenceOptions.GlobalReference)),
size.ToString()
)
));
}
public CodeStatementCollection(CodeStatementCollection value) {}
/// <summary>
/// Serializes the given object into a CodeDom object.
/// </summary>
public override object Serialize(IDesignerSerializationManager manager, object value)
{
if (manager is null || value is null)
{
throw new ArgumentNullException(manager is null ? "manager" : "value");
}
// Find our base class's serializer.
CodeDomSerializer serializer = (CodeDomSerializer)manager.GetSerializer(typeof(Component), typeof(CodeDomSerializer));
if (serializer is null)
{
Debug.Fail("Unable to find a CodeDom serializer for 'Component'. Has someone tampered with the serialization providers?");
return(null);
}
// Now ask it to serializer
object retVal = serializer.Serialize(manager, value);
InheritanceAttribute inheritanceAttribute = (InheritanceAttribute)TypeDescriptor.GetAttributes(value)[typeof(InheritanceAttribute)];
InheritanceLevel inheritanceLevel = InheritanceLevel.NotInherited;
if (inheritanceAttribute != null)
{
inheritanceLevel = inheritanceAttribute.InheritanceLevel;
}
if (inheritanceLevel != InheritanceLevel.InheritedReadOnly)
{
// Next, see if we are in localization mode. If we are, and if we can get
// to a ResourceManager through the service provider, then emit the hierarchy information for
// this object. There is a small fragile assumption here: The resource manager is demand
// created, so if all of the properties of this control had default values it is possible
// there will be no resource manager for us. I'm letting that slip a bit, however, because
// for Control classes, we always emit at least the location / size information for the
// control.
IDesignerHost host = (IDesignerHost)manager.GetService(typeof(IDesignerHost));
if (host != null)
{
PropertyDescriptor prop = TypeDescriptor.GetProperties(host.RootComponent)["Localizable"];
if (prop != null && prop.PropertyType == typeof(bool) && ((bool)prop.GetValue(host.RootComponent)))
{
SerializeControlHierarchy(manager, host, value);
}
}
CodeStatementCollection csCollection = retVal as CodeStatementCollection;
if (csCollection != null)
{
Control control = (Control)value;
// Serialize a suspend / resume pair. We always serialize this
// for the root component
if ((host != null && control == host.RootComponent) || HasSitedNonReadonlyChildren(control))
{
SerializeSuspendLayout(manager, csCollection, value);
SerializeResumeLayout(manager, csCollection, value);
ControlDesigner controlDesigner = host.GetDesigner(control) as ControlDesigner;
if (HasAutoSizedChildren(control) || (controlDesigner != null && controlDesigner.SerializePerformLayout))
{
SerializePerformLayout(manager, csCollection, value);
}
}
// And now serialize the correct z-order relationships for the controls. We only need to
// do this if there are controls in the collection that are inherited.
if (HasMixedInheritedChildren(control))
{
SerializeZOrder(manager, csCollection, control);
}
}
}
return(retVal);
}
private void GenerateStatements(CodeStatementCollection stms)
{
IEnumerator en = stms.GetEnumerator();
while (en.MoveNext())
{
((ICodeGenerator)this).GenerateCodeFromStatement((CodeStatement)en.Current, output.InnerWriter, options);
}
}
/// <summary>
/// Serializes a method invocation on the control being serialized. Used to serialize Suspend/ResumeLayout pairs, etc.
/// </summary>
private void SerializeMethodInvocation(IDesignerSerializationManager manager, CodeStatementCollection statements, object control, string methodName, CodeExpressionCollection parameters, Type[] paramTypes, StatementOrdering ordering)
{
using (TraceScope("ControlCodeDomSerializer::SerializeMethodInvocation(" + methodName + ")"))
{
string name = manager.GetName(control);
Trace(name + "." + methodName);
// Use IReflect to see if this method name exists on the control.
paramTypes = ToTargetTypes(control, paramTypes);
MethodInfo mi = TypeDescriptor.GetReflectionType(control).GetMethod(methodName, BindingFlags.Public | BindingFlags.Instance, null, paramTypes, null);
if (mi != null)
{
CodeExpression field = SerializeToExpression(manager, control);
CodeMethodReferenceExpression method = new CodeMethodReferenceExpression(field, methodName);
CodeMethodInvokeExpression methodInvoke = new CodeMethodInvokeExpression();
methodInvoke.Method = method;
if (parameters != null)
{
methodInvoke.Parameters.AddRange(parameters);
}
CodeExpressionStatement statement = new CodeExpressionStatement(methodInvoke);
switch (ordering)
{
case StatementOrdering.Prepend:
statement.UserData["statement-ordering"] = "begin";
break;
case StatementOrdering.Append:
statement.UserData["statement-ordering"] = "end";
break;
default:
Debug.Fail("Unsupported statement ordering: " + ordering);
break;
}
statements.Add(statement);
}
}
}
public override void OnExportClientServerCode(ActionBranch previousAction, ActionBranch nextAction, ILimnorCodeCompiler compiler, CodeMemberMethod method, CodeStatementCollection statements,
StringCollection jsCode, StringCollection methodCode, JsMethodCompiler data)
{
if (_actionList != null)
{
int last = _actionList.Count - 1;
for (int k = 0; k < _actionList.Count; k++)
{
if (_actionList[k].Action != null)
{
ActionBranch nt = null;
if (k == last)
{
nt = nextAction;
if (nt != null && nt.UseInput)
{
nt.InputName = this.OutputCodeName;
nt.InputType = this.OutputType;
nt.SetInputName(OutputCodeName, OutputType);
}
}
_actionList[k].Action.ExportJavaScriptCode(this, nt, jsCode, methodCode, data);
}
}
}
}
private void SerializeSuspendLayout(IDesignerSerializationManager manager, CodeStatementCollection statements, object control)
{
SerializeMethodInvocation(manager, statements, control, "SuspendLayout", null, Array.Empty <Type>(), StatementOrdering.Prepend);
}
public static WidgetMap GenerateCreationCode(CodeNamespace cns, CodeTypeDeclaration type, Gtk.Widget w, CodeExpression widgetVarExp, CodeStatementCollection statements, GenerationOptions options, ArrayList warnings)
{
statements.Add(new CodeCommentStatement("Widget " + w.Name));
GeneratorContext ctx = new ProjectGeneratorContext(cns, type, statements, options);
Stetic.Wrapper.Widget ww = Stetic.Wrapper.Widget.Lookup(w);
ctx.GenerateCreationCode(ww, widgetVarExp);
ctx.EndGeneration();
warnings.AddRange(ctx.Warnings);
return(ctx.WidgetMap);
}
/// <summary>
/// This method actually performs the serialization. When the member is serialized
/// the necessary statements will be added to the statements collection.
/// </summary>
public override void Serialize(IDesignerSerializationManager manager, object value, MemberDescriptor descriptor, CodeStatementCollection statements)
{
if (manager is null)
{
throw new ArgumentNullException(nameof(manager));
}
if (value is null)
{
throw new ArgumentNullException(nameof(value));
}
if (!(descriptor is PropertyDescriptor propertyToSerialize))
{
throw new ArgumentNullException(nameof(descriptor));
}
if (statements is null)
{
throw new ArgumentNullException(nameof(statements));
}
try
{
ExtenderProvidedPropertyAttribute exAttr = (ExtenderProvidedPropertyAttribute)propertyToSerialize.Attributes[typeof(ExtenderProvidedPropertyAttribute)];
bool isExtender = (exAttr != null && exAttr.Provider != null);
bool serializeContents = propertyToSerialize.Attributes.Contains(DesignerSerializationVisibilityAttribute.Content);
CodeDomSerializer.Trace("Serializing property {0}", propertyToSerialize.Name);
if (serializeContents)
{
SerializeContentProperty(manager, value, propertyToSerialize, isExtender, statements);
}
else if (isExtender)
{
SerializeExtenderProperty(manager, value, propertyToSerialize, statements);
}
else
{
SerializeNormalProperty(manager, value, propertyToSerialize, statements);
}
}
catch (Exception e)
{
// Since we usually go through reflection, don't
// show what our engine does, show what caused
// the problem.
if (e is TargetInvocationException)
{
e = e.InnerException;
}
manager.ReportError(new CodeDomSerializerException(string.Format(SR.SerializerPropertyGenFailed, propertyToSerialize.Name, e.Message), manager));
}
}
public ProjectGeneratorContext(CodeNamespace cns, CodeTypeDeclaration type, CodeStatementCollection statements, GenerationOptions options) : base(cns, "w", statements, options)
{
this.type = type;
}
/// <summary>
/// This serializes the given property on this object as a content property.
/// </summary>
private void SerializeContentProperty(IDesignerSerializationManager manager, object value, PropertyDescriptor property, bool isExtender, CodeStatementCollection statements)
{
CodeDomSerializer.Trace("Property is marked as Visibility.Content. Recursing.");
object propertyValue = GetPropertyValue(manager, property, value, out bool validValue);
// For persist contents objects, we don't just serialize the properties on the object; we
// serialize everything.
//
CodeDomSerializer serializer = null;
if (propertyValue is null)
{
CodeDomSerializer.TraceError("Property {0} is marked as Visibility.Content but it is returning null.", property.Name);
string name = manager.GetName(value);
if (name is null)
{
name = value.GetType().FullName;
}
manager.ReportError(new CodeDomSerializerException(string.Format(SR.SerializerNullNestedProperty, name, property.Name), manager));
}
else
{
serializer = (CodeDomSerializer)manager.GetSerializer(propertyValue.GetType(), typeof(CodeDomSerializer));
if (serializer != null)
{
// Create a property reference expression and push it on the context stack.
// This allows the serializer to gain some context as to what it should be
// serializing.
CodeExpression target = SerializeToExpression(manager, value);
if (target is null)
{
CodeDomSerializer.TraceWarning("Unable to convert value to expression object");
}
else
{
CodeExpression propertyRef = null;
if (isExtender)
{
CodeDomSerializer.Trace("Content property is an extender.");
ExtenderProvidedPropertyAttribute exAttr = (ExtenderProvidedPropertyAttribute)property.Attributes[typeof(ExtenderProvidedPropertyAttribute)];
// Extender properties are method invokes on a target "extender" object.
//
CodeExpression extender = SerializeToExpression(manager, exAttr.Provider);
CodeExpression extended = SerializeToExpression(manager, value);
CodeDomSerializer.TraceWarningIf(extender is null, "Extender object {0} could not be serialized.", manager.GetName(exAttr.Provider));
CodeDomSerializer.TraceWarningIf(extended is null, "Extended object {0} could not be serialized.", manager.GetName(value));
if (extender != null && extended != null)
{
CodeMethodReferenceExpression methodRef = new CodeMethodReferenceExpression(extender, "Get" + property.Name);
CodeMethodInvokeExpression methodInvoke = new CodeMethodInvokeExpression
{
Method = methodRef
};
methodInvoke.Parameters.Add(extended);
propertyRef = methodInvoke;
}
}
else
{
propertyRef = new CodePropertyReferenceExpression(target, property.Name);
}
if (propertyRef != null)
{
ExpressionContext tree = new ExpressionContext(propertyRef, property.PropertyType, value, propertyValue);
manager.Context.Push(tree);
object result = null;
try
{
SerializeAbsoluteContext absolute = (SerializeAbsoluteContext)manager.Context[typeof(SerializeAbsoluteContext)];
if (IsSerialized(manager, propertyValue, absolute != null))
{
result = GetExpression(manager, propertyValue);
}
else
{
result = serializer.Serialize(manager, propertyValue);
}
}
finally
{
Debug.Assert(manager.Context.Current == tree, "Serializer added a context it didn't remove.");
manager.Context.Pop();
}
if (result is CodeStatementCollection csc)
{
foreach (CodeStatement statement in csc)
{
statements.Add(statement);
}
}
else
{
if (result is CodeStatement cs)
{
statements.Add(cs);
}
}
}
}
}
else
{
CodeDomSerializer.TraceError("Property {0} is marked as Visibilty.Content but there is no serializer for it.", property.Name);
manager.ReportError(new CodeDomSerializerException(string.Format(SR.SerializerNoSerializerForComponent, property.PropertyType.FullName), manager));
}
}
}
private static void ReplaceControlCreateStatement(Type ctrlType, CodeAssignStatement objAssignStatement, CodeStatementCollection statements)
{
/* Generate code like below
*
* IServiceProvider __activator = HttpRuntime.WebObjectActivator;
*
* if (activator != null) {
* _ctrl = (ctrlType)activator.GetService(ctrlType);
* }
*
* // if default c-tor exists
* else {
* _ctrl = new ....
* }
* // if no default c-tor
* else {
* _ctrl = null
* }
*
*/
var webObjectActivatorExpr = new CodePropertyReferenceExpression(new CodeTypeReferenceExpression("System.Web.HttpRuntime"), "WebObjectActivator");
var activatorRefExpr = new CodeVariableReferenceExpression("__activator");
var getServiceExpr = new CodeMethodInvokeExpression(webObjectActivatorExpr, "GetService", new CodeTypeOfExpression(ctrlType));
var castExpr = new CodeCastExpression(new CodeTypeReference(ctrlType), getServiceExpr);
var createObjectStatement = new CodeConditionStatement()
{
Condition = new CodeBinaryOperatorExpression(activatorRefExpr,
CodeBinaryOperatorType.IdentityInequality,
new CodePrimitiveExpression(null))
};
createObjectStatement.TrueStatements.Add(new CodeAssignStatement(objAssignStatement.Left, castExpr));
// If default c-tor exists
if (ctrlType.GetConstructor(Type.EmptyTypes) != null)
{
createObjectStatement.FalseStatements.Add(objAssignStatement);
}
else
{
createObjectStatement.FalseStatements.Add(new CodeAssignStatement(objAssignStatement.Left, new CodePrimitiveExpression(null)));
}
// replace the old assign statement
var indexOfStatement = statements.IndexOf(objAssignStatement);
statements.Insert(indexOfStatement, createObjectStatement);
statements.Insert(indexOfStatement, new CodeAssignStatement(activatorRefExpr, webObjectActivatorExpr));
statements.Insert(indexOfStatement, new CodeVariableDeclarationStatement(typeof(IServiceProvider), "__activator"));
statements.Remove(objAssignStatement);
}
/// <summary>
/// This serializes the given property on this object.
/// </summary>
private void SerializeExtenderProperty(IDesignerSerializationManager manager, object value, PropertyDescriptor property, CodeStatementCollection statements)
{
AttributeCollection attributes = property.Attributes;
using (CodeDomSerializer.TraceScope("PropertyMemberCodeDomSerializer::" + nameof(SerializeExtenderProperty)))
{
ExtenderProvidedPropertyAttribute exAttr = (ExtenderProvidedPropertyAttribute)attributes[typeof(ExtenderProvidedPropertyAttribute)];
// Extender properties are method invokes on a target "extender" object.
//
CodeExpression extender = SerializeToExpression(manager, exAttr.Provider);
CodeExpression extended = SerializeToExpression(manager, value);
CodeDomSerializer.TraceWarningIf(extender is null, "Extender object {0} could not be serialized.", manager.GetName(exAttr.Provider));
CodeDomSerializer.TraceWarningIf(extended is null, "Extended object {0} could not be serialized.", manager.GetName(value));
if (extender != null && extended != null)
{
CodeMethodReferenceExpression methodRef = new CodeMethodReferenceExpression(extender, "Set" + property.Name);
object propValue = GetPropertyValue(manager, property, value, out bool validValue);
CodeExpression serializedPropertyValue = null;
// Serialize the value of this property into a code expression. If we can't get one,
// then we won't serialize the property.
if (validValue)
{
ExpressionContext tree = null;
if (propValue != value)
{
// make sure the value isn't the object or we'll end up printing
// this property instead of the value.
tree = new ExpressionContext(methodRef, property.PropertyType, value);
manager.Context.Push(tree);
}
try
{
serializedPropertyValue = SerializeToExpression(manager, propValue);
}
finally
{
if (tree != null)
{
Debug.Assert(manager.Context.Current == tree, "Context stack corrupted.");
manager.Context.Pop();
}
}
}
if (serializedPropertyValue != null)
{
CodeMethodInvokeExpression methodInvoke = new CodeMethodInvokeExpression
{
Method = methodRef
};
methodInvoke.Parameters.Add(extended);
methodInvoke.Parameters.Add(serializedPropertyValue);
statements.Add(methodInvoke);
}
}
}
}
public static void Throw <T> (this CodeStatementCollection statements, params CodeExpression [] parameters) where T : Exception
{
statements.Add(Throw <T> (parameters));
}
/// <summary>
/// This serializes the given property on this object.
/// </summary>
private void SerializeNormalProperty(IDesignerSerializationManager manager, object value, PropertyDescriptor property, CodeStatementCollection statements)
{
using (CodeDomSerializer.TraceScope("CodeDomSerializer::" + nameof(SerializeProperty)))
{
CodeExpression target = SerializeToExpression(manager, value);
CodeDomSerializer.TraceWarningIf(target is null, "Unable to serialize target for property {0}", property.Name);
if (target != null)
{
CodeExpression propertyRef = new CodePropertyReferenceExpression(target, property.Name);
CodeExpression serializedPropertyValue = null;
// First check for a member relationship service to see if this property
// is related to another member. If it is, then we will use that
// relationship to construct the property assign statement. if
// it isn't, then we're serialize ourselves.
if (manager.GetService(typeof(MemberRelationshipService)) is MemberRelationshipService relationships)
{
MemberRelationship relationship = relationships[value, property];
if (relationship != MemberRelationship.Empty)
{
CodeExpression rhsTarget = SerializeToExpression(manager, relationship.Owner);
if (rhsTarget != null)
{
serializedPropertyValue = new CodePropertyReferenceExpression(rhsTarget, relationship.Member.Name);
}
}
}
if (serializedPropertyValue is null)
{
// Serialize the value of this property into a code expression. If we can't get one,
// then we won't serialize the property.
//
object propValue = GetPropertyValue(manager, property, value, out bool validValue);
if (validValue)
{
ExpressionContext tree = null;
if (propValue != value)
{
// make sure the value isn't the object or we'll end up printing
// this property instead of the value.
tree = new ExpressionContext(propertyRef, property.PropertyType, value);
manager.Context.Push(tree);
}
try
{
serializedPropertyValue = SerializeToExpression(manager, propValue);
}
finally
{
if (tree != null)
{
Debug.Assert(manager.Context.Current == tree, "Context stack corrupted.");
manager.Context.Pop();
}
}
}
}
if (serializedPropertyValue != null)
{
CodeAssignStatement assign = new CodeAssignStatement(propertyRef, serializedPropertyValue);
statements.Add(assign);
}
}
}
}
public TableEntry(object owner, CodeStatementCollection statements)
{
Owner = owner;
Statements = statements;
}
public CodeBlock(CodeLine line, string method, CodeStatementCollection statements, BlockKind kind, CodeBlock parent)
: this(line, method, statements, kind, parent, null, null)
{
}
public void AddRange(CodeStatementCollection value) {}
protected void GenerateBlock(CodeStatementCollection statements)
{
OutputStartingBrace();
GenerateStatements(statements);
OutputEndingBrace();
}
private void ValidateStatements(CodeStatementCollection stmts)
{
foreach (CodeStatement stmt in stmts)
{
ValidateStatement(stmt);
}
}
private static CodeElement WalkStatements(TextPoint Point, vsCMElement Scope, CodeStatementCollection statements)
{
foreach (CodeStatement cs in statements)
{
if (Scope == vsCMElement.vsCMElementAssignmentStmt && cs is CodeAssignStatement)
{
if (IsInRange(cs, Point))
{
return((CodeElement)cs.UserData[CodeKey]);
}
}
if (Scope == vsCMElement.vsCMElementLocalDeclStmt && cs is CodeVariableDeclarationStatement)
{
if (IsInRange(cs, Point))
{
return((CodeElement)cs.UserData[CodeKey]);
}
}
CodeExpressionStatement ces = cs as CodeExpressionStatement;
if (ces != null)
{
if (Scope == vsCMElement.vsCMElementFunctionInvokeStmt && ces.Expression is CodeMethodInvokeExpression)
{
if (IsInRange(cs, Point))
{
return((CodeElement)cs.UserData[CodeKey]);
}
}
if (Scope == vsCMElement.vsCMElementPropertySetStmt && ces.Expression is CodePropertySetValueReferenceExpression)
{
if (IsInRange(cs, Point))
{
return((CodeElement)cs.UserData[CodeKey]);
}
}
}
if (Scope == vsCMElement.vsCMElementOther && IsInRange(cs, Point))
{
return((CodeElement)cs.UserData[CodeKey]);
}
}
return(null);
}
// Generate code for a statement collection.
protected void GenerateStatements(CodeStatementCollection e)
{
if(e == null)
{
return;
}
foreach(CodeStatement stmt in e)
{
((ICodeGenerator)this).GenerateCodeFromStatement
(stmt, writer.InnerWriter, Options);
}
}
internal static void BindSignalHandlers(CodeExpression targetObjectVar, ObjectWrapper wrapper, Stetic.WidgetMap map, CodeStatementCollection statements, GenerationOptions options)
{
foreach (Signal signal in wrapper.Signals)
{
SignalDescriptor descriptor = signal.SignalDescriptor;
CodeExpression createDelegate;
if (options.UsePartialClasses)
{
createDelegate =
new CodeDelegateCreateExpression(
new CodeTypeReference(descriptor.HandlerTypeName, CodeTypeReferenceOptions.GlobalReference),
new CodeThisReferenceExpression(),
signal.Handler);
}
else
{
createDelegate =
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(new CodeTypeReference(typeof(Delegate), CodeTypeReferenceOptions.GlobalReference)),
"CreateDelegate",
new CodeTypeOfExpression(descriptor.HandlerTypeName),
targetObjectVar,
new CodePrimitiveExpression(signal.Handler));
createDelegate = new CodeCastExpression(descriptor.HandlerTypeName.ToGlobalTypeRef(), createDelegate);
}
CodeAttachEventStatement cevent = new CodeAttachEventStatement(
new CodeEventReferenceExpression(
map.GetWidgetExp(wrapper),
descriptor.Name),
createDelegate);
statements.Add(cevent);
}
Wrapper.Widget widget = wrapper as Wrapper.Widget;
if (widget != null && widget.IsTopLevel)
{
// Bind local action signals
foreach (Wrapper.ActionGroup grp in widget.LocalActionGroups)
{
foreach (Wrapper.Action ac in grp.Actions)
{
BindSignalHandlers(targetObjectVar, ac, map, statements, options);
}
}
}
Gtk.Container cont = wrapper.Wrapped as Gtk.Container;
if (cont != null)
{
foreach (Gtk.Widget child in cont.AllChildren)
{
Stetic.Wrapper.Widget ww = Stetic.Wrapper.Widget.Lookup(child);
if (ww != null)
{
BindSignalHandlers(targetObjectVar, ww, map, statements, options);
}
}
}
}
protected void GenerateStatements(CodeStatementCollection stmts)
{
foreach (CodeStatement stmt in stmts)
{
((ICodeGenerator)this).GenerateCodeFromStatement(stmt, _output.InnerWriter, _options);
}
}
public override bool OnExportCode(ActionBranch previousAction, ActionBranch nextAction, ILimnorCodeCompiler compiler, CodeMemberMethod method, CodeStatementCollection statements)
{
bool bRet = false;
if (_actionList != null)
{
int last = _actionList.Count - 1;
for (int k = 0; k < _actionList.Count; k++)
{
if (_actionList[k].Action != null)
{
bRet = _actionList[k].Action.IsMethodReturn;
ActionBranch nt = null;
if (k == last)
{
nt = nextAction;
if (nt != null && nt.UseInput)
{
nt.InputName = this.OutputCodeName;
nt.InputType = this.OutputType;
nt.SetInputName(OutputCodeName, OutputType);
}
}
_actionList[k].Action.ExportCode(this, nt, compiler, this.Method, method, statements, compiler.Debug);
}
}
}
return(bRet);
}
