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