public override object Serialize(IDesignerSerializationManager manager, object tempValue)
{
CodeDomSerializer baseSerializer = (CodeDomSerializer)manager.GetSerializer
(
typeof(System.Collections.ArrayList),
typeof(CodeDomSerializer)
);
GridColumns columns = (GridColumns)tempValue;
if ((columns.Count > 0) && (columns.HasDefaultColumn()))
{
ArrayList serializeColumns = new ArrayList();
foreach (GridColumn column in columns)
{
if (!(column is Alphora.Dataphor.DAE.Client.Controls.DataColumn))
{
serializeColumns.Add(column);
}
}
return(baseSerializer.Serialize(manager, serializeColumns));
}
else
{
return(baseSerializer.Serialize(manager, tempValue));
}
}
public void GenerateCodeForSmartPartInfoCompiles()
{
DesignerSerializerAttribute attr = (DesignerSerializerAttribute)Attribute.GetCustomAttribute(
typeof(SmartPartInfo), typeof(DesignerSerializerAttribute));
CodeDomSerializer serializer = (CodeDomSerializer)Activator.CreateInstance(Type.GetType(attr.SerializerTypeName));
UserControl smartPart = new UserControl();
Container container = new Container();
SmartPartInfo info1 = new SmartPartInfo("foo", "");
container.Add(info1, "info1");
MockSPI info2 = new MockSPI("bar", "");
container.Add(info2, "info2");
MockManager manager = new MockManager(container.Components);
manager.Services.Add(typeof(IDesignerHost), new MockDesignerHost(smartPart, container));
manager.Services.Add(typeof(IReferenceService), new MockReferenceService(container.Components));
manager.Services.Add(typeof(IContainer), container);
manager.Services.Add(typeof(IDesignerSerializationManager), manager);
CodeTypeDeclaration declaration = new CodeTypeDeclaration("UserControl1");
CodeMemberMethod init = new CodeMemberMethod();
init.Name = "InitializeComponent";
declaration.Members.Add(init);
// Add empty fields for both SPIs.
declaration.Members.Add(new CodeMemberField(typeof(ISmartPartInfo), "info1"));
declaration.Members.Add(new CodeMemberField(typeof(ISmartPartInfo), "info2"));
manager.Services.Add(typeof(CodeTypeDeclaration), declaration);
serializer.Serialize(manager, info1);
serializer.Serialize(manager, info2);
StringWriter sw = new StringWriter();
new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromType(
declaration, sw, new CodeGeneratorOptions());
sw.Flush();
//Console.WriteLine(sw.ToString());
CompilerResults results = new Microsoft.CSharp.CSharpCodeProvider().CompileAssemblyFromSource(
new CompilerParameters(new string[] {
"System.dll",
new Uri(typeof(SmartPartInfo).Assembly.CodeBase).LocalPath
}),
sw.ToString());
Assert.IsFalse(results.Errors.HasErrors, ErrorsToString(results.Errors));
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeDomSerializer serializer1 = (CodeDomSerializer)manager.GetSerializer(this.GetPropType().BaseType, typeof(CodeDomSerializer));
object obj1 = serializer1.Serialize(manager, value);
if (this.ShouldSerialize(value) && (obj1 is CodeStatementCollection))
{
string text1 = manager.GetName(value);
if ((text1 != null) && (text1 != string.Empty))
{
CodeStatementCollection collection1 = (CodeStatementCollection)obj1;
CodeExpression expression1 = base.SerializeToExpression(manager, value);
IDesignerHost host1 = ((Component)value).Container as IDesignerHost;
if (host1.RootComponent != null)
{
string text2 = manager.GetName(host1.RootComponent);
if ((text2 != null) && (text2 != string.Empty))
{
CodePropertyReferenceExpression expression2 = new CodePropertyReferenceExpression(expression1, this.GetPropName());
CodeExpression[] expressionArray1 = new CodeExpression[1] {
new CodeTypeOfExpression(text2)
};
expressionArray1 = new CodeExpression[1] {
new CodePrimitiveExpression(text1 + ".XmlScheme")
};
CodeMethodInvokeExpression expression3 = new CodeMethodInvokeExpression(new CodeObjectCreateExpression(typeof(ResourceManager), expressionArray1), "GetObject", expressionArray1);
CodeCastExpression expression4 = new CodeCastExpression("System.String", expression3);
CodeAssignStatement statement1 = new CodeAssignStatement(expression2, expression4);
collection1.Add(statement1);
}
}
}
}
return(obj1);
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeDomSerializer baseSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(BvResourceManagerChanger).BaseType, typeof(CodeDomSerializer));
object codeObject = baseSerializer.Serialize(manager, value);
if (codeObject is CodeStatementCollection)
{
CodeStatementCollection statements = (CodeStatementCollection)codeObject;
Component component = (Component)value;
IDesignerHost host = component.Site.GetService(typeof(IDesignerHost)) as IDesignerHost;
if (host != null)
{
CodeCommentStatement comment = new CodeCommentStatement("Form Is Localizable: " + IsLocalizable(host));
statements.Insert(0, comment);
if (IsLocalizable(host))
{
CodeTypeDeclaration classTypeDeclaration = (CodeTypeDeclaration)manager.GetService(typeof(CodeTypeDeclaration));
CodeExpression typeofExpression = new CodeTypeOfExpression(classTypeDeclaration.Name);
CodeDirectionExpression outResourceExpression = new CodeDirectionExpression(FieldDirection.Out, new CodeVariableReferenceExpression("resources"));
CodeExpression rightCodeExpression = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("bv.common.Resources.BvResourceManagerChanger"), "GetResourceManager", new CodeExpression[] { typeofExpression, outResourceExpression });
statements.Insert(0, new CodeExpressionStatement(rightCodeExpression));
}
}
}
return(codeObject);
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeDomSerializer _codeDomSerializer = (CodeDomSerializer)manager.GetSerializer(
typeof(MultiFunctionChartLegend).BaseType, typeof(CodeDomSerializer));
object _object = _codeDomSerializer.Serialize(manager, value);
if (_object is CodeStatementCollection)
{
CodeStatementCollection _codeStatementCollection = (CodeStatementCollection)_object;
CodeExpression _targetObject = base.GetExpression(manager, value);
if (_targetObject != null)
{
CodePropertyReferenceExpression _codePropertyReferenceExpression = new CodePropertyReferenceExpression(_targetObject, "OwnerChart");
CodeAssignStatement _codeAssignStatement = new CodeAssignStatement(_codePropertyReferenceExpression, new CodeThisReferenceExpression());
_codeStatementCollection.Insert(0, _codeAssignStatement);
CodeCommentStatement _codeCommentStatement = new CodeCommentStatement(
new CodeComment("WARNING: This generates an exception in design time, but is ok (select 'Ignore and continue')."));
_codeStatementCollection.Insert(0, _codeCommentStatement);
}
}
return(_object);
}
/// <summary>
/// We customize the output from the default serializer here, adding
/// a comment and an extra line of code.
/// </summary>
public override object Serialize(IDesignerSerializationManager manager, object value)
{
// first, locate and invoke the default serializer for
// the ButtonArray's base class (UserControl)
//
CodeDomSerializer baseSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(WizardStepsControl).BaseType, typeof(CodeDomSerializer));
object codeObject = baseSerializer.Serialize(manager, value);
// now add some custom code
//
if (codeObject is CodeStatementCollection)
{
// add a custom comment to the code.
//
CodeStatementCollection statements = (CodeStatementCollection)codeObject;
statements.Insert(4, new CodeCommentStatement("This is a custom comment added by a custom serializer on " + DateTime.Now.ToLongDateString()));
// call a custom method.
//
CodeExpression targetObject = base.SerializeToExpression(manager, value);
WizardStepsControl wsc = (WizardStepsControl)value;
if (targetObject != null && wsc.Steps != null)
{
CodePropertyReferenceExpression leftNode = new CodePropertyReferenceExpression(targetObject, "Steps");
CodeObjectCreateExpression rightNode = new CodeObjectCreateExpression(typeof(Collection <Step>));
CodeAssignStatement initializeStepsStatement = new CodeAssignStatement(leftNode, rightNode);
statements.Insert(5, initializeStepsStatement);
}
}
// finally, return the statements that have been created
return(codeObject);
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeDomSerializer serializer = GetBaseSerializer(manager);
object returnObj = serializer.Serialize(manager, value);
return(returnObj);
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeDomSerializer codeDomSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(PlotToolBarButton).BaseType, typeof(CodeDomSerializer));
object obj = codeDomSerializer.Serialize(manager, value);
CodeExpression codeExpression = base.SerializeToExpression(manager, value);
if (codeExpression == null)
{
return(obj);
}
if (!(obj is CodeStatementCollection))
{
return(obj);
}
CodeStatementCollection codeStatementCollection = (CodeStatementCollection)obj;
CodeMethodInvokeExpression expression = new CodeMethodInvokeExpression(codeExpression, "LoadingBegin");
int index = 0;
for (int i = 0; i < codeStatementCollection.Count; i++)
{
if (codeStatementCollection[i] is CodeCommentStatement)
{
index = i + 1;
}
}
codeStatementCollection.Insert(index, new CodeExpressionStatement(expression));
expression = new CodeMethodInvokeExpression(codeExpression, "LoadingEnd");
codeStatementCollection.Add(expression);
return(obj);
}
// See sample for the Deserialize method
/// <summary>
/// We customize the output from the default serializer here, adding
/// a comment and an extra line of code.
/// </summary>
public override object Serialize(IDesignerSerializationManager manager, object value)
{
// first, locate and invoke the default serializer for
// the ButtonArray's base class (UserControl)
//
CodeDomSerializer baseSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(TaskBarButton).BaseType, typeof(CodeDomSerializer));
object codeObject = baseSerializer.Serialize(manager, value);
// now add some custom code
//
if (codeObject is CodeStatementCollection)
{
// add a custom comment to the code.
//
CodeStatementCollection statements = (CodeStatementCollection)codeObject;
//statements.Insert(0, new CodeCommentStatement("This is a custom comment added by a custom serializer on " + DateTime.Now.ToLongDateString()));
// call a custom method.
//
CodeExpression targetObject = base.SerializeToExpression(manager, value);
if (targetObject != null)
{
CodeExpression args = new CodeSnippetExpression("this.Handle");
CodeMethodInvokeExpression methodCall = new CodeMethodInvokeExpression(targetObject, "AddToWindow");
methodCall.Parameters.Add(args);
statements.Add(methodCall);
}
}
// finally, return the statements that have been created
return(codeObject);
}
public override object Serialize(
IDesignerSerializationManager manager, object value)
{
CodeDomSerializer baseSerializer = manager.GetSerializer(
typeof(FlowChart).BaseType, typeof(CodeDomSerializer)) as CodeDomSerializer;
object codeObject = baseSerializer.Serialize(manager, value);
if (codeObject is CodeStatementCollection)
{
CodeStatementCollection code =
codeObject as CodeStatementCollection;
FlowChart chart = value as FlowChart;
// Brushes
SerializeBrush(code, "BackBrush", chart, chart.BackBrush);
SerializeBrush(code, "BoxBrush", chart, chart.BoxBrush);
SerializeBrush(code, "TableBrush", chart, chart.TableBrush);
SerializeBrush(code, "ArrowBrush", chart, chart.ArrowBrush);
// Pens
SerializePen(code, "BoxPen", chart, chart.BoxPen);
SerializePen(code, "TablePen", chart, chart.TablePen);
SerializePen(code, "ArrowPen", chart, chart.ArrowPen);
// Text alignment
SerializeTextFormat(code, "TextFormat", chart, chart.TextFormat);
}
return(codeObject);
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
try {
CodeDomSerializer serial = (CodeDomSerializer)manager.GetSerializer(typeof(Component), typeof(CodeDomSerializer));
if (serial == null)
{
return(null);
}
CodeStatementCollection statements = (CodeStatementCollection)serial.Serialize(manager, value);
IDesignerHost host = (IDesignerHost)manager.GetService(typeof(IDesignerHost));
if (host == value)
{
return(statements);
}
InsertCodeCommentHeader(statements);
Calendar cdr = (Calendar)value;
CodeExpression cnref = SerializeToExpression(manager, value);
CodePropertyReferenceExpression propref = null;
//CodeAssignStatement cassign = null;
//cdr.CalendarStyle.CalendarHeader = new HeaderStyle(Font, foreColor, backColor, height);
// CalendarStyle.CalendarHeader
propref = new CodePropertyReferenceExpression(cnref, "CalendarStyle.CalendarHeader");
return(statements);
} catch (Exception ex) {
MessageBox.Show("Error during Serialize : " + ex.ToString());
return(null);
}
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeDomSerializer _codeDomSerializer = (CodeDomSerializer)manager.GetSerializer(
typeof(DXPlayer).BaseType, typeof(CodeDomSerializer));
object _object = _codeDomSerializer.Serialize(manager, value);
if (_object is CodeStatementCollection)
{
CodeStatementCollection _codeStatementCollection = (CodeStatementCollection)_object;
CodeExpression _targetObject = base.GetExpression(manager, value);
if (_targetObject != null)
{
CodePropertyReferenceExpression _codePropertyReferenceExpression =
new CodePropertyReferenceExpression(_targetObject, "Owner");
CodeAssignStatement _codeAssignStatement = new CodeAssignStatement(
_codePropertyReferenceExpression, new CodeThisReferenceExpression());
_codeStatementCollection.Insert(0, _codeAssignStatement);
}
}
return(_object);
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeDomSerializer baseSerializer =
(CodeDomSerializer)manager.GetSerializer(typeof(ResourceControl).BaseType, typeof(CodeDomSerializer));
object codeObject = baseSerializer.Serialize(manager, value);
if (codeObject is CodeStatementCollection)
{
CodeStatementCollection statements = (CodeStatementCollection)codeObject;
statements.Insert(0, new CodeCommentStatement("MLUResManager is used to set the custom resource file which in the another resource.dll."));
statements.Insert(0, new CodeCommentStatement("Must to set the BaseName property which is use to get the resource file name."));
CodeExpression targetObject =
base.SerializeToExpression(manager, value);
if (targetObject != null)
{
CodeExpression Paramter = new CodeArgumentReferenceExpression("ref resources");
CodeMethodInvokeExpression methodCall =
new CodeMethodInvokeExpression(targetObject, "reInitResManger", Paramter);
statements.Add(methodCall);
}
}
return(codeObject);
}
/// <summary>
///
/// </summary>
/// <param name="manager"></param>
/// <param name="value"></param>
/// <returns></returns>
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeDomSerializer baseClassSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(Component), typeof(CodeDomSerializer));
object codeObject = baseClassSerializer.Serialize(manager, value);
if (value.GetType().GetInterface("IWSerializer") == null)
{
System.Windows.Forms.MessageBox.Show("Must not never reach here:" + value.GetType().ToString());
return(codeObject);
}
MethodInfo mInf = value.GetType().GetInterface("IWSerializer").GetMethod("ShouldSerialize");
if (codeObject is CodeStatementCollection)
{
CodeStatementCollection statements = (CodeStatementCollection)codeObject;
//--- loop through all statements
int count = statements.Count;
for (int i = 0; i < count; i++)
{
CodeStatement st = statements[i];
if (st is CodeAssignStatement)
{
CodeAssignStatement cAssign = (CodeAssignStatement)st;
// If left is eg. 'this.BorderColor'
if (cAssign.Left is CodePropertyReferenceExpression)
{
/* if(cAssign.Right is CodeCastExpression){
* CodeCastExpression c = (CodeCastExpression)cAssign.Right;
* if(c.Expression is CodeMethodInvokeExpression){
* CodeMethodInvokeExpression mI = (CodeMethodInvokeExpression)c.Expression;
* if(mI.Method.TargetObject is CodeVariableReferenceExpression){
* CodeVariableReferenceExpression vR = (CodeVariableReferenceExpression)mI.Method.TargetObject;
* System.Windows.Forms.MessageBox.Show(vR.);
* }
* }
* }*/
string propertyName = ((CodePropertyReferenceExpression)cAssign.Left).PropertyName;
//--- Check if we need to serialize property.
if (!(bool)mInf.Invoke(value, new object[] { propertyName }))
{
statements.Remove(st);
count--;
i--;
}
}
}
}
}
return(codeObject);
}
/// <summary>
/// Serializes the specified object into a CodeDOM object.
/// </summary>
/// <param name="manager">A serialization manager interface that is used during the deserialization process.</param>
/// <param name="value">The object to serialize.</param>
/// <returns>A CodeDOM object representing the object that has been serialized.</returns>
public override object Serialize(IDesignerSerializationManager manager, object value)
{
// Set serialization flag
bool oldSerializationFlag = false;
SerializationStatus oldSerializationStatus = SerializationStatus.None;
Chart chart = value as Chart;
if (chart != null)
{
oldSerializationFlag = chart.serializing;
oldSerializationStatus = chart.serializationStatus;
chart.serializing = true;
chart.serializationStatus = SerializationStatus.Saving;
}
// Serialize object using the base class serializer
object result = null;
CodeDomSerializer baseSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(Chart).BaseType, typeof(CodeDomSerializer));
if (baseSerializer != null)
{
result = baseSerializer.Serialize(manager, value);
System.CodeDom.CodeStatementCollection statements = result as System.CodeDom.CodeStatementCollection;
// Sustom serialization of the DataSource property
if (statements != null && chart != null)
{
// Check if DataSource property is set
if (chart.DataSource != null && chart.DataSource is String && ((String)chart.DataSource) != "(none)")
{
// Add assignment statement for the DataSource property
System.CodeDom.CodeExpression targetObject =
base.SerializeToExpression(manager, value);
if (targetObject != null)
{
System.CodeDom.CodeAssignStatement assignStatement = new System.CodeDom.CodeAssignStatement(
new System.CodeDom.CodePropertyReferenceExpression(targetObject, "DataSource"),
new System.CodeDom.CodePropertyReferenceExpression(new System.CodeDom.CodeThisReferenceExpression(), (String)chart.DataSource));
statements.Add(assignStatement);
}
}
}
}
// Clear serialization flag
if (chart != null)
{
chart.serializing = oldSerializationFlag;
chart.serializationStatus = oldSerializationStatus;
}
return(result);
}
public override object Serialize(IDesignerSerializationManager AManager, object AValue)
{
CodeDomSerializer LBaseSerializer = (CodeDomSerializer)AManager.GetSerializer
(
typeof(System.Collections.ArrayList),
typeof(CodeDomSerializer)
);
GridColumns LColumns = (GridColumns)AValue;
if ((LColumns.Count > 0) && (LColumns[0].IsDefaultGridColumn))
{
ArrayList LSerializeColumns = new ArrayList();
return(LBaseSerializer.Serialize(AManager, LSerializeColumns));
}
else
{
return(LBaseSerializer.Serialize(AManager, AValue));
}
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
if (manager == null || value == null)
{
throw new ArgumentNullException((manager == null) ? "manager" : "value");
}
CodeDomSerializer codeDomSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(Component), typeof(CodeDomSerializer));
if (codeDomSerializer == null)
{
return(null);
}
object obj = codeDomSerializer.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)
{
IDesignerHost designerHost = (IDesignerHost)manager.GetService(typeof(IDesignerHost));
if (designerHost != null)
{
PropertyDescriptor propertyDescriptor = TypeDescriptor.GetProperties(designerHost.RootComponent)["Localizable"];
if (propertyDescriptor != null && propertyDescriptor.PropertyType == typeof(bool) && (bool)propertyDescriptor.GetValue(designerHost.RootComponent))
{
this.SerializeControlHierarchy(manager, designerHost, value);
}
}
CodeStatementCollection codeStatementCollection = obj as CodeStatementCollection;
if (codeStatementCollection != null)
{
Control control = (Control)value;
if ((designerHost != null && control == designerHost.RootComponent) || this.HasSitedNonReadonlyChildren(control))
{
this.SerializeSuspendLayout(manager, codeStatementCollection, value);
this.SerializeResumeLayout(manager, codeStatementCollection, value);
ControlDesigner controlDesigner = designerHost.GetDesigner(control) as ControlDesigner;
var serializePerformLayoutProp = typeof(ControlDesigner).GetProperty("SerializePerformLayout", BindingFlags.NonPublic | BindingFlags.Instance);
if (this.HasAutoSizedChildren(control) || (controlDesigner != null && (bool)serializePerformLayoutProp.GetValue(controlDesigner)))
{
this.SerializePerformLayout(manager, codeStatementCollection, value);
}
}
if (this.HasMixedInheritedChildren(control))
{
this.SerializeZOrder(manager, codeStatementCollection, control);
}
}
}
return(obj);
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeDomSerializer serializer1 = GetSerializer(manager);
if (serializer1 == null)
{
return(null);
}
return(serializer1.Serialize(manager, value));
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
if ((manager == null) || (value == null))
{
throw new ArgumentNullException((manager == null) ? "manager" : "value");
}
CodeDomSerializer serializer = (CodeDomSerializer)manager.GetSerializer(typeof(Component), typeof(CodeDomSerializer));
if (serializer == null)
{
return(null);
}
object obj2 = serializer.Serialize(manager, value);
InheritanceAttribute attribute = (InheritanceAttribute)TypeDescriptor.GetAttributes(value)[typeof(InheritanceAttribute)];
InheritanceLevel notInherited = InheritanceLevel.NotInherited;
if (attribute != null)
{
notInherited = attribute.InheritanceLevel;
}
if (notInherited != InheritanceLevel.InheritedReadOnly)
{
IDesignerHost service = (IDesignerHost)manager.GetService(typeof(IDesignerHost));
if (service != null)
{
PropertyDescriptor descriptor = TypeDescriptor.GetProperties(service.RootComponent)["Localizable"];
if (((descriptor != null) && (descriptor.PropertyType == typeof(bool))) && ((bool)descriptor.GetValue(service.RootComponent)))
{
this.SerializeControlHierarchy(manager, service, value);
}
}
CodeStatementCollection statements = obj2 as CodeStatementCollection;
if (statements == null)
{
return(obj2);
}
Control parent = (Control)value;
if (((service != null) && (parent == service.RootComponent)) || this.HasSitedNonReadonlyChildren(parent))
{
this.SerializeSuspendLayout(manager, statements, value);
this.SerializeResumeLayout(manager, statements, value);
ControlDesigner designer = service.GetDesigner(parent) as ControlDesigner;
if (this.HasAutoSizedChildren(parent) || ((designer != null) && designer.SerializePerformLayout))
{
this.SerializePerformLayout(manager, statements, value);
}
}
if (this.HasMixedInheritedChildren(parent))
{
this.SerializeZOrder(manager, statements, parent);
}
}
return(obj2);
}
/// <summary>
/// Serializes a PaletteGroupView object to the code DOM.
/// </summary>
/// <param name="manager"></param>
/// <param name="value"></param>
/// <returns></returns>
public override object Serialize(IDesignerSerializationManager manager, object value)
{
object retVal = value;
CodeDomSerializer baseSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(GroupView), typeof(CodeDomSerializer));
if (baseSerializer != null)
{
retVal = baseSerializer.Serialize(manager, value);
if (retVal != null)
{
System.CodeDom.CodeStatementCollection stmts = retVal as System.CodeDom.CodeStatementCollection;
if (stmts != null)
{
PaletteGroupView palGrpVw = value as PaletteGroupView;
if (palGrpVw != null)
{
SymbolPalette pal = palGrpVw.Palette;
if (pal != null)
{
// Serialize the palette into the resource file
BinaryFormatter formatter = new BinaryFormatter();
System.IO.MemoryStream oStream = new System.IO.MemoryStream();
formatter.Serialize(oStream, pal);
string resName = palGrpVw.Name + "." + "Palette";
this.SerializeResource(manager, resName, oStream.GetBuffer());
oStream.Close();
// Add statements to CodeDom to load the palette from
// the resource file at run-time
string formClassName = "";
IDesignerHost designerHost = manager.GetService(typeof(IDesignerHost)) as IDesignerHost;
if (designerHost != null)
{
formClassName = designerHost.RootComponentClassName;
CodePropertyReferenceExpression exprRefGroupView = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), palGrpVw.Name);
CodeExpression[] loadPalParams = new CodeExpression[]
{
new CodePropertyReferenceExpression(new CodeTypeOfExpression(formClassName), "Assembly"),
new CodePrimitiveExpression(formClassName),
new CodePrimitiveExpression(resName)
};
CodeMethodInvokeExpression stmtLoadPalette = new CodeMethodInvokeExpression(exprRefGroupView, "LoadPalette", loadPalParams);
stmts.Add(stmtLoadPalette);
}
}
}
}
}
}
return(retVal);
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
ToolStripMenuItem item = value as ToolStripMenuItem;
ToolStrip currentParent = item.GetCurrentParent();
if (((item != null) && !item.IsOnDropDown) && ((currentParent != null) && (currentParent.Site == null)))
{
return(null);
}
CodeDomSerializer serializer = (CodeDomSerializer)manager.GetSerializer(typeof(ImageList).BaseType, typeof(CodeDomSerializer));
return(serializer.Serialize(manager, value));
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeDomSerializer baseClassSerializer = (CodeDomSerializer)manager.
GetSerializer(typeof(MyComponent).BaseType, typeof(CodeDomSerializer));
object codeObject = baseClassSerializer.Serialize(manager, value);
if (codeObject is CodeStatementCollection)
{
CodeStatementCollection statements = (CodeStatementCollection)codeObject;
// Initial MyList
// Generate "myComponent1.MyList = new System.Collections.Generic.List<string>();"
CodeObjectCreateExpression objectCreate1;
objectCreate1 = new CodeObjectCreateExpression("System.Collections.Generic.List<string>", new CodeExpression[] { });
CodeAssignStatement as2 =
new CodeAssignStatement(new CodeVariableReferenceExpression(manager.GetName(value) + ".MyList"),
objectCreate1);
statements.Insert(0, as2);
// Add my generated code comment
string commentText = "MyList generation code";
CodeCommentStatement comment = new CodeCommentStatement(commentText);
statements.Insert(1, comment);
// Add items to MyList
// Generate the following code
// this.myComponent1.MyList.Add("string5");
// this.myComponent1.MyList.Add("string4");
// this.myComponent1.MyList.Add("string3");
// this.myComponent1.MyList.Add("string2");
// this.myComponent1.MyList.Add("string1");
MyComponent myCom = (MyComponent)manager.GetInstance(manager.GetName(value));
for (int i = 0; i < myCom.MyList.Count; i++)
{
CodeMethodInvokeExpression methodInvoke = new CodeMethodInvokeExpression(
// targetObject that contains the method to invoke.
new CodeThisReferenceExpression(),
// methodName indicates the method to invoke.
manager.GetName(value) + ".MyList.Add",
// parameters array contains the parameters for the method.
new CodeExpression[] { new CodePrimitiveExpression(myCom.MyList[i]) });
CodeExpressionStatement expressionStatement;
expressionStatement = new CodeExpressionStatement(methodInvoke);
statements.Insert(2, expressionStatement);
}
// Remove system generated code
statements.RemoveAt(statements.Count - 1);
}
return(codeObject);
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeDomSerializer baseClassSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(ComboBoxMultiColumns).BaseType, typeof(CodeDomSerializer));
object codeObject = baseClassSerializer.Serialize(manager, value);
if (codeObject is CodeStatementCollection)
{
ComboBoxMultiColumns comboBoxMultiColumns = value as ComboBoxMultiColumns;
if (comboBoxMultiColumns != null)
{
CodeStatementCollection statements = (CodeStatementCollection)codeObject;
List <CodeObjectCreateExpression> parameter_list = new List <CodeObjectCreateExpression>();
foreach (ComboBoxColumn column in comboBoxMultiColumns.Columns)
{
parameter_list.Add
(
new CodeObjectCreateExpression
(
typeof(ComboBoxColumn),
new CodeExpression[]
{
new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("ComboBoxMultiColumns.ComboBoxColumnAlignment"), column.Alignment.ToString()),
new CodePrimitiveExpression(column.AutoSize),
new CodePrimitiveExpression(column.Caption),
new CodePrimitiveExpression(column.FieldName),
new CodePrimitiveExpression(column.FormatString),
new CodePrimitiveExpression(column.Visible),
new CodePrimitiveExpression(column.Width)
}
)
);
}
CodeArrayCreateExpression createArray = new CodeArrayCreateExpression(typeof(ComboBoxColumn), parameter_list.ToArray());
CodeFieldReferenceExpression target = base.SerializeToExpression(manager, value) as CodeFieldReferenceExpression;
if (target != null && parameter_list.Count > 0)
{
//CodeMethodInvokeExpression methodCall = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("this." + target.FieldName + ".Columns"), "AddRange", createArray);
CodeMethodReferenceExpression methodCall = new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), target.FieldName + ".Columns.AddRange");
CodeMethodInvokeExpression invoker = new CodeMethodInvokeExpression(methodCall, createArray);
statements.Add(invoker);
}
}
}
return(codeObject);
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
ConstantsExtenderProvider provider = value as ConstantsExtenderProvider;
CodeDomSerializer baseClassSerializer = manager.GetSerializer(typeof(ConstantsExtenderProvider).BaseType, typeof(CodeDomSerializer)) as CodeDomSerializer;
CodeStatementCollection statements = baseClassSerializer.Serialize(manager, value) as CodeStatementCollection;
IDesignerHost host = (IDesignerHost)manager.GetService(typeof(IDesignerHost));
ComponentCollection components = host.Container.Components;
this.SerializeExtender(manager, provider, components, statements);
return statements;
}
public override void Flush()
{
if (this.dirty)
{
XmlDocument document = new XmlDocument();
document.AppendChild(document.CreateElement("DOCUMENT_ELEMENT"));
IComponent root = this.host.RootComponent;
Hashtable nametable = new Hashtable(this.host.Container.Components.Count);
document.DocumentElement.AppendChild(this.WriteObject(document, nametable, root));
foreach (IComponent comp in this.host.Container.Components)
{
if (!((comp == root) || nametable.ContainsKey(comp)))
{
document.DocumentElement.AppendChild(this.WriteObject(document, nametable, comp));
}
}
CodeCompileUnit code = new CodeCompileUnit();
CodeNamespace ns = new CodeNamespace(root.Site.Name + "Namespace");
ns.Imports.Add(new CodeNamespaceImport("System"));
SampleTypeResolutionService strs = this.host.GetService(typeof(ITypeResolutionService)) as SampleTypeResolutionService;
foreach (Assembly assm in strs.RefencedAssemblies)
{
ns.Imports.Add(new CodeNamespaceImport(assm.GetName().Name));
}
RootDesignerSerializerAttribute a = TypeDescriptor.GetAttributes(root)[typeof(RootDesignerSerializerAttribute)] as RootDesignerSerializerAttribute;
CodeDomSerializer cds = Activator.CreateInstance(this.host.GetType(a.SerializerTypeName)) as CodeDomSerializer;
IDesignerSerializationManager manager = this.host.GetService(typeof(IDesignerSerializationManager)) as IDesignerSerializationManager;
CodeTypeDeclaration td = cds.Serialize(manager, root) as CodeTypeDeclaration;
CodeConstructor con = new CodeConstructor();
con.Attributes = MemberAttributes.Public;
con.Statements.Add(new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), "InitializeComponent"), new CodeExpression[0]));
td.Members.Add(con);
CodeEntryPointMethod main = new CodeEntryPointMethod();
main.Name = "Main";
main.Attributes = MemberAttributes.Public | MemberAttributes.Static;
main.CustomAttributes.Add(new CodeAttributeDeclaration("System.STAThreadAttribute"));
main.Statements.Add(new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(typeof(Application)), "Run"), new CodeExpression[] { new CodeObjectCreateExpression(new CodeTypeReference(root.Site.Name), new CodeExpression[0]) }));
td.Members.Add(main);
ns.Types.Add(td);
code.Namespaces.Add(ns);
this.dirty = false;
this.xmlDocument = document;
this.codeCompileUnit = code;
this.UpdateCodeWindows();
}
}
public override object Serialize(IDesignerSerializationManager AManager, object AValue)
{
CodeDomSerializer LbaseSerializer = (CodeDomSerializer)AManager.GetSerializer(typeof(Alphora.Dataphor.DAE.Client.DataSession).BaseType, typeof(CodeDomSerializer));
object LCodeObject = LbaseSerializer.Serialize(AManager, AValue);
if (LCodeObject is CodeStatementCollection)
{
CodeStatementCollection LStatements = (CodeStatementCollection)LCodeObject;
CodeStatement LSetActivePropertyStatement = GetPropertyAssignStatement(LStatements, CPropertyName);
if (LSetActivePropertyStatement != null)
{
LStatements.Remove(LSetActivePropertyStatement);
LStatements.Insert(LStatements.Count, LSetActivePropertyStatement);
}
}
return(LCodeObject);
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeDomSerializer serial = GetConfiguredSerializer(manager, value);
if (serial == null)
{
return(null);
}
CodeStatementCollection statements = (CodeStatementCollection)serial.Serialize(manager, value);
PropertyDescriptor prop = TypeDescriptor.GetProperties(value)["WebMapping"];
MapperInfo info = (MapperInfo)prop.GetValue(value);
DataUIMapper dm = (DataUIMapper)
DesignUtils.ProviderProperty.GetValue(prop, new object[0]);
//Attach the view mappings to the control attributes.
if (info.ControlProperty != String.Empty && info.DataProperty != String.Empty)
{
CodeExpression ctlref = SerializeToExpression(manager, value);
CodeCastExpression cast = new CodeCastExpression(typeof(IAttributeAccessor), ctlref);
statements.Add(new CodeMethodInvokeExpression(
cast, "SetAttribute", new CodeExpression[] {
new CodePrimitiveExpression("DIM_Mapper"),
new CodePrimitiveExpression(manager.GetName(dm))
}));
statements.Add(new CodeMethodInvokeExpression(
cast, "SetAttribute", new CodeExpression[] {
new CodePrimitiveExpression("DIM_Format"),
new CodePrimitiveExpression(info.Format)
}));
statements.Add(new CodeMethodInvokeExpression(
cast, "SetAttribute", new CodeExpression[] {
new CodePrimitiveExpression("DIM_DataProperty"),
new CodePrimitiveExpression(info.DataProperty)
}));
statements.Add(new CodeMethodInvokeExpression(
cast, "SetAttribute", new CodeExpression[] {
new CodePrimitiveExpression("DIM_ControlProperty"),
new CodePrimitiveExpression(info.ControlProperty)
}));
}
return(statements);
}
public override object Serialize(IDesignerSerializationManager manager, object tempValue)
{
CodeDomSerializer LbaseSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(System.ComponentModel.Component), typeof(CodeDomSerializer));
object codeObject = LbaseSerializer.Serialize(manager, tempValue);
if (codeObject is CodeStatementCollection)
{
CodeStatementCollection statements = (CodeStatementCollection)codeObject;
CodeStatement assignPropertyStatement = GetPropertyAssignStatement(statements, PropertyName);
if (assignPropertyStatement != null)
{
statements.Remove(assignPropertyStatement);
statements.Insert(statements.Count, assignPropertyStatement);
}
}
return(codeObject);
}
/// <summary>
/// We implement this for the abstract method on CodeDomSerializer. This method
/// takes an object graph, and serializes the object into CodeDom elements.
/// </summary>
public override object Serialize(IDesignerSerializationManager manager, object value)
{
ToolStripMenuItem item = value as ToolStripMenuItem;
ToolStrip parent = item.GetCurrentParent() as ToolStrip;
//Dont Serialize if we are Dummy Item ...
if ((item != null) && !(item.IsOnDropDown) && (parent != null) && (parent.Site == null))
{
//dont serialize anything...
return(null);
}
else
{
CodeDomSerializer baseSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(ImageList).BaseType, typeof(CodeDomSerializer));
return(baseSerializer.Serialize(manager, value));
}
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeDomSerializer baseClassSerializer = (CodeDomSerializer)manager.
GetSerializer(typeof(Report).BaseType, typeof(CodeDomSerializer));
object codeObject = baseClassSerializer.Serialize(manager, value);
if (codeObject is CodeStatementCollection)
{
CodeStatementCollection statements = (CodeStatementCollection)codeObject;
Report report = value as Report;
List <string> addedItems = new List <string>();
foreach (Dictionary.RegDataItem item in report.Dictionary.RegisteredItems)
{
string dsName = "";
if (item.Data is DataTable)
{
dsName = (item.Data as DataTable).DataSet.Site.Name;
}
else if (item.Data is BindingSource)
{
dsName = (item.Data as BindingSource).Site.Name;
}
if (dsName != "" && !addedItems.Contains(dsName))
{
CodeExpression[] args = new CodeExpression[] {
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), dsName),
new CodePrimitiveExpression(dsName)
};
CodeExpression invokeExpression = new CodeMethodInvokeExpression(
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), report.Site.Name),
"RegisterData",
args);
statements.Add(new CodeExpressionStatement(invokeExpression));
addedItems.Add(dsName);
}
}
}
return(codeObject);
}
