// CodeMapping Function
public string LoadDynamicAssembly(int depth = 0)
{
var indentBuilder = new IndentStringBuilder(depth);
foreach (string dllName in WPFCompiler.DynamicLibraries)
{
indentBuilder.AppendLine($"DynamicLoadDll(\"{dllName}\");");
}
return(indentBuilder.ToString());
}
// CodeMapping Function
public string WindowConstructor(int depth = 0)
{
var indentBuilder = new IndentStringBuilder(depth);
if (Parameter.Option.TargetPlatform == Platform.Android)
{
indentBuilder.Append("this.SetAndroidStyle();");
}
return(indentBuilder.ToString());
}
public virtual void AddFirst()
{
IndentStringBuilder orig = _sb;
_sb = new IndentStringBuilder();
Add();
orig.sb.Insert(0, _sb.ToString());
_sb = orig;
}
private void ValidateModel(object sender, EventArgs args)
{
var codeFrm = new ShowCodeFrm();
var model = ModelManager.Instance().GetModel(this.FileId.Value);
var module = ModelManager.Instance().MakeSureParseModule(model.File);
var builder = new IndentStringBuilder();
((ViewModelDB)module).Render(builder);
codeFrm.SetText(builder.ToString());
codeFrm.Show();
}
public override void Trigger(EditableView.ClickPosition.Sources source, EditableView pnlView, Transaction transaction)
{
string file = FileDialog.ShowSave(FileDialog.Context.UserExport, "*.txt|*.txt");
if (string.IsNullOrEmpty(file))
{
return;
}
IndentStringBuilder output = new IndentStringBuilder();
CurrentDocument.WriteExportText(output);
File.WriteAllText(file, output.ToString());
}
// CodeMapping Function
public string ComponentInitialize(int depth = 0)
{
var indentBuilder = new IndentStringBuilder(depth);
try
{
foreach (var kv in this.Mapper.NameContainer)
{
var attr = kv.Value.GetAttribute <WPFAttribute>();
string name = kv.Key.Trim('_');
indentBuilder.AppendLine($"{name} = this.FindElement<{attr.Name}>(\"{name}\");");
}
logicCodes.Clear();
logicCodes.AddRange(this.NativeGenerator.Generate().ToArray());
if (logicCodes.Count > 0 && logicCodes[0].Length > 0)
{
indentBuilder.AppendLine();
indentBuilder.AppendLine("// Event Handlers");
indentBuilder.AppendBlock(logicCodes[0]);
}
if (logicCodes.Count > 1 && logicCodes[1].Length > 0)
{
indentBuilder.AppendLine();
indentBuilder.AppendLine();
indentBuilder.AppendLine("// Data Bindings");
indentBuilder.AppendBlock(logicCodes[1]);
}
if (logicCodes.Count > 2 && logicCodes[2].Length > 0)
{
indentBuilder.AppendLine();
indentBuilder.AppendLine();
indentBuilder.AppendLine("// Template Setting");
indentBuilder.AppendBlock(logicCodes[2]);
}
}
catch (System.Exception e)
{
}
return(indentBuilder.ToString());
}
public static void AddMethodHandlersClass(DefClass type, IndentStringBuilder sb)
{
if (!type.HasWrapType(WrapTypes.NativeDirector))
{
throw new Exception("Unexpected");
}
if (type.IsNested)
{
sb.AppendIndent("public: ");
}
else
{
sb.AppendIndent("public ");
}
sb.Append("ref class " + type.Name + " abstract sealed\n");
sb.AppendLine("{");
sb.AppendLine("public:");
sb.IncreaseIndent();
foreach (DefFunction f in type.PublicMethods)
{
if (f.IsDeclarableFunction && f.IsVirtual)
{
//if (f.Parameters.Count > 0)
//{
// AddEventArgsClass(f, sb);
//}
sb.AppendIndent("delegate static " + f.CLRTypeName + " " + f.CLRName + "Handler(");
for (int i = 0; i < f.Parameters.Count; i++)
{
DefParam param = f.Parameters[i];
sb.Append(" " + param.Type.GetCLRParamTypeName(param) + " " + param.Name);
if (i < f.Parameters.Count - 1)
{
sb.Append(",");
}
}
sb.Append(" );\n");
}
}
sb.DecreaseIndent();
sb.AppendLine("};");
sb.AppendLine();
}
public override void Add()
{
if (_t.IsInterface)
{
IndentStringBuilder tempsb = _sb;
_sb = new IndentStringBuilder();
base.Add();
string fname = _t.FullCLRName.Replace(_t.CLRName, _t.Name);
string res = _sb.ToString().Replace(_t.FullCLRName + "::", fname + "::");
_sb = tempsb;
_sb.AppendLine(res);
}
else
{
base.Add();
}
}
public IncClassProducer(Wrapper wrapper, DefClass t, IndentStringBuilder sb)
: base(wrapper, t, sb)
{
AddPreDeclarations();
if (_t.BaseClass != null)
{
AddTypeDependancy(_t.BaseClass);
}
if (AllowSubclassing)
{
_wrapper.PreClassProducers.Add(new NativeProtectedTypesProxy(_wrapper, _t, _sb));
_wrapper.PostClassProducers.Add(new NativeProtectedStaticsProxy(_wrapper, _t, _sb));
//_wrapper.PreClassProducers.Add(new IncNativeProtectedTypesProxy(_wrapper, _t, _sb));
}
}
public ClassProducer(Wrapper wrapper, DefClass t, IndentStringBuilder sb)
{
this._wrapper = wrapper;
this._t = t;
this._sb = sb;
foreach (DefClass iface in _t.GetInterfaces())
{
AddTypeDependancy(iface);
_interfaces.Add(iface);
}
if (_t.IsInterface)
{
// Declaring an overridable class for interface
_interfaces.Add(_t);
}
}
protected virtual void RenderView(IndentStringBuilder builder, T_Field f, AssignOperatorInfo?op, IndentStringBuilder rightBuilder)
{
var p = "";
if (rightBuilder != null)
{
p = rightBuilder.ToString();
}
//builder.AppendFormat(".{0}({1})", f.Name, p);
builder.AppendFormat(".{0}", f.Name);
if (op.HasValue)
{
builder.AppendFormat("{0}{1}", op.Value.GetDescription(), rightBuilder.ToString());
}
}
// CodeMapping Function
public string GlobalVariableDefine()
{
var indentBuilder = new IndentStringBuilder(2);
for (int i = 0; i < this.Mapper.NameContainer.Count; i++)
{
var kv = this.Mapper.NameContainer.ElementAt(i);
var attr = kv.Value.GetAttribute <WPFAttribute>();
indentBuilder.Append($"private {attr.Name} {kv.Key.Trim('_')};");
if (i < this.Mapper.NameContainer.Count - 1)
{
indentBuilder.AppendLine();
}
}
return(indentBuilder.ToString());
}
private void ValidateModel(object sender, EventArgs args)
{
var codeFrm = new ShowCodeFrm();
var model = ModelManager.Instance().GetModel(this.FileId.Value);
var module = ModelManager.Instance().MakeSureParseModule(model.File);
if (module == null)
{
System.Windows.Forms.MessageBox.Show("模块还未生成");
return;
}
var builder = new IndentStringBuilder();
((WorkflowDB)module).Render(builder);
codeFrm.SetText(builder.ToString());
codeFrm.Show();
}
private void Mnu_GenerateDBCode(object sender, EventArgs args)
{
var codeFrm = new ShowCodeFrm();
var model = ModelManager.Instance().GetModel(this.FileId.Value);
var module = ModelManager.Instance().MakeSureParseModule(model.File);
if (module == null)
{
System.Windows.Forms.MessageBox.Show("模块还没解析");
return;
}
var builder = new IndentStringBuilder();
//module.NameSpace = ns;
((DmModelDB)module).RenderSql(builder);
codeFrm.SetText(builder.ToString());
codeFrm.Show();
}
private void InsertDB_Transitions(WorkflowContext ctx, NodeInfo nodeInfo, Dictionary <string, Guid> nodes)
{
if (nodeInfo.Translation == null ||
nodeInfo.Translation.Statments == null)
{
return;
}
foreach (var tr in nodeInfo.Translation.Statments)
{
var transition = new Sys_Transition(Guid.NewGuid());
transition.FromNodeId = nodes[nodeInfo.Name.ToLower().Trim()];
transition.ToNodeId = nodes[tr.Target.ToLower().Trim()];
var builder = new IndentStringBuilder();
tr.Expression.Render(builder);
transition.Condition = builder.ToString();
transition.CreateTime = DateTime.Now;
ctx.Sys_Transitions.Add(transition);
}
}
// CodeMapping Function
public string PageInitialize()
{
var indentBuilder = new IndentStringBuilder(3);
for (int i = 0; i < this.Parameter.Screens.Length; i++)
{
/* Ex
* var p0 = GenResourceManager.LoadXaml("Screen1") as DeXignPage;
* dw.Add(p0);
*/
indentBuilder.AppendLine($"var p{i} = GenResourceManager.LoadXaml(\"{this.Parameter.Screens[i].GetPageName()}.xaml\") as DeXignPage;");
indentBuilder.AppendLine($"dw.Add(p{i});");
}
/* Ex
* dw.SetPage(p0);
*/
indentBuilder.Append($"dw.SetPage(p0);");
return(indentBuilder.ToString());
}
// CodeMapping Function
public string CallbackHandlers()
{
if (logicCodes.Count > 1)
{
var indentBuilder = new IndentStringBuilder(2);
for (int i = 1; i < logicCodes.Count; i++)
{
indentBuilder.AppendBlock(logicCodes[i]);
if (i < logicCodes.Count - 1)
{
indentBuilder.AppendLine();
indentBuilder.AppendLine();
}
}
return(indentBuilder.ToString());
}
return(null);
}
protected override void RenderView(IndentStringBuilder builder, T_Field f, AssignOperatorInfo?op, IndentStringBuilder opValue)
{
//base.RenderView(builder, f, rightBuilder);
if (opValue != null && opValue.Length > 0)
{
builder.AppendFormat(".{0}({1})", f.Name, opValue.ToString());
}
else
{
if (f.Type is T_EventType)
{
builder.AppendFormat(".{0}", f.Name);
}
else if (f.Type is T_ValidateType)
{
builder.AppendFormat(".{0}", f.Name);
}
else
{
builder.AppendFormat(".{0}()", f.Name);
}
}
}
public string GetErrorMessage(int tabs = 0)
{
var errorMessage = new IndentStringBuilder
{
Indent = tabs
};
var debugText = GetDebugErrorMessage();
errorMessage.WriteLine(debugText);
if (InnerErrors.Length > 0)
{
errorMessage.Indent++;
foreach (var innerError in InnerErrors)
{
errorMessage.WriteLine(innerError.GetErrorMessage(tabs + 2));
}
errorMessage.Indent--;
}
return(errorMessage.ToString());
}
public IncReadOnlyStructClassProducer(Wrapper wrapper, DefClass t, IndentStringBuilder sb)
: base(wrapper, t, sb)
{
}
public IncNonOverridableClassProducer(Wrapper wrapper, DefClass t, IndentStringBuilder sb)
: base(wrapper, t, sb)
{
}
public IncCLRHandleClassProducer(Wrapper wrapper, DefClass t, IndentStringBuilder sb)
: base(wrapper, t, sb)
{
}
public IncNativeDirectorClassProducer(Wrapper wrapper, DefClass t, IndentStringBuilder sb)
: base(wrapper, t, sb)
{
}
public CppSubclassingClassProducer(Wrapper wrapper, DefClass t, IndentStringBuilder sb, DefClass[] additionalInterfaces)
: base(wrapper, t, sb)
{
this._additionalInterfaces = additionalInterfaces;
}
public static void AddNativeProxyMethodBody(DefFunction f, string managedTarget, IndentStringBuilder sb)
{
string managedCall;
string fullPostConv = null;
if (f.IsGetProperty)
{
sb.AppendLine(f.CLRTypeName + " mp_return = " + managedTarget + "->" + f.CLRName + ";");
managedCall = "mp_return";
}
else if (f.IsSetProperty)
{
DefParam param = f.Parameters[0];
managedCall = managedTarget + "->" + f.CLRName + " = " + param.Type.GetNativeCallConversion(param.Name, param);
}
else
{
string pre, post, conv;
foreach (DefParam param in f.Parameters)
{
param.Type.GetNativeParamConversion(param, out pre, out conv, out post);
if (!String.IsNullOrEmpty(pre))
{
sb.AppendLine(pre);
}
if (!String.IsNullOrEmpty(post))
{
fullPostConv += post + "\n";
}
}
bool explicitCast = f.HasAttribute <ExplicitCastingForParamsAttribute>();
if (!f.IsVoid)
{
sb.AppendIndent(f.CLRTypeName + " mp_return = " + managedTarget + "->" + f.CLRName + "(");
for (int i = 0; i < f.Parameters.Count; i++)
{
DefParam param = f.Parameters[i];
param.Type.GetNativeParamConversion(param, out pre, out conv, out post);
sb.Append(" ");
if (explicitCast)
{
sb.Append("(" + param.CLRTypeName + ")");
}
sb.Append(conv);
if (i < f.Parameters.Count - 1)
{
sb.Append(",");
}
}
sb.Append(" );\n");
managedCall = "mp_return";
if (!String.IsNullOrEmpty(fullPostConv))
{
sb.AppendLine(fullPostConv);
}
}
else
{
managedCall = managedTarget + "->" + f.CLRName + "(";
for (int i = 0; i < f.Parameters.Count; i++)
{
DefParam param = f.Parameters[i];
param.Type.GetNativeParamConversion(param, out pre, out conv, out post);
managedCall += " ";
if (explicitCast)
{
managedCall += "(" + param.CLRTypeName + ")";
}
managedCall += conv;
if (i < f.Parameters.Count - 1)
{
managedCall += ",";
}
}
managedCall += " )";
}
}
if (!f.IsVoid)
{
if (f.Type is IDefString)
{
sb.AppendLine("SET_NATIVE_STRING( Mogre::Implementation::cachedReturnString, " + managedCall + " )");
sb.AppendLine("return Mogre::Implementation::cachedReturnString;");
}
else
{
string returnExpr;
string newname, expr, postcall;
DefParam param = new DefParam(f, managedCall);
expr = f.Type.GetPreCallParamConversion(param, out newname);
postcall = f.Type.GetPostCallParamConversionCleanup(param);
if (!String.IsNullOrEmpty(expr))
{
sb.AppendLine(expr);
if (String.IsNullOrEmpty(postcall))
{
returnExpr = newname;
}
else
{
throw new Exception("Unexpected");
}
}
else
{
returnExpr = newname;
}
if (IsCachedFunction(f))
{
sb.AppendLine("STATIC_ASSERT( sizeof(" + f.Type.FullNativeName + ") <= CACHED_RETURN_SIZE )");
sb.AppendLine("memcpy( Mogre::Implementation::cachedReturn, &" + returnExpr + ", sizeof(" + f.Type.FullNativeName + ") );");
sb.AppendLine("return *reinterpret_cast<" + f.Type.FullNativeName + "*>(Mogre::Implementation::cachedReturn);");
}
else
{
sb.AppendLine("return " + returnExpr + ";");
}
}
}
else
{
sb.AppendLine(managedCall + ";");
if (!String.IsNullOrEmpty(fullPostConv))
{
sb.AppendLine(fullPostConv);
}
}
}
public CppOverridableClassProducer(Wrapper wrapper, DefClass t, IndentStringBuilder sb)
: base(wrapper, t, sb)
{
_wrapper.PostClassProducers.Add(new CppNativeProxyClassProducer(_wrapper, _t, _sb));
}
public CppNativeProxyClassProducer(Wrapper wrapper, DefClass t, IndentStringBuilder sb)
: base(wrapper, t, sb)
{
}
protected override void RenderView(IndentStringBuilder builder, T_Field f, AssignOperatorInfo?op, IndentStringBuilder opValue)
{
if (op.HasValue)
{
builder.AppendFormat(".{0} {1} {2}", f.Name, op.GetDescription(), opValue);
}
else
{
builder.AppendFormat(".{0}", f.Name);
}
}
public CppPlainWrapperClassProducer(Wrapper wrapper, DefClass t, IndentStringBuilder sb)
: base(wrapper, t, sb)
{
}
public virtual T_Type RenderView(IndentStringBuilder builder, List <string> call_stack, IndentStringBuilder paras, AssignOperatorInfo?op, IndentStringBuilder opValue,
PostfixPartType?postfixPartType, IndentStringBuilder func_paras, IndentStringBuilder index_para)
{
//if(call_stack == null)
var member = call_stack[0];
AssignOperatorInfo? op2 = null;
IndentStringBuilder opValue2 = null;
if (call_stack.Count == 1)
{
op2 = op;
opValue2 = opValue;
}
T_Type nextType = null;
if (!this.IsInstance)
{
foreach (var f in this.Static_Fields)
{
if (f.Name == member)
{
this.RenderView(builder, f, op2, opValue2);
nextType = f.Type;
break;
}
}
if (nextType == null)
{
foreach (var m in this.Static_Methods)
{
if (m.Name == member)
{
this.RenderView(builder, m, paras);
nextType = m.Type;
break;
}
}
}
}
else
{
foreach (var f in this.Fields)
{
if (f.Name == member)
{
this.RenderView(builder, f, op2, opValue2);
nextType = f.Type;
break;
}
}
if (nextType == null)
{
foreach (var m in this.Methods)
{
if (m.Name == member)
{
this.RenderView(builder, m, paras);
nextType = m.Type;
break;
}
}
}
}
if (call_stack.Count > 1)
{
//var call_stack2 = new List<string>();
//call_stack2.AddRange(call_stack);
//call_stack2.RemoveAt(0);
return(nextType.RenderView(builder, call_stack.SubList(1), paras, op, opValue, postfixPartType, func_paras, index_para));
}
return(nextType);
}
