internal static void generateFiles(Project p, PGOptions opts1, ProjectItemGroupElement pige)
{
Dictionary<string, string> tmp = new Dictionary<string, string>();
WinDataProvider wdp = new WinDataProvider(WIN_NAME, opts1.projectNamespace, opts1.xamlType == XamlWindowType.RegularWindow);
AppDataProvider apd = new AppDataProvider(wdp.fileName, opts1.projectNamespace);
HomeDataProvider hdp = null;
string tmp2;
XamlFileGenerator.generateFile(apd, opts1);
XamlFileGenerator.generateFile(wdp, opts1);
if (opts1.xamlType == XamlWindowType.NavigationWindow) {
hdp = new HomeDataProvider(wdp.homePage, opts1.projectNamespace);
XamlFileGenerator.generateFile(hdp, opts1);
generatePageAndModel(pige, hdp);
}
if (!string.IsNullOrEmpty(tmp2 = wdp.viewModelName) && File.Exists(tmp2)) {
generateCompile(pige, tmp2);
}
generateApp(pige, apd);
generatePage(pige, wdp);
if (opts1.xamlPages.Count > 0) {
GeneralPage gp;
foreach (string aPageName in opts1.xamlPages) {
gp = new GeneralPage(aPageName, opts1.projectNamespace);
XamlFileGenerator.generateFile(gp, opts1);
generatePageAndModel(pige, gp);
}
}
}
internal static void generateMainFiles(Project p, PGOptions opts, ProjectItemGroupElement pige2)
{
switch (opts.projectType) {
case ProjectType.WindowsForm: generateForms(pige2, opts); break;
case ProjectType.ConsoleApp: generateMain(pige2, opts); break;
case ProjectType.ClassLibrary: generateLib(pige2, opts); break;
case ProjectType.XamlApp: generateXaml(pige2, opts); break;
default:
throw new InvalidOperationException("unhandled " + opts.projectType.GetType().Name + ": " + opts.projectType);
}
}
/// <summary>do it.</summary>
/// <param name="ixfgd"></param>
/// <param name="opts"></param>
internal static void generateFile(IXamlFileGenerationData ixfgd, PGOptions opts)
{
StringBuilder sb;
string fname, ename, ns, modelName, ext;
if (ixfgd == null)
throw new ArgumentNullException("ixfgd", "generation-object is null!");
if (string.IsNullOrEmpty(ename = ixfgd.elementName))
throw new ArgumentNullException("ename", "element-name is null!");
if (string.IsNullOrEmpty(fname = ixfgd.fileName))
if (string.IsNullOrEmpty(fname))
throw new ArgumentNullException("fname", "file-name is null!");
if (ixfgd.generationType == GenFileType.View)
ixfgd.xamlName = Path.Combine("Source\\Views\\", fname + ".xaml");
else
ixfgd.xamlName = fname + ".xaml";
ns = ixfgd.nameSpace;
sb = new StringBuilder();
if (DefaultProjectGenerator.dontOverwriteFile(ixfgd.xamlName))
return;
using (StringWriter sw = new StringWriter(sb)) {
using (XmlWriter xw = XmlWriter.Create(sw, settings)) {
xw.WriteStartElement(ename, NS_DEFAULT);
xw.WriteAttributeString("xmlns", "x", null, NS_X);
xw.WriteAttributeString("xmlns", "d", null, NS_BLEND);
if (!string.IsNullOrEmpty(ns))
xw.WriteAttributeString("xmlns", "local", null, "clr-namespace:" + ns);
ixfgd.populateElementAttributes(xw);
ixfgd.populateElement(xw);
xw.WriteEndDocument();
}
}
if (showFileContent)
Debug.Print(sb.ToString());
createDirIfNeeded(ixfgd.xamlName);
File.WriteAllText(ixfgd.xamlName, sb.ToString());
ext = opts.provider.FileExtension;
modelName = fname + "ViewModel";
if (ixfgd.generationType == GenFileType.View) {
ixfgd.codeBehindName = Path.Combine("Source\\Views", fname + ".xaml." + ext);
ixfgd.viewModelName = Path.Combine("Source\\Models\\", modelName + "." + ext);
} else {
ixfgd.codeBehindName = fname + ".xaml." + ext;
ixfgd.viewModelName = modelName + "." + ext;
}
createMainFile(ixfgd.codeBehindName, ns, fname, ename, modelName, ixfgd.generateViewModel, ixfgd, opts);
if (ixfgd.generateViewModel)
createModelfile(ixfgd.viewModelName, ns, modelName, ixfgd, opts);
}
public static void createAsmInfoFile(string aFile, string aName, string szVersion, PGOptions opts)
{
string tmp, dir;
if (Path.IsPathRooted(aFile))
tmp = aFile;
else {
tmp = Path.Combine(Directory.GetCurrentDirectory(), aFile);
}
if (DefaultProjectGenerator.dontOverwriteFile(tmp))
return;
if (!Directory.Exists(dir = Path.GetDirectoryName(tmp)))
Directory.CreateDirectory(dir);
// if ()
Trace.WriteLine("here");
using (TextWriter tw = new StreamWriter(tmp)) {
opts.provider.GenerateCodeFromCompileUnit(createCompileUnit(aName, szVersion, opts), tw, opts.options);
}
}
internal static void generate(PGOptions opts, bool rebuild)
{
Project p = null;
bool generate = false;
if (File.Exists(opts.projectFileName))
try {
p = new Project(opts.projectFileName);
} catch (Exception ex) {
Console.Error.WriteLine("failed to open " + opts.projectFileName + " [" + ex.Message + "]");
}
if (p == null) {
p = new Project();
generate = true;
}
if (rebuild) {
p.Xml.RemoveAllChildren();
generate = true;
}
doStuff(p, opts, generate);
p.Save(opts.projectFileName);
Debug.Print("saved: " + opts.projectFileName);
}
static void doStuff(Project p, PGOptions opts, bool generate)
{
string asmName = opts.assemblyName;
p.Xml.DefaultTargets = "Build";
addDefaultProperty(p, opts.projectType, opts.projectNamespace, opts.assemblyName);
if (opts.projectType == ProjectType.XamlApp)
p.Xml.AddImport("$(MSBuildExtensionsPath)\\$(MSBuildToolsVersion)\\Microsoft.Common.props");
addPropertyGroup(p, true, opts.assemblyName, opts.projectType);
addPropertyGroup(p, false, opts.assemblyName, opts.projectType);
if (opts.projectType == ProjectType.XamlApp) {
var vrefs = p.Xml.AddItemGroup();
vrefs.Label = "references_here";
// add refs here.
string[] refNames = new string[] {
"System",
"System.Core",
"System.Data",
"System.Data.DataSetExtensions",
"System.Xml",
"System.Xml.Linq",
"System.Xaml",
"System.Net.Http",
"Microsoft.CSharp",
"WindowsBase",
"PresentationCore",
"PresentationFramework",
};
foreach (string refName in refNames)
vrefs.AddItem("Reference", refName);
IDictionary<string, string> blah = new Dictionary<string, string>();
blah.Add("RequiredTargetFramework", "4.0");
vrefs.AddItem("Reference", "System.Xaml", blah);
}
if (opts.generateCode) {
generateCommonFiles(p, opts);
if (!opts.simplyProject)
generateFiles(p, opts);
}
if (opts.projectType == ProjectType.XamlApp) {
} else {
var vvv = p.Xml.AddItemGroup();
vvv.Label = "References";
vvv.AddItem("Reference", "System");
if (!opts.simplyProject)
vvv.AddItem("Reference", "System.Data");
if (opts.projectType == ProjectType.WindowsForm) {
vvv.AddItem("Reference", "System.Windows.Forms");
vvv.AddItem("Reference", "System.Drawing");
}
if (opts.doDevExpress) {
vvv.AddItem("Reference", "DevExpress.BonusSkins.v12.2");
vvv.AddItem("Reference", "DevExpress.Utils.v12.2");
vvv.AddItem("Reference", "DevExpress.XtraBars.v12.2");
vvv.AddItem("Reference", "DevExpress.XtraEditors.v12.2");
vvv.AddItem("Reference", "DevExpress.Data.v12.2");
}
if (opts.usePhibroStyle)
generatePhibroSection(p);
}
var p3 = p.Xml.AddImport("$(MSBuildToolsPath)\\Microsoft.CSharp.targets");
if (opts.usePhibroStyle) {
// G:\MIS\icts\MSBuild\2010
p.Xml.AddImport("$(MSPEIRules)\\Phibro.CopyBundle.Targets");
p.Xml.AddImport("$(MSPEIRules)\\Phibro.CopyToShared.Targets");
p.Xml.AddImport("$(MSPEIRules)\\Phibro.LightWeightAssembly.Targets");
}
if (opts.projectType != ProjectType.XamlApp) {
var v0 = p.Xml.AddPropertyGroup();
v0.AddProperty("StartupObject", string.Empty);
}
if (opts.usePhibroStyle)
generatePhibroRules(p);
}
static void createAppCfgFile(string filename, PGOptions opts)
{
XmlWriterSettings xws;
if (File.Exists(filename))
File.Delete(filename);
xws = new XmlWriterSettings();
xws.Indent = true;
xws.IndentChars = new string(' ', 4);
xws.Encoding = Encoding.ASCII;
xws.Encoding = Encoding.UTF8;
if (dontOverwriteFile(filename))
return;
using (XmlWriter xw = XmlWriter.Create(filename, xws)) {
xw.WriteStartDocument();
xw.WriteStartElement("configuration");
xw.WriteStartElement("startup");
xw.WriteStartElement("supportedRuntime");
xw.WriteAttributeString("assemblyVersion", TARGET_40);
xw.WriteAttributeString("sku", ".NETFramework,Version=" + (opts.projectType == ProjectType.XamlApp ? TARGET_45 : TARGET_452));
if (opts.projectType == ProjectType.XamlApp)
xw.WriteAttributeString("version", TARGET_40);
xw.WriteEndElement();
xw.WriteEndElement();
if (opts.usePhibroStyle) {
xw.WriteStartElement("runtime");
xw.WriteStartElement("assemblyBinding", "urn:schemas-microsoft-com:asm.targetElement");
xw.WriteStartElement("probing");
xw.WriteAttributeString("privatePath", "assemblies\\" + PEI_PROVIDER_NAME + "\\" + PEI_COMMON_DEFAULT_VERSION);
xw.WriteEndElement();
xw.WriteEndElement();
xw.WriteEndElement();
}
xw.WriteEndElement();
xw.WriteEndDocument();
}
}
/// <summary>entry-point</summary>
/// <remarks>remarks</remarks>
static void Main(string[] args)
{
int exitCode = 0;
PGOptions opts = new PGOptions();
string anArg;
int nargs;
int len;
string atype;
bool fixNS = false;
bool showHelp = false;
#if DEBUG
Debug.Listeners.Add(new TextWriterTraceListener(Console.Out, PGOptions.LISTENER_NAME));
#endif
#if TRACE
Trace.Listeners.Add(new TextWriterTraceListener(Console.Out, PGOptions.LISTENER_NAME_2));
#endif
if ((nargs = args.Length) > 0)
for (int i = 0; i < nargs; i++) {
anArg = args[i];
if ((len = anArg.Length) >= 2) {
if (anArg[0] == '-' || anArg[0] == '/') {
switch (anArg[1]) {
case 'f':
if (len > 2) opts.assemblyName = anArg.Substring(2).Trim();
else { opts.assemblyName = args[i + 1]; i++; }
opts.calculateNamespace();
break;
case 'n':
if (len > 2) opts.setNamespace(anArg.Substring(2).Trim());
else { opts.setNamespace(args[i + 1]); i++; }
fixNS = false;
break;
case 'v':
if (len > 2) opts.assemblyVersion = anArg.Substring(2).Trim();
else { opts.assemblyVersion = args[i + 1]; i++; }
break;
case 't':
if (len > 2) atype = anArg.Substring(2).Trim();
else { atype = args[i + 1]; i++; }
switch (atype) {
case "c": opts.projectType = ProjectType.ConsoleApp; break;
case "d": opts.projectType = ProjectType.ClassLibrary; break;
case "w": opts.projectType = ProjectType.WindowsForm; break;
case "x": opts.projectType = ProjectType.XamlApp; if (opts.xamlType == XamlWindowType.NONE) opts.xamlType = XamlWindowType.RegularWindow; break;
default: Console.Error.WriteLine("unknown project-projectType '" + atype + "'!"); break;
}
break;
case 'x':
if (len > 2) atype = anArg.Substring(2).Trim();
else { atype = args[i + 1]; i++; }
switch (atype) {
case "f":
if (len > 3) { atype = anArg.Substring(2).Trim(); opts.addXmlPage(atype); } else { opts.addXmlPage(atype = args[i + 1]); i++; }
break;
case "n": opts.xamlType = XamlWindowType.NavigationWindow; break;
case "w": opts.xamlType = XamlWindowType.RegularWindow; break;
default: Console.Error.WriteLine("unknown xaml-type '" + atype + "'!"); opts.xamlType = XamlWindowType.RegularWindow; break;
}
break;
case 'b': opts.isVB = true; break;
case 'C': opts.isCPPProject = true; break;
case 'D': opts.doDevExpress = true; break;
case 'g': opts.generateCode = true; break;
case 'p': opts.usePhibroStyle = true; break;
case 's': opts.simplyProject = true; break;
case 'h': showHelp = true; break;
case '?': showHelp = true; break;
}
}
}
}
// -C C++ project
// -D devexpress
// -g generate-code
// -p phibro-style
// -s simplyProject
if (opts.simplyProject)
opts.usePhibroStyle = false;
if (showHelp)
showUserHelp(Console.Error, Assembly.GetEntryAssembly());
else {
opts.projectFileName = opts.assemblyName + (opts.isCPPProject ? ".vcxproj" : (opts.isVB ? ".vbproj" : ".csproj"));
if (fixNS)
opts.calculateNamespace();
try {
opts.createProvider();
if (opts.isCPPProject)
CProjectGenerator.generate(opts);
else
DefaultProjectGenerator.generate(opts, true);
} catch (Exception ex) {
Console.Error.WriteLine("[ERROR] " + ex.Message);
Trace.WriteLine("[TRACE] " + ex.Message);
Console.Error.Write("awaiting <ENTER>:");
Console.ReadLine();
exitCode = 1;
}
}
#if DEBUG
Debug.Flush();
Debug.Listeners.Remove(PGOptions.LISTENER_NAME);
#endif
#if TRACE
Trace.Flush();
Trace.Listeners.Remove(PGOptions.LISTENER_NAME_2);
#endif
Environment.Exit(exitCode);
}
static void createMainFile(string outCSName, string nameSpace, string fname, string ename, string modelName, bool generateViewModel, IXamlFileGenerationData ixfgd, PGOptions opts)
{
CodeCompileUnit ccu = null;
CodeNamespace ns0, ns;
CodeTypeDeclaration ctd;
CodeConstructor cc = null;
CodeMemberField f;
CodeFieldReferenceExpression fr = null;
ccu = new CodeCompileUnit();
ccu.Namespaces.Add(ns = ns0 = new CodeNamespace());
if (!string.IsNullOrEmpty(nameSpace))
ccu.Namespaces.Add(ns = new CodeNamespace(nameSpace));
ixfgd.addImports(ns0);
ns.Types.Add(ctd = new CodeTypeDeclaration(fname));
if (opts.provider.Supports(GeneratorSupport.PartialTypes))
ctd.IsPartial = true;
ctd.BaseTypes.Add(ename);
if (generateViewModel) {
fr = new CodeFieldReferenceExpression(null, "_vm");
ctd.Members.Add(f = new CodeMemberField(modelName, fr.FieldName));
f.Attributes = 0;
ctd.Members.Add(cc = new CodeConstructor());
cc.Attributes = MemberAttributes.Public;
cc.Statements.Add(
new CodeAssignStatement(
new CodePropertyReferenceExpression(ceThis, "DataContext"),
new CodeBinaryOperatorExpression(fr, CodeBinaryOperatorType.Assign, new CodeObjectCreateExpression(modelName))));
cc.Statements.Add(
new CodeExpressionStatement(
new CodeMethodInvokeExpression(null, "InitializeComponent", new CodeExpression[0])));
}
ixfgd.generateCode(ns, ctd, cc);
outputFile(ccu, ns, outCSName, opts);
}
static void generateXaml(ProjectItemGroupElement pige2, PGOptions opts)
{
Trace.WriteLine("do something for XAML");
}
static void generateMain(ProjectItemGroupElement pige2, PGOptions opts)
{
string fname, tmp, relName;
fname = Path.Combine(Directory.GetCurrentDirectory(), relName = "Source\\adriver." + opts.provider.FileExtension);
if (DefaultProjectGenerator.dontOverwriteFile(fname))
return;
if (!Directory.Exists(tmp = Path.GetDirectoryName(fname)))
Directory.CreateDirectory(tmp);
using (TextWriter tw = new StreamWriter(fname)) {
opts.provider.GenerateCodeFromCompileUnit(createCCUMain(opts.projectNamespace, opts.assemblyName, false), tw, opts.options);
}
pige2.AddItem("Compile", relName);
}
static void generateLib(ProjectItemGroupElement pige2, PGOptions opts)
{
string fname, tmp, relName, className;
className = opts.assemblyName.Substring(0, 1).ToUpper() + opts.assemblyName.Substring(1) + "Class";
fname = Path.Combine(Directory.GetCurrentDirectory(), relName = "Source\\" + className + "." + opts.provider.FileExtension);
if (!Directory.Exists(tmp = Path.GetDirectoryName(fname)))
Directory.CreateDirectory(tmp);
if (DefaultProjectGenerator.dontOverwriteFile(fname))
return;
using (TextWriter tw = new StreamWriter(fname)) {
opts.provider.GenerateCodeFromCompileUnit(createClass(opts.projectNamespace, className), tw, opts.options);
}
if (pige2 != null)
pige2.AddItem("Compile", relName);
}
static void generateForms(ProjectItemGroupElement pige2, PGOptions opts)
{
string fname, tmp, relName, relName2;
string asmName = opts.assemblyName, ext;
fname = Path.Combine(Directory.GetCurrentDirectory(), relName = "Source\\UI\\" + asmName + "Form." + (ext = opts.provider.FileExtension));
if (DefaultProjectGenerator.dontOverwriteFile(fname))
return;
if (!Directory.Exists(tmp = Path.GetDirectoryName(fname)))
Directory.CreateDirectory(tmp);
using (TextWriter tw = new StreamWriter(fname)) {
opts.provider.GenerateCodeFromCompileUnit(createCCUForm(opts.projectNamespace, asmName, opts.doDevExpress), tw, opts.options);
}
fname = Path.Combine(Directory.GetCurrentDirectory(), relName2 = "Source\\UI\\" + asmName + "Form.Designer." + ext);
using (TextWriter tw = new StreamWriter(fname)) {
opts.provider.GenerateCodeFromCompileUnit(createCCUDesigner(opts.projectNamespace, asmName, opts.doDevExpress), tw, opts.options);
}
if (pige2 != null) {
pige2.AddItem("Compile", relName);
var v2 = pige2.AddItem("Compile", relName2);
v2.AddMetadata("DependentUpon", Path.GetFileName(relName));
}
}
static void generateCommonFiles(Project p, PGOptions opts)
{
ProjectItemGroupElement pige = null;
string asmInfoName;
if (createConfig && !opts.simplyProject) {
createAppCfgFile(APP_CFG, opts);
pige = createItemGroup(p, "None");
pige.AddItem("None", APP_CFG);
}
if (createAsmInfo) {
asmInfoName = PROPERTY_DIR + "\\" + "AssemblyInfo." + opts.provider.FileExtension;
CSGenerator.createAsmInfoFile(
Path.Combine(Directory.GetCurrentDirectory(), asmInfoName),
opts.assemblyName, opts.assemblyVersion, opts);
var avar = createItemGroup(p, "AssemblyInfo");
avar.AddItem("Compile", asmInfoName);
}
}
static void createModelfile(string outModelName, string nameSpace, string modelName, IXamlFileGenerationData ixfgd, PGOptions opts)
{
CodeCompileUnit ccu = null;
CodeNamespace ns0, ns;
CodeTypeDeclaration ctd;
CodeConstructor cc;
CodeMemberEvent cme0;
CodeMemberMethod cmm0, cmm3;
CodeEventReferenceExpression cere;
ccu = new CodeCompileUnit();
ccu.Namespaces.Add(ns = ns0 = new CodeNamespace());
if (!string.IsNullOrEmpty(nameSpace))
ccu.Namespaces.Add(ns = new CodeNamespace(nameSpace));
ns0.Imports.Add(new CodeNamespaceImport("System.ComponentModel"));
ns0.Imports.Add(new CodeNamespaceImport("System.Reflection"));
ns.Types.Add(ctd = new CodeTypeDeclaration(modelName));
if (opts.provider.Supports(GeneratorSupport.PartialTypes))
ctd.IsPartial = true;
ctd.BaseTypes.Add("INotifyPropertyChanged");
cere = new CodeEventReferenceExpression(ceThis, "PropertyChanged");
ctd.Members.AddRange(new CodeTypeMember[] {
cme0=createEvent(cere),
cc=new CodeConstructor(),
cmm0=createMethod1("firePropertyChanged",cere,new CodeArgumentReferenceExpression ("propertyName")),
cmm3=createMethod2("firePropertyChanged",cere,new CodeArgumentReferenceExpression ("mb"))
}); ;
cc.Attributes = MemberAttributes.Public;
ixfgd.generateModelCode(ns, ctd);
outputFile(ccu, ns, outModelName, opts);
}
static void generateFiles(Project p, PGOptions opts)
{
ProjectItemGroupElement pige;
pige = p.Xml.AddItemGroup();
pige.Label = "IDK";
if (opts.projectType == ProjectType.XamlApp) {
XamlGenerator.generateFiles(p, opts, pige);
} else {
CSGenerator.generateMainFiles(p, opts, pige);
}
}
static void outputFile(CodeCompileUnit ccu, CodeNamespace ns, string outModelName, PGOptions opts)
{
StringBuilder sb;
if (DefaultProjectGenerator.dontOverwriteFile(outModelName))
return;
using (TextWriter sw = new StringWriter(sb = new StringBuilder())) {
if (ccu != null)
opts.provider.GenerateCodeFromCompileUnit(ccu, sw, opts.options);
else
opts.provider.GenerateCodeFromNamespace(ns, sw, opts.options);
}
createDirIfNeeded(outModelName);
File.WriteAllText(outModelName, sb.ToString());
if (showFileContent)
Debug.Print(sb.ToString());
sb.Clear();
sb = null;
}
internal static void generate(PGOptions opts)
{
// Logger.log(MethodBase.GetCurrentMethod());
generate(opts.projectFileName, opts.assemblyVersion, opts.assemblyVersion, opts.projectNamespace, opts.projectType);
}
static CodeCompileUnit createCompileUnit(string aName, string szVersion, PGOptions opts)
{
var v = new CodeSnippetCompileUnit();
StringBuilder sb;
StringWriter sw = new StringWriter(sb = new StringBuilder());
CodeNamespace ns = new CodeNamespace();
ns.Imports.AddRange(
new CodeNamespaceImport[] {
new CodeNamespaceImport ("System.Reflection"),
new CodeNamespaceImport ("System.Runtime.InteropServices"),
});
opts.provider.GenerateCodeFromNamespace(ns, sw, opts.options);
string companyName = Properties.Settings.Default.CustomCompany;
var v2 = new CodeSnippetTypeMember(
string.Join("\n",
"[assembly:AssemblyTitle(\"" + aName + "\")]",
"[assembly:AssemblyProduct(\"" + aName + "\")]",
"[assembly:AssemblyDescription(\"description of " + aName + ".\")]",
"[assembly:AssemblyCompany(\"" + companyName + "\")]",
"[assembly:AssemblyCopyright(\"Copyright © " + DateTime.Now.Year.ToString() + ", " + companyName + "\")]",
"#if DEBUG",
"[assembly:AssemblyConfiguration(\"Debug assemblyVersion\")]",
"#else",
"[assembly:AssemblyConfiguration(\"Release assemblyVersion\")]",
"#endif",
"[assembly:ComVisible(false)]",
null,
"[assembly:AssemblyVersion(\"" + szVersion + "\")]",
"[assembly:AssemblyFileVersion(\"" + szVersion + "\")]",
"[assembly:AssemblyInformationalVersion(\"" + szVersion + "\")]"));
opts.provider.GenerateCodeFromMember(v2, sw, opts.options);
sw.Flush();
sw.Close();
sw.Dispose();
sw = null;
v.Value = sb.ToString();
return v;
}
