← Back to branch summary

~halega/+junk/sharpdevelop

« back to all changes in this revision

Viewing changes to src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/Designer/BooDesignerGenerator.cs

  • Committer: sk
  • Date: 2011-09-10 05:17:57 UTC
  • Revision ID: halega@halega.com-20110910051757-qfouz1llya9m6boy
4.1.0.7915 Release Candidate 1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/Designer/BooDesignerGenerator.cs
 
1
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
 
2
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
3
 
 
4
using System;
 
5
using System.CodeDom;
 
6
using System.Collections.Generic;
 
7
using System.Reflection;
 
8
using System.Text;
 
9
 
 
10
using ICSharpCode.FormsDesigner;
 
11
using ICSharpCode.SharpDevelop.Dom;
 
12
using ICSharpCode.SharpDevelop.Editor;
 
13
 
 
14
namespace Grunwald.BooBinding.Designer
 
15
{
 
16
        public class BooDesignerGenerator : AbstractDesignerGenerator
 
17
        {
 
18
                protected override string GenerateFieldDeclaration(CodeDOMGenerator domGenerator, CodeMemberField field)
 
19
                {
 
20
                        // TODO: add support for modifiers
 
21
                        // (or implement code generation for fields in the Boo CodeDomProvider)
 
22
                        return "private " + field.Name + " as " + field.Type.BaseType;
 
23
                }
 
24
                
 
25
                protected override System.CodeDom.Compiler.CodeDomProvider CreateCodeProvider()
 
26
                {
 
27
                        return new Boo.Lang.CodeDom.BooCodeProvider();
 
28
                }
 
29
                
 
30
                protected override void FixGeneratedCode(IClass formClass, CodeMemberMethod code)
 
31
                {
 
32
                        base.FixGeneratedCode(formClass, code);
 
33
                        Dictionary<string, IReturnType> variables = new Dictionary<string, IReturnType>();
 
34
                        foreach (IField f in formClass.DefaultReturnType.GetFields()) {
 
35
                                variables[f.Name] = f.ReturnType;
 
36
                        }
 
37
                        variables[""] = formClass.DefaultReturnType;
 
38
                        foreach (CodeStatement statement in code.Statements) {
 
39
                                CodeExpressionStatement ces = statement as CodeExpressionStatement;
 
40
                                if (ces != null) {
 
41
                                        CodeMethodInvokeExpression cmie = ces.Expression as CodeMethodInvokeExpression;
 
42
                                        if (cmie != null && cmie.Parameters.Count == 1) {
 
43
                                                CodeArrayCreateExpression cace = cmie.Parameters[0] as CodeArrayCreateExpression;
 
44
                                                if (cace != null) {
 
45
                                                        IReturnType rt = ResolveType(cmie.Method.TargetObject, variables);
 
46
                                                        if (rt != null) {
 
47
                                                                foreach (IMethod m in rt.GetMethods()) {
 
48
                                                                        if (m.Name == cmie.Method.MethodName
 
49
                                                                            && m.Parameters.Count == 1
 
50
                                                                            && m.Parameters[0].IsParams
 
51
                                                                            && m.Parameters[0].ReturnType.IsArrayReturnType)
 
52
                                                                        {
 
53
                                                                                ArrayReturnType paramArt = m.Parameters[0].ReturnType.CastToArrayReturnType();
 
54
                                                                                if (paramArt.ArrayDimensions == 1
 
55
                                                                                    && paramArt.FullyQualifiedName == cace.CreateType.BaseType)
 
56
                                                                                {
 
57
                                                                                        cace.UserData["Explode"] = true;
 
58
                                                                                }
 
59
                                                                        }
 
60
                                                                }
 
61
                                                        }
 
62
                                                }
 
63
                                        }
 
64
                                }
 
65
                                CodeVariableDeclarationStatement cvds = statement as CodeVariableDeclarationStatement;
 
66
                                if (cvds != null) {
 
67
                                        variables[cvds.Name] = new SearchClassReturnType(formClass.ProjectContent, formClass, formClass.Region.BeginLine + 1, 0, cvds.Type.BaseType, cvds.Type.TypeArguments.Count);
 
68
                                }
 
69
                        }
 
70
                }
 
71
                
 
72
                IReturnType ResolveType(CodeExpression expr, Dictionary<string, IReturnType> variables)
 
73
                {
 
74
                        IReturnType rt;
 
75
                        if (expr is CodeThisReferenceExpression) {
 
76
                                return variables[""];
 
77
                        } else if (expr is CodeVariableReferenceExpression) {
 
78
                                string name = (expr as CodeVariableReferenceExpression).VariableName;
 
79
                                if (variables.TryGetValue(name, out rt))
 
80
                                        return rt;
 
81
                        } else if (expr is CodeFieldReferenceExpression) {
 
82
                                string name = (expr as CodeFieldReferenceExpression).FieldName;
 
83
                                rt = ResolveType((expr as CodeFieldReferenceExpression).TargetObject, variables);
 
84
                                if (rt != null) {
 
85
                                        foreach (IField f in rt.GetFields()) {
 
86
                                                if (f.Name == name) {
 
87
                                                        return f.ReturnType;
 
88
                                                }
 
89
                                        }
 
90
                                }
 
91
                        } else if (expr is CodePropertyReferenceExpression) {
 
92
                                string name = (expr as CodePropertyReferenceExpression).PropertyName;
 
93
                                rt = ResolveType((expr as CodePropertyReferenceExpression).TargetObject, variables);
 
94
                                if (rt != null) {
 
95
                                        foreach (IProperty p in rt.GetProperties()) {
 
96
                                                if (p.Name == name) {
 
97
                                                        return p.ReturnType;
 
98
                                                }
 
99
                                        }
 
100
                                }
 
101
                        }
 
102
                        return null;
 
103
                }
 
104
                
 
105
                protected override string CreateEventHandler(Type eventType, string eventMethodName, string body, string indentation)
 
106
                {
 
107
                        if (string.IsNullOrEmpty(body)) body = "pass";
 
108
                        string param = GenerateParams(eventType);
 
109
                        
 
110
                        StringBuilder b = new StringBuilder();
 
111
                        b.AppendLine(indentation);
 
112
                        b.AppendLine(indentation + "private def " + eventMethodName + "(" + param + "):");
 
113
                        if (string.IsNullOrEmpty(body)) {
 
114
                                if (ICSharpCode.FormsDesigner.Gui.OptionPanels.GeneralOptionsPanel.InsertTodoComment) {
 
115
                                        body = "// TODO: Implement " + eventMethodName;
 
116
                                }
 
117
                        }
 
118
                        b.AppendLine(indentation + "\t" + body);
 
119
                        return b.ToString();
 
120
                }
 
121
                
 
122
                protected override DomRegion GetReplaceRegion(IDocument document, IMethod method)
 
123
                {
 
124
                        DomRegion r = method.BodyRegion;
 
125
                        return new DomRegion(r.BeginLine + 1, 1, r.EndLine + 1, 1);
 
126
                }
 
127
                
 
128
                protected override int GetEventHandlerInsertionLine(IClass c)
 
129
                {
 
130
                        return c.Region.EndLine + 1;
 
131
                }
 
132
                
 
133
                protected static string GenerateParams(Type eventType)
 
134
                {
 
135
                        MethodInfo mInfo = eventType.GetMethod("Invoke");
 
136
                        string param = "";
 
137
                        
 
138
                        for (int i = 0; i < mInfo.GetParameters().Length; ++i)  {
 
139
                                ParameterInfo pInfo  = mInfo.GetParameters()[i];
 
140
                                
 
141
                                param += pInfo.Name;
 
142
                                param += " as ";
 
143
                                
 
144
                                string typeStr = pInfo.ParameterType.ToString();
 
145
                                typeStr = new BooAmbience().GetIntrinsicTypeName(typeStr);
 
146
                                param += typeStr;
 
147
                                if (i + 1 < mInfo.GetParameters().Length) {
 
148
                                        param += ", ";
 
149
                                }
 
150
                        }
 
151
                        return param;
 
152
                }
 
153
        }
 
154
}