internal void SetComponentLinks(IEnumerable<AbstractEndpoint.IAbstractComponentLink> componentLinks)
{
var links = new List<ComponentsOrderingViewModel>();
var setOrder = new Action(() =>
{
var worker = new BackgroundWorker();
worker.DoWork += (e, s) =>
{
foreach (var cl in links.AsEnumerable().Reverse())
{
cl.Link.Order = links.IndexOf(cl) + 1;
}
};
worker.RunWorkerAsync();
});
foreach (var cl in componentLinks.OrderBy(x => x.Order))
{
var vm = new ComponentsOrderingViewModel { Link = cl };
links.Add(vm);
vm.UpCommand = new RelayCommand(
() =>
{
var prevIndex = links.IndexOf(vm);
links.Remove(vm);
links.Insert(prevIndex - 1, vm);
this.ComponentList.ItemsSource = null;
this.ComponentList.ItemsSource = links;
this.ComponentList.SelectedItem = vm;
setOrder();
}, () => links.IndexOf(vm) > 0);
vm.DownCommand = new RelayCommand(
() =>
{
var prevIndex = links.IndexOf(vm);
links.Remove(vm);
links.Insert(prevIndex + 1, vm);
this.ComponentList.ItemsSource = null;
this.ComponentList.ItemsSource = links;
this.ComponentList.SelectedItem = vm;
setOrder();
}, () => links.IndexOf(vm) < links.Count - 1);
}
this.ComponentList.ItemsSource = links;
}
private async void CreateRepo_Click(object sender, RoutedEventArgs e)
{
CreateRepo.IsEnabled = false;
RepoProgress.Visibility = Visibility.Visible;
var asd = new List<string>();
foreach (CheckBox item in ListOfFolders.Items)
{
if (item.IsChecked.HasValue)
{
if ((bool)item.IsChecked) asd.Add((string)item.Content);
}
}
if (asd.Count > 0)
{
await Task.Run(() =>
{
var newRepo = new RepositoryData();
newRepo.DownloadRoot = Repository.DefaultUrlBase;
newRepo.Files = r.CreateRepositoryData(asd.AsEnumerable());
string output = JsonConvert.SerializeObject(newRepo);
try
{
using (var wr = new StreamWriter("updater.json", false))
{
wr.Write(output);
wr.Flush();
}
MessageBox.Show("Metadata created successfully.");
}
catch (Exception)
{
MessageBox.Show("Unable to write metadata file.");
}
});
}
CreateRepo.IsEnabled = true;
RepoProgress.Visibility = Visibility.Hidden;
}
/*
* Get the member access in the document, returning a tuple of member access node and the RefactoringType it is accessing.
*/
public IEnumerable<Tuple<SyntaxNode, ITypeSymbol>> GetMemberAccessAndAccessedTypes()
{
// For all the classes whose memeber is accessed and their types.
var typedAccesses = new List<Tuple<SyntaxNode, ITypeSymbol>>();
// Get all nodes whose RefactoringType is member access.
var accesses = root.DescendantNodes().Where(n => n.Kind == SyntaxKind.MemberAccessExpression);
// For all the access in the list.
foreach (SyntaxNode access in accesses)
{
// Get left and right side of the access.
var analyzer = AnalyzerFactory.GetMemberAccessAnalyzer();
analyzer.SetMemberAccess(access);
var left = analyzer.GetLeftPart();
// Query about the RefactoringType of the left side of the access, if it is not null, add to the results.
// ATTENTION: mode.GetTypeInfo() cannot get primitive RefactoringType such as int.
var infor = model.GetTypeInfo(left);
if(infor.Type != null)
typedAccesses.Add(Tuple.Create(access, infor.Type));
}
return typedAccesses.AsEnumerable();
}
/* Map all the nodes to another document. */
public IEnumerable<SyntaxNode> MapToAnotherDocument(IDocument document)
{
var analyzer = AnalyzerFactory.GetSyntaxNodeAnalyzer();
var list = new List<SyntaxNode>();
foreach (SyntaxNode node in nodes)
{
analyzer.SetSyntaxNode(node);
list.Add(analyzer.MapToAnotherDocument(document));
}
return list.AsEnumerable();
}
/*
* Get groups of nodes. In each group, nodes are sequentially ordered and no code in
* between of each two nearby nodes.
*/
public IEnumerable<IEnumerable<SyntaxNode>> GetNeighborredNodesGroups()
{
// Remove all the nodes contained by other node in the list, also sort the list by starting position
var sortedNodes = RemoveSubNodes().OrderBy(n => n.Span.Start);
var breakIndexes = new List<int>();
var analyzer = AnalyzerFactory.GetSyntaxNodeAnalyzer();
logger.Debug("Sourted node count: " + sortedNodes.Count());
// Iterate all the nodes, if one is not neighborred with its previous one, add to the break indexes.
for (int i = 1; i < sortedNodes.Count(); i++)
{
analyzer.SetSyntaxNode(nodes.ElementAt(i));
if (!analyzer.IsNeighborredWith(sortedNodes.ElementAt(i - 1)))
{
breakIndexes.Add(i);
}
}
// The number of elements shall be the last break index.
breakIndexes.Add(nodes.Count());
var lists = new List<IEnumerable<SyntaxNode>>();
int start = 0;
// Iterate each break index, from 'last break index' to 'current break index -1'
// is a group of neiborred syntax node.
foreach (var end in breakIndexes)
{
lists.Add(sortedNodes.Skip(start).Take(end - start));
start = end;
}
return lists.AsEnumerable();
}
/* Get a subset of all the containing statements, start and end index are inclusive. */
public IEnumerable<SyntaxNode> GetStatementsByIndexRange(int start, int end)
{
var statements = GetStatements();
var subList = new List<SyntaxNode>();
for(int i = start; i <= end; i++)
{
subList.Add(statements.ElementAt(i));
}
return subList.AsEnumerable();
}
public IEnumerable<SyntaxNode> GetStatementsBefore(int position)
{
// Get all the statements first.
IEnumerable<SyntaxNode> statements = GetStatements();
// Initiate an empty statement list.
IList<SyntaxNode> result = new List<SyntaxNode>();
// Iterate all the statement.
foreach(var statement in statements)
{
// For statement whose end point is before the position, add it to the result
if (statement.Span.End < position)
{
result.Add(statement);
}
}
return result.AsEnumerable();
}
public IEnumerable<IEnumerable<SyntaxNode>> GetParameterUsages()
{
// Containing the results.
var list = new List<IEnumerable<SyntaxNode>>();
// All the parameters taken.
var parameters = GetParameters();
// Block of the method declaration.
var block = ASTUtil.GetBlockOfMethod(method);
// For each parameter.
// ATTENTION: foreach will throw null exception if it has nothing in it.
foreach (ParameterSyntax para in parameters)
{
// Need a new subList to copy out nodes, IEnumerable is a read only interface that will not copy out as new
// elements. To copy out as new elements, a list is needed.
// ATTENTION: cannot list.add(block.DecendantNodes()...), because if have multiple paras the previous added IEnumerable
// will be rewrite.
var sublist = new List<SyntaxNode>();
// Only able to retrieve the parameter usages if the method block exists.
if (block != null)
{
// If an identifier name equals the paraemeter's name, it is one usage of the
// parameter.
sublist.AddRange(block.DescendantNodes().Where(n => n.Kind == SyntaxKind.IdentifierName
&& n.GetText().Equals(para.Identifier.ValueText)));
}
logger.Info("Parameter " + para.Identifier + " usage:" +
StringUtil.ConcatenateAll(",", sublist.Select(n => n.Span.ToString())));
list.Add(sublist.AsEnumerable());
}
return list.AsEnumerable();
}
private void XMLParser_DoWork(object sender, DoWorkEventArgs e)
{
this.Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Normal, new Action(delegate()
{
CheckingLabel.Content = "Picking the right edition for you";
}
));
//OSParams Tree: [0] = LanguageCode, [1] = Edition, [2] = Architecture, [3] ProductName
CurrentOSParams = new List<string>();
CurrentOSParams.Add((CultureInfo.InstalledUICulture).Name.ToLower());
CurrentOSParams.Add((string)Microsoft.Win32.Registry.GetValue("HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", "EditionId", null));
if (Environment.Is64BitOperatingSystem)
CurrentOSParams.Add("x64");
else
CurrentOSParams.Add("x86");
CurrentOSParams.Add((string)Microsoft.Win32.Registry.GetValue("HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", "ProductName", null));
this.Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Normal, new Action(delegate()
{
MainWindowHandle.SendGXNReport("Launched on Build " + (string)Microsoft.Win32.Registry.GetValue(@"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion", "CurrentBuildNumber", null) + ": LanguageCode=" + CurrentOSParams[0] + ", Edition=" + CurrentOSParams[1] + ", Architecture=" + CurrentOSParams[2] + ", ProductName=" + CurrentOSParams[3]);
}
));
ESDList = new List<EsdFile>();
HttpWebRequest wreq = HttpWebRequest.Create("http://msft.gq/pub/xml/mct/10240.16384_prd.xml") as HttpWebRequest;
using (HttpWebResponse wres = wreq.GetResponse() as HttpWebResponse)
using (Stream wresStr = wres.GetResponseStream())
{
XDocument xdoc = XDocument.Load(wresStr);
var files = from f in xdoc.Descendants("File")
select new EsdFile()
{
FileName = f.Element("FileName").Value,
LanguageCode = f.Element("LanguageCode").Value,
Language = f.Element("Language").Value,
Edition = f.Element("Edition").Value,
Architecture = f.Element("Architecture").Value,
Size = long.Parse(f.Element("Size").Value),
Sha1 = f.Element("Sha1").Value,
FilePath = f.Element("FilePath").Value,
Key = f.Element("Key").Value,
Architecture_Loc = f.Element("Architecture_Loc").Value,
Edition_Loc = f.Element("Edition_Loc").Value,
IsRetailOnly = Convert.ToBoolean(f.Element("IsRetailOnly").Value)
};
ESDList.AddRange(files);
}
IEnumerable<EsdFile> ESDListEnum = from XMLEntry in ESDList.AsEnumerable()
where XMLEntry.LanguageCode.Equals(CurrentOSParams[0]) &&
XMLEntry.Edition.Equals(CurrentOSParams[1]) &&
XMLEntry.Architecture.Equals(CurrentOSParams[2])
select XMLEntry;
ESDParams = new List<string>();
UpcomingOSParams = new List<string>();
foreach (var ESD in ESDListEnum)
{
if (UpcomingOSParams.Count < 4)
{
UpcomingOSParams.Add(ESD.LanguageCode);
UpcomingOSParams.Add(ESD.Edition);
UpcomingOSParams.Add(ESD.Architecture);
if (ESD.Edition_Loc.Equals("%EDU_N%"))
UpcomingOSParams.Add("Windows 10 Education N");
else if (ESD.Edition_Loc.Equals("%BASE_K%"))
UpcomingOSParams.Add("Windows 10 Home K");
else if (ESD.Edition_Loc.Equals("%BASE%"))
UpcomingOSParams.Add("Windows 10 Home");
else if (ESD.Edition_Loc.Equals("%BASE_CHINA%"))
UpcomingOSParams.Add("Windows 10 Home China");
else if (ESD.Edition_Loc.Equals("%EDU_K%"))
UpcomingOSParams.Add("Windows 10 Education K");
else if (ESD.Edition_Loc.Equals("%BASE_N%"))
UpcomingOSParams.Add("Windows 10 Home N");
else if (ESD.Edition_Loc.Equals("%PRO_K%"))
UpcomingOSParams.Add("Windows 10 Pro K");
else if (ESD.Edition_Loc.Equals("%EDU%"))
UpcomingOSParams.Add("Windows 10 Education");
else if (ESD.Edition_Loc.Equals("%SINGLE_LANGUAGE%"))
UpcomingOSParams.Add("Windows 10 Home Single Language");
else if (ESD.Edition_Loc.Equals("%EDU_KN%"))
UpcomingOSParams.Add("Windows 10 Education KN");
else if (ESD.Edition_Loc.Equals("%PRO_N%"))
UpcomingOSParams.Add("Windows 10 Pro N");
else if (ESD.Edition_Loc.Equals("%PRO%"))
UpcomingOSParams.Add("Windows 10 Pro");
else if (ESD.Edition_Loc.Equals("%PRO_KN%"))
UpcomingOSParams.Add("Windows 10 Pro KN");
else if (ESD.Edition_Loc.Equals("%BASE_KN%"))
UpcomingOSParams.Add("Windows 10 Home KN");
}
//ESDParams Tree: [0] Url, [1] FileName, [2] Sha1, [3] Key
if (ESDParams.Count < 4)
{
ESDParams.Add(ESD.FilePath);
ESDParams.Add(ESD.FileName);
ESDParams.Add(ESD.Sha1);
ESDParams.Add(ESD.Key);
}
}
if (ESDParams.Count < 4)
{
HasFailed = true;
this.Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Normal, new Action(delegate()
{
MainWindowHandle.JumpToErrorPage("There is no edition of Windows 10 we could upgrade you to.");
return;
}
));
}
else
{
this.Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Normal, new Action(delegate()
{
MainWindowHandle.SendGXNReport("ESD to download: " + ESDParams[1]);
}
));
}
}
/*
* Get tuples of node and RefactoringType. Nodes shall be identifier names.
* ATTENTION: the declarations cannot get RefactoringType info, only identifiers(references) can.
*/
public IEnumerable<Tuple<SyntaxNode, ITypeSymbol>> GetTypableIdentifierTypeTuples()
{
var typedIdentifiers = new List<Tuple<SyntaxNode, ITypeSymbol>>();
// Get all identifiers.
var identifiers = root.DescendantNodes().Where(n => n.Kind == SyntaxKind.IdentifierName);
foreach (SyntaxNode id in identifiers)
{
// Query RefactoringType information of an identifier.
var info = model.GetTypeInfo(id);
// If RefactoringType is retrieved, add to the result.
if (info.Type != null)
typedIdentifiers.Add(Tuple.Create(id, info.Type));
}
return typedIdentifiers.AsEnumerable();
}
