private static string GetComplierTextHeader(int codeElementCount, VCCodeElement codeElement)
{
bool isTemplate = false;
if (codeElement == null)
{
return(null);
}
string reflexHeader = null;
switch (codeElement.Kind)
{
case vsCMElement.vsCMElementClass:
case vsCMElement.vsCMElementStruct:
if ((codeElement is VCCodeClass codeClass && codeClass.IsTemplate) ||
(codeElement is VCCodeStruct codeStruct && codeStruct.IsTemplate))
{
isTemplate = true;
reflexHeader = "WATERY_REFLECTION_TEMPALTE";
}
else
{
reflexHeader = "WATERY_REFLECTION";
}
break;
private void PopulateRecursively(TreeNodeCollection nodes, CodeElements elements)
{
for (int i = 1; i <= elements.Count; i++)
{
VCCodeElement element = elements.Item(i) as VCCodeElement;
if (IsElementAcceptableType(element))
{
TreeNode node = new TreeNode();
node.Text = element.Name;
node.Tag = element;
IPicture picture = (IPicture)element.Picture;
Icon icon = Icon.FromHandle(new IntPtr(picture.Handle));
imageList.Images.Add(icon);
node.ImageIndex = node.SelectedImageIndex = imageList.Images.Count - 1;
node.Checked = true;
nodes.Add(node);
PopulateRecursively(node.Nodes, element.Children);
}
}
}
private VCCodeClass GetClassCodeElem()
{
VCCodeElement targetClassElem = (VCCodeElement)ent.Parent;
if (targetClassElem != null && targetClassElem.Kind == vsCMElement.vsCMElementClass)
{
return((VCCodeClass)targetClassElem);
}
return(null);
}
private bool IsElementAcceptableType(VCCodeElement element)
{
switch (element.Kind)
{
case vsCMElement.vsCMElementFunction:
VCCodeFunction function = (VCCodeFunction)element;
if (element.Name.StartsWith("~") ||
function.Access != vsCMAccess.vsCMAccessPublic)
{
return(false);
}
else
{
return(true);
}
case vsCMElement.vsCMElementClass:
VCCodeClass klass = (VCCodeClass)element;
if (klass.Access != vsCMAccess.vsCMAccessPublic)
{
return(false);
}
else
{
return(true);
}
case vsCMElement.vsCMElementNamespace:
return(true);
case vsCMElement.vsCMElementStruct:
VCCodeStruct strukt = (VCCodeStruct)element;
if (strukt.Access != vsCMAccess.vsCMAccessPublic)
{
return(false);
}
else
{
return(true);
}
default:
return(false);
}
}
private void GetCheckedFunctionsRecursively(List <VCCodeFunction> functions, TreeNodeCollection nodes)
{
foreach (TreeNode node in nodes)
{
if (node.Checked)
{
VCCodeElement element = (VCCodeElement)node.Tag;
if (element is VCCodeFunction)
{
functions.Add((VCCodeFunction)element);
}
}
GetCheckedFunctionsRecursively(functions, node.Nodes);
}
}
private List <VCCodeElement> ScanElements(VCCodeElements elements)
{
Queue <VCCodeElement> QueueElements = new Queue <VCCodeElement>();
foreach (VCCodeElement Element in elements)
{
QueueElements.Enqueue(Element);
}
List <VCCodeElement> result = new List <VCCodeElement>();
while (QueueElements.Count != 0)
{
VCCodeElement Element = QueueElements.Dequeue();
switch (Element.Kind)
{
case vsCMElement.vsCMElementStruct:
result.Add(Element);
VCCodeElements children = (VCCodeElements)Element.Children;
foreach (VCCodeElement childElement in children)
{
QueueElements.Enqueue(childElement);
}
break;
case vsCMElement.vsCMElementClass:
case vsCMElement.vsCMElementEnum:
case vsCMElement.vsCMElementFunction:
case vsCMElement.vsCMElementMacro:
case vsCMElement.vsCMElementTypeDef:
case vsCMElement.vsCMElementVariable:
result.Add(Element);
break;
case vsCMElement.vsCMElementIncludeStmt:
break;
default:
MessageBox.Show(Element.Kind.ToString());
break;
}
}
return(result);
}
public void ChangeElement(CodeElement element, vsCMChangeKind changeKind)
{
if (testsTreeView.Nodes.Count == 0)
{
return;
}
if (element is VCCodeClass || element is VCCodeStruct)
{
testsTreeView.BeginUpdate();
VCCodeModel model = ((VCCodeElement)element).CodeModel;
TestSuiteCollector collector = new TestSuiteCollector();
collector.Process(model);
List <TestSuite> suitesInModel = new List <TestSuite>(collector.Suites);
// Iterate through the current suites in the view and pull out any
// that are no longer in the model.
TreeNode solutionNode = testsTreeView.Nodes[0];
for (int i = 0; i < solutionNode.Nodes.Count;)
{
TreeNode viewNode = solutionNode.Nodes[i];
int index = suitesInModel.FindIndex(
new Predicate <TestSuite>(delegate(TestSuite suite)
{
return(suite.Name == viewNode.Text);
}));
if (index == -1)
{
viewNode.Remove();
}
else
{
// The suites that are left over will be those in the
// model that aren't yet in the tree, so they need to
// be added.
suitesInModel.RemoveAt(index);
i++;
}
}
// Make sure a suite with the same name isn't already in the
// view (this could happen if the name changes and then quickly
// changes back before the event fires. If it's not there, add
// it.
foreach (TestSuite suite in suitesInModel)
{
AddTestSuiteToNode(suite, solutionNode, null).Expand();
}
testsTreeView.Sort();
testsTreeView.EndUpdate();
}
else if (element is VCCodeFunction)
{
testsTreeView.BeginUpdate();
VCCodeElement parent = (VCCodeElement)((VCCodeElement)element).Parent;
TestCaseCollector collector = new TestCaseCollector();
collector.Process(parent.Children);
List <TestCase> casesInModel = new List <TestCase>(collector.TestCases);
// Iterate through the current test cases for this suite in the
// view and pull out any that are no longer in the model.
TreeNode suiteNode = FindNodeForTestSuite(parent);
if (suiteNode == null)
{
return;
}
for (int i = 0; i < suiteNode.Nodes.Count;)
{
TreeNode viewNode = suiteNode.Nodes[i];
int index = casesInModel.FindIndex(
new Predicate <TestCase>(delegate(TestCase testCase)
{
return(testCase.Name == viewNode.Text);
}));
if (index == -1)
{
viewNode.Remove();
}
else
{
// The test cases that are left over will be those in
// the model that aren't yet in the tree, so they need
// to be added.
casesInModel.RemoveAt(index);
i++;
}
}
foreach (TestCase testCase in casesInModel)
{
AddTestCaseToNode((TestSuite)suiteNode.Tag, testCase, suiteNode, null);
}
testsTreeView.Sort();
testsTreeView.EndUpdate();
}
}
private bool IsElementAcceptableType(VCCodeElement element)
{
switch (element.Kind)
{
case vsCMElement.vsCMElementFunction:
VCCodeFunction function = (VCCodeFunction)element;
if (element.Name.StartsWith("~") ||
function.Access != vsCMAccess.vsCMAccessPublic)
return false;
else
return true;
case vsCMElement.vsCMElementClass:
VCCodeClass klass = (VCCodeClass)element;
if (klass.Access != vsCMAccess.vsCMAccessPublic)
return false;
else
return true;
case vsCMElement.vsCMElementNamespace:
return true;
case vsCMElement.vsCMElementStruct:
VCCodeStruct strukt = (VCCodeStruct)element;
if (strukt.Access != vsCMAccess.vsCMAccessPublic)
return false;
else
return true;
default:
return false;
}
}
public static void AssigneElement(string baseDirectory, VCCodeElement element, IScope parent)
{
if (element == null)
{
return;
}
var name = element.FullName;
IScope scope = parent;
switch (element.Kind)
{
case vsCMElement.vsCMElementClass:
{
var item = element as VCCodeClass;
scope = parent.FindScope(item.Name);
if (scope != null)
{
break;
}
var classNode = new ClassNode();
classNode.Name = item.Name;
classNode.VCElement = element;
foreach (VCCodeElement baseClass in item.Bases)
{
classNode.ParentClasses.Add(baseClass.Name);
}
scope = classNode;
parent.AddElement(scope);
break;
}
case vsCMElement.vsCMElementNamespace:
{
var item = element as VCCodeNamespace;
scope = parent.FindScope(item.Name);
if (scope != null)
{
break;
}
scope = new NamespaceNode();
((NamespaceNode)scope).VCElement = element;
scope.Name = item.Name;
parent.AddElement(scope);
break;
}
case vsCMElement.vsCMElementEnum:
case vsCMElement.vsCMElementFunction:
case vsCMElement.vsCMElementParameter:
case vsCMElement.vsCMElementVariable:
return;
default:
break;
}
var ex = element.Children.OfType <VCCodeClass>()
.Select(m => m.FullName)
.ToList();
foreach (VCCodeElement item in element.Children)
{
AssigneElement(baseDirectory, item, scope);
}
}
private static StringBuilder ComplierText(string reflexHeader, string text, VCCodeElement codeElement)
{
var complierText = new StringBuilder(reflexHeader + '(' + text + ',');
switch (codeElement.Kind)
{
case vsCMElement.vsCMElementEnum:
var codeEnum = codeElement as VCCodeEnum;
foreach (VCCodeElement enumMember in codeEnum.Members)
{
complierText.Append(enumMember.Name + ',');
}
complierText.Remove(complierText.Length - 1, 1);
break;
case vsCMElement.vsCMElementClass:
if (codeElement is VCCodeClass codeClass)
{
if (codeClass.IsTemplate)
{
complierText.Append('(');
foreach (VCCodeParameter parameter in codeClass.TemplateParameters)
{
complierText.Append(parameter.DisplayName + ',');
}
complierText[complierText.Length - 1] = ')';
complierText.Append(',');
}
if (GetReflxString(codeClass.Functions as VCCodeElements,
codeClass.Variables as VCCodeElements,
complierText))
{
return(null);
}
}
break;
case vsCMElement.vsCMElementStruct:
if (codeElement is VCCodeStruct codeStruct)
{
if (codeStruct.IsTemplate)
{
complierText.Append('(');
foreach (VCCodeParameter parameter in codeStruct.TemplateParameters)
{
complierText.Append(parameter.DisplayName + ',');
}
complierText[complierText.Length - 1] = ')';
complierText.Append(',');
}
if (GetReflxString(codeStruct.Functions as VCCodeElements,
codeStruct.Variables as VCCodeElements,
complierText))
{
return(null);
}
}
break;
default:
return(null);
}
complierText.Append(");");
return(complierText);
}
public static void CalcReflx(DTE dte)
{
//var textView = session.TextView;
//var lineText = textView.Selection.ActivePoint.Position.GetContainingLine().Extent.GetText();
Document activeDocument = dte.ActiveDocument;
TextSelection textSelection = activeDocument.Selection as TextSelection;
if (textSelection == null)
{
return;
}
VirtualPoint activePoint = textSelection.ActivePoint;
var editPoint = activePoint.CreateEditPoint();
editPoint.StartOfLine();
var lineText = editPoint.GetText(activePoint.LineCharOffset);
var text = lineText.Trim();
var pattenBegin = "reflex(";
var pattenEnd = ")";
if (!text.StartsWith(pattenBegin) || !text.EndsWith(pattenEnd))
{
return;
}
if (!(activeDocument.ProjectItem.FileCodeModel is VCFileCodeModel fileCodeModel))
{
return;
}
text = text.Substring(pattenBegin.Length);
text = text.Remove(text.Length - pattenEnd.Length);
VCCodeElement[] codeElements;
{
var vcCodeElements = (fileCodeModel.CodeElementFromFullName(text) as VCCodeElements);
if (vcCodeElements == null || vcCodeElements.Count == 0)
{
return;
}
codeElements = vcCodeElements.Cast <VCCodeElement>().ToArray();
}
BEGIN_CAST:
if (codeElements.Length == 0)
{
return;
}
if (codeElements.Length != 1)
{
List <VCCodeElement> finders = new List <VCCodeElement>();
bool maybeClassOrStruct = text.Contains("::");
foreach (VCCodeElement element in codeElements)
{
VCCodeElement parent = element;
// 根据情况,往上查找几层
for (int i = maybeClassOrStruct ? 0 : 1; i < 2; i++)
{
parent = parent.Parent as VCCodeElement;
if (parent == null)
{
break;
}
if (parent.StartPoint.LessThan(activePoint) && parent.EndPoint.GreaterThan(activePoint))
{
finders.Add(element);
}
}
}
if (finders.Count == 0)
{
return;
}
codeElements = finders.ToArray();
}
VCCodeElement curCodeElement = codeElements[0];
if (curCodeElement == null || curCodeElement.Kind == vsCMElement.vsCMElementNamespace)
{
return;
}
if (curCodeElement.Kind == vsCMElement.vsCMElementTypeDef ||
curCodeElement.Kind == (vsCMElement)2000)
{
if (codeElements.Length > 1)
{
return;
}
if (curCodeElement is VCCodeTypedef codeTypedef)
{
codeElements = fileCodeModel.CodeElementFromFullName(codeTypedef
.TypeString).Cast <VCCodeElement>().ToArray();
goto BEGIN_CAST;
}
}
var reflexHeader = GetComplierTextHeader(codeElements.Length, curCodeElement);
if (reflexHeader == null)
{
return;
}
StringBuilder allComplerText = null;
foreach (VCCodeElement codeElement in codeElements)
{
var complierText = ComplierText(reflexHeader, text, codeElement);
if (complierText == null)
{
continue;
}
if (allComplerText == null)
{
allComplerText = complierText;
}
else
{
allComplerText.Append("\r\n" + complierText);
}
}
if (allComplerText != null)
{
activeDocument.ReplaceText(lineText, allComplerText.ToString(),
(int)vsFindOptions.vsFindOptionsMatchWholeWord);
}
}
