public ValidationPattern(ITaskItem item, TaskLoggingHelper log)
{
string idRegex = item.GetMetadata("IdentityRegex");
if (string.IsNullOrEmpty(idRegex))
{
// Temporarily support reading the regex from the Include/ItemSpec for backwards compatibility
// when the IdentityRegex isn't specified. This can be removed once all consumers are using IdentityRegex.
idRegex = item.ItemSpec;
}
_idPattern = new Regex(idRegex);
_expectedVersion = item.GetMetadata("ExpectedVersion");
_expectedPrerelease = item.GetMetadata("ExpectedPrerelease");
_log = log;
if (string.IsNullOrWhiteSpace(_expectedVersion))
{
if (string.IsNullOrWhiteSpace(_expectedPrerelease))
{
_log.LogError(
"Can't find ExpectedVersion or ExpectedPrerelease metadata on item {0}",
item.ItemSpec);
}
}
else if (!string.IsNullOrWhiteSpace(_expectedPrerelease))
{
_log.LogError(
"Both ExpectedVersion and ExpectedPrerelease metadata found on item {0}, but only one permitted",
item.ItemSpec);
}
}
public bool Parse(string antBuildPath, string antBuildType, TaskLoggingHelper log, bool outputInQuotes)
{
// Ant build directory check
if (Directory.Exists(antBuildPath) == false)
{
log.LogError("Ant Build Path '" + antBuildPath + "' does not exist");
return false;
}
// Check that the build.xml exists
string buildXml = Path.GetFullPath(antBuildPath + "\\build.xml");
if (File.Exists(buildXml) == false)
{
log.LogError("build.xml '" + buildXml + "' does not exist");
return false;
}
// Check that the AndroidManifest.xml exists
string manifestXml = Path.GetFullPath(antBuildPath + "\\AndroidManifest.xml");
if (File.Exists(manifestXml) == false)
{
log.LogError("AndroidManifest.xml '" + manifestXml + "' does not exist");
return false;
}
// Parse the xml to grab the finished apk path
if (ParseBuildXml(buildXml))
{
if (antBuildType.ToLower() == "debug")
{
OutputFile = Path.GetFullPath(antBuildPath + "\\" + BUILD_BIN_PATH + "\\" + ApkName + "-debug.apk");
}
else
{
OutputFile = Path.GetFullPath(antBuildPath + "\\" + BUILD_BIN_PATH + "\\" + ApkName + "-release.apk");
}
if ( outputInQuotes )
{
OutputFile = "\"" + OutputFile + "\"";
}
}
else
{
// Parse failed, oh dear.
log.LogError("Failed parsing '" + buildXml + "'");
return false;
}
if (ParseAndroidManifestXml(manifestXml) == false)
{
// Parse failed, oh dear.
log.LogError("Failed parsing '" + manifestXml + "'");
return false;
}
return true;
}
public async Task <bool> PushToFeed(IEnumerable <string> items, bool allowOverwrite = false)
{
if (IsSanityChecked(items))
{
if (CancellationToken.IsCancellationRequested)
{
Log.LogError("Task PushToFeed cancelled");
CancellationToken.ThrowIfCancellationRequested();
}
await PushItemsToFeedAsync(items, allowOverwrite);
}
return(!Log.HasLoggedErrors);
}
public IEnumerable<string> GetAppBuildOrder(string sourceDirectory, string startAppPath, string uniqueSourceDirectoryPath, TaskLoggingHelper log)
{
_log = log;
_uniqueSourceDirectoryPath = uniqueSourceDirectoryPath;
var sourceDirectoryPath = sourceDirectory.Trim('\'', '"');
var appList = GetAppListWithReferences(sourceDirectoryPath);
var appPath = startAppPath.Trim('\'', '"');
var startApps = appPath.Split('|').ToList();
foreach (var app in startApps)
{
if (!string.IsNullOrEmpty(app))
{
_log.LogMessage("Application path: {0}", app);
var startApp = appList[Path.GetFullPath(app.ToUpper().Replace(sourceDirectoryPath.ToUpper(), _uniqueSourceDirectoryPath)).ToUpper()];
if (startApp == null)
{
log.LogError("Application {0} could not be found.", app);
}
else
{
_orderedAppList.Add(Path.GetFullPath(app.ToUpper().Replace(sourceDirectoryPath.ToUpper(), _uniqueSourceDirectoryPath)).ToUpper());
LoopReferences(startApp, appList);
}
}
}
_orderedAppList.ForEach(a => _log.LogMessage(a));
return _orderedAppList;
}
private void Log(ILogMessage message, LogLevel level)
{
switch (level)
{
case LogLevel.Error:
_log.LogError(message.Message);
break;
case LogLevel.Warning:
_log.LogWarning(message.Message);
break;
case LogLevel.Minimal:
_log.LogMessage(MessageImportance.Low, message.Message);
break;
case LogLevel.Information:
_log.LogMessage(MessageImportance.Normal, message.Message);
break;
case LogLevel.Debug:
case LogLevel.Verbose:
default:
_log.LogMessage(MessageImportance.High, message.Message);
break;
}
return;
}
public async Task <bool> PushToFeed(IEnumerable <string> items, string relativePath, bool allowOverwrite = false)
{
if (feed.IsSanityChecked(items))
{
if (CancellationToken.IsCancellationRequested)
{
Log.LogError("Task PushToFeed cancelled");
CancellationToken.ThrowIfCancellationRequested();
}
using (var clientThrottle = new SemaphoreSlim(this.MaxClients, this.MaxClients))
{
await Task.WhenAll(items.Select(item => PushItemToFeed(item, relativePath, clientThrottle, allowOverwrite)));
}
}
return(!Log.HasLoggedErrors);
}
void Fault(object sender, ExceptionEventArgs e)
{
log.LogError("Confuser", "CR003", "Confuser",
0, 0, 0, 0, string.Format(@"***************
ERROR IN CONFUSER!!
Message : {0}
Stack Trace : {1}
***************", e.Exception.Message, e.Exception.StackTrace));
ReturnValue = false;
}
public ValidationPattern(ITaskItem item, TaskLoggingHelper log)
{
_idPattern = new Regex(item.ItemSpec);
_expectedVersion = item.GetMetadata("ExpectedVersion");
_expectedPrerelease = item.GetMetadata("ExpectedPrerelease");
_log = log;
if (string.IsNullOrWhiteSpace(_expectedVersion))
{
if (string.IsNullOrWhiteSpace(_expectedPrerelease))
{
_log.LogError(
"Can't find ExpectedVersion or ExpectedPrerelease metadata on item {0}",
item.ItemSpec);
}
}
else if (!string.IsNullOrWhiteSpace(_expectedPrerelease))
{
_log.LogError(
"Both ExpectedVersion and ExpectedPrerelease metadata found on item {0}, but only one permitted",
item.ItemSpec);
}
}
private static bool HandleIntegerList(dynamic scTask, IList<int> targetCollection, string value, string itemName, TaskLoggingHelper log) {
if (!string.IsNullOrEmpty(value)) {
foreach (var s in value.Split(new[] { ';', ',' }).Select(s => s.Trim()).Where(s => s != "")) {
int w;
if (!int.TryParse(s, NumberStyles.Integer, CultureInfo.InvariantCulture, out w)) {
log.LogError("Invalid number " + s + " in " + itemName);
return false;
}
if (!targetCollection.Contains(w))
targetCollection.Add(w);
}
}
return true;
}
public bool IsSanityChecked(IEnumerable <string> items)
{
Log.LogMessage(MessageImportance.Low, $"START checking sanitized items for feed");
foreach (var item in items)
{
if (items.Any(s => Path.GetExtension(item) != ".nupkg"))
{
Log.LogError($"{item} is not a nupkg");
return(false);
}
}
List <string> duplicates = items.GroupBy(x => x)
.Where(group => group.Count() > 1)
.Select(group => group.Key).ToList();
if (duplicates.Count > 0)
{
Log.LogError($"Duplicates found: {duplicates}");
return(false);
}
Log.LogMessage(MessageImportance.Low, $"DONE checking for sanitized items for feed");
return(true);
}
public CollectTargets(TaskLoggingHelper log)
{
Log = log;
// Get the parent directory of the running program. We assume that
// this is the root of the FieldWorks repository tree.
var fwrt = BuildUtils.GetAssemblyFolder();
while (!Directory.Exists(Path.Combine(fwrt, "Build")) || !Directory.Exists(Path.Combine(fwrt, "Src")))
{
fwrt = Path.GetDirectoryName(fwrt);
if (fwrt == null)
{
Log.LogError("Error pulling the working folder from the running assembly.");
break;
}
}
m_fwroot = fwrt;
}
public static bool InstallPackages(string packagesDirectory, string packagesConfigPath, string nugetExePath, TaskLoggingHelper log)
{
var nugetArguments = @"install -o " + packagesDirectory + " -Prerelease -NonInteractive " + packagesConfigPath;
log.LogMessage("Installing: " + nugetExePath + " " + nugetArguments);
ProcessStartInfo psi = new ProcessStartInfo();
psi.UseShellExecute = false;
psi.FileName = nugetExePath;
psi.Arguments = nugetArguments;
psi.CreateNoWindow = true;
var process = Process.Start(psi);
if (!process.WaitForExit(20000))
{
log.LogError("Packages installation timed out.");
return false;
}
return true;
}
public static bool CreateJavaSources(TaskLoggingHelper log, IEnumerable<TypeDefinition> javaTypes, string outputPath, bool useSharedRuntime, bool generateOnCreateOverrides, bool hasExportReference)
{
bool ok = true;
foreach (var t in javaTypes) {
try {
GenerateJavaSource (log, t, outputPath, useSharedRuntime, generateOnCreateOverrides, hasExportReference);
} catch (XamarinAndroidException xae) {
ok = false;
log.LogError (
subcategory: "",
errorCode: "XA" + xae.Code,
helpKeyword: string.Empty,
file: xae.SourceFile,
lineNumber: xae.SourceLine,
columnNumber: 0,
endLineNumber: 0,
endColumnNumber: 0,
message: xae.MessageWithoutCode,
messageArgs: new object [0]
);
}
}
return ok;
}
public bool Initialize(string taskName, IDictionary<string, TaskPropertyInfo> parameterGroup, string taskBody, IBuildEngine taskFactoryLoggingHost)
{
TaskLoggingHelper log = new TaskLoggingHelper(taskFactoryLoggingHost, taskName);
// We use the property group for the declaration
taskProperties = (from c in parameterGroup select c.Value).ToArray();
// Compile chunk
try
{
log.LogMessage("Compile script.");
task = lua.CompileChunk(taskBody, taskName, LuaDeskop.StackTraceCompileOptions,
new KeyValuePair<string, Type>("engine", typeof(IBuildEngine)),
new KeyValuePair<string, Type>("log", typeof(TaskLoggingHelper))
);
return true;
}
catch (LuaParseException e)
{
log.LogError("{0} (at line {1},{2})", e.Message, taskName, e.Line);
return false;
}
} // func Initialize
public async Task <bool> CheckIfBlobExistsAsync(string blobPath)
{
string url = $"{FeedContainerUrl}/{blobPath}?comp=metadata";
using (HttpClient client = new HttpClient())
{
const int MaxAttempts = 15;
// add a bit of randomness to the retry delay.
var rng = new Random();
int retryCount = MaxAttempts;
// Used to make sure TaskCancelledException comes from timeouts.
CancellationTokenSource cancelTokenSource = new CancellationTokenSource();
while (true)
{
try
{
client.DefaultRequestHeaders.Clear();
var request = AzureHelper.RequestMessage("GET", url, AccountName, AccountKey).Invoke();
using (HttpResponseMessage response = await client.SendAsync(request, cancelTokenSource.Token))
{
if (response.IsSuccessStatusCode)
{
Log.LogMessage(
MessageImportance.Low,
$"Blob {blobPath} exists for {AccountName}: Status Code:{response.StatusCode} Status Desc: {await response.Content.ReadAsStringAsync()}");
}
else
{
Log.LogMessage(
MessageImportance.Low,
$"Blob {blobPath} does not exist for {AccountName}: Status Code:{response.StatusCode} Status Desc: {await response.Content.ReadAsStringAsync()}");
}
return(response.IsSuccessStatusCode);
}
}
catch (HttpRequestException toLog)
{
if (retryCount <= 0)
{
Log.LogError($"Unable to check for existence of blob {blobPath} in {AccountName} after {MaxAttempts} retries.");
throw;
}
else
{
Log.LogWarning("Exception thrown while trying to detect if blob already exists in feed:");
Log.LogWarningFromException(toLog, true);
}
}
catch (TaskCanceledException possibleTimeoutToLog)
{
// Detect timeout.
if (possibleTimeoutToLog.CancellationToken != cancelTokenSource.Token)
{
if (retryCount <= 0)
{
Log.LogError($"Unable to check for existence of blob {blobPath} in {AccountName} after {MaxAttempts} retries.");
throw;
}
else
{
Log.LogWarning("Exception thrown while trying to detect if blob already exists in feed:");
Log.LogWarningFromException(possibleTimeoutToLog, true);
}
}
else
{
throw;
}
}
--retryCount;
Log.LogWarning($"Failed to check for existence of blob {blobPath}. {retryCount} attempts remaining");
int delay = (MaxAttempts - retryCount) * rng.Next(1, 7);
await Task.Delay(delay * 1000);
}
}
}
public static bool Bind(TaskLoggingHelper log, XmlReader modelReader, XmlReader viewModelReader, XmlWriter viewWriter, Action<object, XsltMessageEncounteredEventArgs> messageAction = null)
{
XmlDocument viewModelDocument = new XmlDocument();
try
{
viewModelDocument.Load(viewModelReader);
}
catch (Exception x)
{
log.LogError("View Model: {0}", x.Message);
return false;
}
XmlDocument modelDocument = new XmlDocument();
try
{
modelDocument.Load(modelReader);
}
catch (Exception x)
{
log.LogError("Model: {0}", x.Message);
return false;
}
using (StringReader dummyReader = new StringReader("<dummy/>"))
{
XslTransforms.BindTransform.Apply(
XmlReader.Create(dummyReader),
viewWriter,
messageAction: messageAction,
parameters: new[] {
new XslTransforms.Parameter("ViewModel", "", viewModelDocument),
new XslTransforms.Parameter("Model", "", modelDocument)});
}
return true;
}
/// <summary>
/// Executes a tool, logs standard error and a nonzero exit code as errors, returns the output and optionally logs that
/// as well.
/// </summary>
/// <param name="log">used for logging</param>
/// <param name="executable">the name of the executable</param>
/// <param name="args">the command line arguments</param>
/// <param name="logOutput">should we log the output in real time</param>
/// <returns>the output of the tool</returns>
public static string ExecuteWithLogging(TaskLoggingHelper log, string executable, string args, bool logOutput)
{
if (log == null)
{
throw new ArgumentNullException("log");
}
log.LogMessage(MessageImportance.Low, "Executing tool: {0} {1}", executable, args);
var exec = new ShellWrapper(executable, args);
// stderr is logged as errors
exec.ErrorDataReceived += (sender, e) =>
{
if (e.Data != null)
{
log.LogError(e.Data);
}
};
// stdout is logged normally if requested
if (logOutput)
{
exec.OutputDataReceived += (sender, e) =>
{
if (e.Data != null)
{
log.LogMessage(MessageImportance.Normal, e.Data);
}
};
}
// execute the process
exec.Execute();
// check the exit code
if (exec.ExitCode != 0)
{
log.LogError("The tool {0} exited with error code {1}", executable, exec.ExitCode);
}
return exec.StandardOutput;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Dynamically invokes <paramref name="methodName"/> in dll <paramref name="fileName"/>.
/// </summary>
/// <param name="log">Log helper</param>
/// <param name="fileName">Name of the dll.</param>
/// <param name="delegateSignatureType">Signature of the method.</param>
/// <param name="methodName">Name of the method</param>
/// <param name="args">Arguments to pass to <paramref name="methodName"/>.</param>
/// ------------------------------------------------------------------------------------
private static void ApiInvoke(TaskLoggingHelper log, string fileName,
Type delegateSignatureType, string methodName, params object[] args)
{
if (!File.Exists(fileName))
return;
fileName = Path.GetFullPath(fileName);
IntPtr hModule = LoadLibrary(fileName);
if (hModule == IntPtr.Zero)
{
var errorCode = Marshal.GetLastWin32Error();
log.LogError("Failed to load library {0} for {1} with error code {2}", fileName, methodName,
errorCode);
return;
}
try
{
IntPtr method = GetProcAddress(hModule, methodName);
if (method == IntPtr.Zero)
return;
Marshal.GetDelegateForFunctionPointer(method, delegateSignatureType).DynamicInvoke(args);
}
catch (Exception e)
{
log.LogError("RegHelper.ApiInvoke failed getting function pointer for {0}: {1}",
methodName, e);
}
finally
{
FreeLibrary(hModule);
}
}
private bool ValidNonNull(string name, object value, TaskLoggingHelper log)
{
Contract.Requires(name != null);
Contract.Ensures(!Contract.Result<bool>() || (value != null));
Contract.Ensures(Contract.Result<bool>() || (value == null));
if (value == null)
{
if (log != null)
{
log.LogError("Parameter '{0}' must be non-empty", name);
}
return false;
}
return true;
}
private static CompilerOptions GetOptions(dynamic taskOptions, TaskLoggingHelper log) {
var result = new CompilerOptions();
result.KeyContainer = taskOptions.KeyContainer;
result.KeyFile = taskOptions.KeyFile;
result.MinimizeScript = !taskOptions.EmitDebugInformation;
result.DocumentationFile = taskOptions.DocumentationFile;
result.OutputAssemblyPath = taskOptions.OutputAssembly;
result.OutputScriptPath = taskOptions.OutputScript;
result.TreatWarningsAsErrors = taskOptions.TreatWarningsAsErrors;
result.WarningLevel = taskOptions.WarningLevel;
result.AlreadyCompiled = taskOptions.AlreadyCompiled;
result.EntryPointClass = taskOptions.MainEntryPoint;
if (!string.IsNullOrEmpty(taskOptions.TargetType)) {
switch ((string)taskOptions.TargetType.ToLowerInvariant()) {
case "exe":
case "winexe":
result.HasEntryPoint = true;
break;
case "library":
case "module":
result.HasEntryPoint = false;
break;
default:
log.LogError("Invalid target type (must be exe, winexe, library or module).");
return null;
}
}
else {
result.HasEntryPoint = false;
}
if (taskOptions.WarningLevel < 0 || taskOptions.WarningLevel > 4) {
log.LogError("Warning level must be between 0 and 4.");
return null;
}
if (taskOptions.AdditionalLibPaths != null)
result.AdditionalLibPaths.AddRange(taskOptions.AdditionalLibPaths);
if (taskOptions.DefineConstants != null)
result.DefineConstants.AddRange(((string)taskOptions.DefineConstants).Split(';').Select(s => s.Trim()).Where(s => s != ""));
if (!HandleIntegerList(taskOptions, result.DisabledWarnings, taskOptions.DisabledWarnings, "DisabledWarnings", log))
return null;
if (!HandleIntegerList(taskOptions, result.WarningsAsErrors, taskOptions.WarningsAsErrors, "WarningsAsErrors", log))
return null;
if (!HandleIntegerList(taskOptions, result.WarningsNotAsErrors, taskOptions.WarningsNotAsErrors, "WarningsNotAsErrors", log))
return null;
if (taskOptions.References != null) {
foreach (ITaskItem r in taskOptions.References) {
string alias = r.GetMetadata("Aliases");
result.References.Add(new Reference(r.ItemSpec, !string.IsNullOrWhiteSpace(alias) ? alias : null));
}
}
if (taskOptions.Sources != null) {
foreach (ITaskItem s in taskOptions.Sources) {
result.SourceFiles.Add(s.ItemSpec);
}
}
if (taskOptions.Resources != null) {
foreach (ITaskItem r in taskOptions.Resources) {
string name = r.GetMetadata("LogicalName");
string access = r.GetMetadata("Access");
result.EmbeddedResources.Add(new EmbeddedResource(r.ItemSpec, !string.IsNullOrWhiteSpace(name) ? name : Path.GetFileName(r.ItemSpec), !string.Equals(access, "private", StringComparison.OrdinalIgnoreCase)));
}
}
return result;
}
/// <summary>
/// Append each of the define constants to the command line.
/// </summary>
/// <param name="commandLine">Command line builder.</param>
internal static void AppendExtensions(CommandLineBuilder commandLine, ITaskItem[] extensions, TaskLoggingHelper log)
{
if (extensions == null)
{
// No items
return;
}
for (int i = 0; i < extensions.Length; i++)
{
string className = extensions[i].GetMetadata("Class");
if (String.IsNullOrEmpty(className))
{
log.LogError(String.Format("Missing the required property 'Class' for the extension {0}", extensions[i].ItemSpec));
}
commandLine.AppendSwitchUnquotedIfNotNull("-ext ", String.Concat(className, ",", extensions[i].ItemSpec));
}
}
/// <summary>
///
/// </summary>
/// <param name="fileName">The file name of the dependent (usually a .resx)</param>
/// <param name="binaryStream">File contents binary stream, may be null</param>
/// <param name="log">Task's TaskLoggingHelper, for logging warnings or errors</param>
/// <returns></returns>
private static ExtractedClassName GetFirstClassNameFullyQualified(string fileName, Stream binaryStream,TaskLoggingHelper log)
{
Match m = null;
string currentNamespace = "";
ExtractedClassName name = new ExtractedClassName();
int conditionalDepth = 0;
StreamReader reader = new StreamReader(binaryStream, true); // let the reader determine the encoding
var namespaces = new Stack<string>();
while (! reader.EndOfStream)
{
var line = reader.ReadLine();
// Does the line contain "CLASS"
m = classRx.Match(line);
if (m.Success)
{
name.Name = currentNamespace + m.Groups[1].Value;
name.IsInsideConditionalBlock = conditionalDepth > 0;
return name;
}
// Does the line contain "BEGIN NAMESPACE"
m = namespaceBeginRx.Match(line);
if (m.Success)
{
namespaces.Push(currentNamespace);
currentNamespace = currentNamespace + (m.Groups[1].Value + ".");
}
// Does the line contain "END NAMESPACE"
else if (namespaceEndRx.Match(line).Success)
{
if (namespaces.Count > 0)
{
currentNamespace = namespaces.Pop();
}
else
{
object[] messageArgs = new object[] { fileName };
log.LogError("CreateXSharpManifestResourceName: found 'END NAMESPACE' with no matching 'BEGIN NAMESPACE' in '{0}'", messageArgs);
}
}
// Does the line contain "#IFDEF"
else if (ifdefRx.Match(line).Success)
{
conditionalDepth++;
}
// Does the line contain "#ENDIF"
else if (endifRx.Match(line).Success)
{
conditionalDepth--;
}
}
return name;
}
public static bool GenerateFile (CodeDomProvider provider, string app_name,
string xaml_file, string xaml_path_in_project, string out_file, TaskLoggingHelper log)
{
XmlDocument xmldoc = new XmlDocument ();
xmldoc.Load (xaml_file);
XmlNamespaceManager nsmgr = new XmlNamespaceManager (xmldoc.NameTable);
nsmgr.AddNamespace("x", "http://schemas.microsoft.com/winfx/2006/xaml");
XmlNode root = xmldoc.SelectSingleNode ("/*", nsmgr);
if (root == null) {
log.LogError ("{0}: No root node found.", xaml_file);
return false;
}
XmlAttribute root_class = root.Attributes ["x:Class"];
if (root_class == null) {
File.WriteAllText (out_file, "");
return true;
}
bool is_application = root.LocalName == "Application";
string root_ns;
string root_type;
string root_asm;
ParseXmlns (root_class.Value, out root_type, out root_ns, out root_asm);
Hashtable names_and_types = GetNamesAndTypes (root, nsmgr);
// Hashtable keys_and_types = GetKeysAndTypes (root, nsmgr);
CodeCompileUnit ccu = new CodeCompileUnit ();
CodeNamespace decl_ns = new CodeNamespace (root_ns);
ccu.Namespaces.Add (decl_ns);
decl_ns.Imports.Add (new CodeNamespaceImport ("System"));
decl_ns.Imports.Add (new CodeNamespaceImport ("System.Windows"));
decl_ns.Imports.Add (new CodeNamespaceImport ("System.Windows.Controls"));
decl_ns.Imports.Add (new CodeNamespaceImport ("System.Windows.Documents"));
decl_ns.Imports.Add (new CodeNamespaceImport ("System.Windows.Input"));
decl_ns.Imports.Add (new CodeNamespaceImport ("System.Windows.Media"));
decl_ns.Imports.Add (new CodeNamespaceImport ("System.Windows.Media.Animation"));
decl_ns.Imports.Add (new CodeNamespaceImport ("System.Windows.Shapes"));
decl_ns.Imports.Add (new CodeNamespaceImport ("System.Windows.Controls.Primitives"));
CodeTypeDeclaration decl_type = new CodeTypeDeclaration (root_type);
decl_type.IsPartial = true;
decl_ns.Types.Add (decl_type);
CodeMemberMethod initcomp = new CodeMemberMethod ();
initcomp.Name = "InitializeComponent";
decl_type.Members.Add (initcomp);
if (sl2) {
CodeMemberField field = new CodeMemberField ();
field.Name = "_contentLoaded";
field.Type = new CodeTypeReference (typeof (bool));
decl_type.Members.Add (field);
CodeConditionStatement is_content_loaded = new CodeConditionStatement (new CodeVariableReferenceExpression ("_contentLoaded"),
new CodeStatement [] { new CodeMethodReturnStatement () });
initcomp.Statements.Add (is_content_loaded);
CodeAssignStatement set_content_loaded = new CodeAssignStatement (new CodeVariableReferenceExpression ("_contentLoaded"),
new CodePrimitiveExpression (true));
initcomp.Statements.Add (set_content_loaded);
string component_path = String.Format ("/{0};component/{1}", app_name, xaml_path_in_project);
CodeMethodInvokeExpression load_component = new CodeMethodInvokeExpression (
new CodeTypeReferenceExpression ("System.Windows.Application"), "LoadComponent",
new CodeExpression [] { new CodeThisReferenceExpression (),
new CodeObjectCreateExpression (new CodeTypeReference ("System.Uri"), new CodeExpression [] {
new CodePrimitiveExpression (component_path),
new CodeFieldReferenceExpression (new CodeTypeReferenceExpression ("System.UriKind"), "Relative") })
});
initcomp.Statements.Add (load_component);
}
if (!is_application) {
foreach (DictionaryEntry entry in names_and_types) {
string name = (string) entry.Key;
CodeTypeReference type = (CodeTypeReference) entry.Value;
CodeMemberField field = new CodeMemberField ();
if (sl2)
field.Attributes = MemberAttributes.Assembly;
field.Name = name;
field.Type = type;
decl_type.Members.Add (field);
CodeMethodInvokeExpression find_invoke = new CodeMethodInvokeExpression (
new CodeThisReferenceExpression(), "FindName",
new CodeExpression[] { new CodePrimitiveExpression (name) } );
CodeCastExpression cast = new CodeCastExpression (type, find_invoke);
CodeAssignStatement assign = new CodeAssignStatement (
new CodeVariableReferenceExpression (name), cast);
initcomp.Statements.Add (assign);
}
}
using (StreamWriter writer = new StreamWriter (out_file)) {
provider.GenerateCodeFromCompileUnit (ccu, writer, new CodeGeneratorOptions ());
}
return true;
}
