private void RefreshHirearchy()
{
if (schemaTabView.Selected.Identifier.ToString() == "Hierarchy")
{
if (objectClassesList.SelectedRows.Count > 0)
{
HierarchyItemDatasource ds = new HierarchyItemDatasource(_currentObject);
var mgr = _serverDTO.Connection.SchemaManager;
var dto = mgr.GetObjectClass(_currentObject);
HierarchyItem rootItem = new HierarchyItem(_currentObject);
HierarchyItem prevItem = rootItem;
while (dto != null)
{
dto = mgr.GetObjectClass(dto.SuperClass);
if (dto != null)
{
HierarchyItem currItem = new HierarchyItem(dto.Name);
prevItem.Children.Add(currItem);
prevItem = currItem;
}
ds.Item = rootItem;
}
this.HierarchyOutlineView.DataSource = ds;
this.HierarchyOutlineView.ReloadData();
}
}
}
private void PromptAndDelete(HierarchyItem item, IVsHierarchyDeleteHandler deleteHandler, __VSDELETEITEMOPERATION deleteType, string message)
{
Guid unused = Guid.Empty;
// show delete dialog...
if (ErrorHandler.Succeeded(
_mockVs.UIShell.ShowMessageBox(
0,
ref unused,
null,
message,
null,
0,
OLEMSGBUTTON.OLEMSGBUTTON_OKCANCEL,
OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST,
OLEMSGICON.OLEMSGICON_WARNING,
0,
out global::System.Int32 result
)) && result == DialogResult.OK)
{
int hr = deleteHandler.DeleteItem(
(uint)deleteType,
item.ItemId
);
if (ErrorHandler.Failed(hr) && hr != VSConstants.OLE_E_PROMPTSAVECANCELLED)
{
_mockVs.UIShell.ReportErrorInfo(hr);
}
}
}
private bool ShouldShowSpecificMessage(HierarchyItem item, int canRemoveItem, int canDeleteItem)
{
__VSDELETEITEMOPERATION op = 0;
if (canRemoveItem != 0)
{
op |= __VSDELETEITEMOPERATION.DELITEMOP_RemoveFromProject;
}
if (canDeleteItem != 0)
{
op |= __VSDELETEITEMOPERATION.DELITEMOP_DeleteFromStorage;
}
IVsHierarchyDeleteHandler2 deleteHandler = item.Hierarchy as IVsHierarchyDeleteHandler2;
if (deleteHandler != null)
{
deleteHandler.ShowSpecificDeleteRemoveMessage(
(uint)op,
1,
new[] { item.ItemId },
out global::System.Int32 dwShowStandardMessage,
out global::System.UInt32 pdwDelItemOp
);
return(dwShowStandardMessage != 0);
}
return(false);
}
private void PopulateTree(TestSuiteCollection suites)
{
fixingChecks = true;
// Preserve the original selection so that we can reselect them.
Dictionary <string, bool> selectedTests = SelectedTestCases;
// clear the current contents
testsTreeView.Nodes.Clear();
TreeNode solutionNode = new TreeNode();
HierarchyItem solHier = new HierarchyItem(suites.Solution as IVsHierarchy);
// Don't do anything if the solution is empty.
if (solHier.Name == null)
{
return;
}
solutionNode.Text = "Solution '" + solHier.Name + "'";
solutionNode.ImageKey = solutionNode.SelectedImageKey = "Solution";
testsTreeView.Nodes.Add(solutionNode);
foreach (TestSuite suite in suites.Suites)
{
AddTestSuiteToNode(suite, solutionNode, selectedTests);
}
fixingChecks = false;
testsTreeView.Sort();
solutionNode.ExpandAll();
}
protected override TreeViewItem BuildRoot()
{
// TODO:Remove
m_CachedSceneItems.Clear();
using (var searching = new SearchingScope(IsSearching, m_HierarchySearchFilter))
{
var root = new HierarchyItem {
id = int.MaxValue, depth = -1, displayName = "Root"
};
for (var i = 0; i < m_SceneManager.LoadedSceneCount; ++i)
{
var scene = m_SceneManager.GetLoadedSceneAtIndex(i);
if (m_CachedSceneItems.TryGetValue(scene.SceneGuid, out var item))
{
root.AddChild(item);
}
else
{
root.AddChild(LoadScene(scene, searching));
}
}
if (m_SceneManager.LoadedSceneCount == 0)
{
root.AddChild(new TreeViewItem(0, 0, "No scene loaded"));
}
ShouldReload = false;
return(root);
}
}
public HierarchyCollection<Heading> GetHeadingHierarchy(string html)
{
var hierarchy = new HierarchyCollection<Heading>();
var headingsStack = new Stack<HierarchyItem<Heading>>();
foreach (var heading in GetHeadings(html))
{
var hiearchyItem = new HierarchyItem<Heading>(heading);
var addedItem = false;
while (headingsStack.Count > 0)
{
// Keep looking up the heading hierarchy until we find the
// first item that is a higher heading type than the current
// heading
var parentHeading = headingsStack.Peek();
if (parentHeading.Item.HeadingType < heading.HeadingType)
{
headingsStack.Push(hiearchyItem);
parentHeading.Children.Add(hiearchyItem);
addedItem = true;
break;
}
headingsStack.Pop();
}
if (!addedItem)
{
headingsStack.Push(hiearchyItem);
hierarchy.Add(hiearchyItem);
}
}
return hierarchy;
}
// -------------------------------------------------------------------
/// <summary>
/// Creates a new submittable physical item.
/// </summary>
/// <param name="rootPath">
/// The root path of the solution that contains this item.
/// </param>
/// <param name="project">
/// The project that contains this item.
/// </param>
/// <param name="hierItem">
/// The hierarchy item that this item represents.
/// </param>
public SubmittablePhysicalItem(string rootPath, IVsProject project,
HierarchyItem hierItem)
{
this.rootPath = rootPath;
this.project = project;
this.hierarchy = hierItem;
}
private void DropUponSceneItem(HierarchyItem parent, List <ISceneGraphNode> nodes)
{
SceneGuid guid;
switch (parent)
{
case EntityItem entityItem:
{
guid = m_EntityManager.GetSharedComponentData <SceneGuid>(entityItem.Entity);
break;
}
case SceneItem sceneItem:
{
guid = sceneItem.Scene.SceneGuid;
break;
}
}
var graph = m_SceneManager.GetGraphForScene(guid);
Assert.IsNotNull(graph);
foreach (var node in nodes)
{
graph.Add(node);
}
SetSelectionAndExpandedState(nodes);
}
public override void OnFocus()
{
GameObject[] parentObjects;
if (sceneOpen)
{
parentObjects = UnityEngine.SceneManagement.SceneManager.GetActiveScene().GetRootGameObjects();
}
else // Prefabs
{
var prefabs = ES3ReferenceMgr.Current.prefabs;
parentObjects = new GameObject[prefabs.Count];
for (int i = 0; i < prefabs.Count; i++)
{
if (prefabs[i] != null)
{
parentObjects[i] = prefabs[i].gameObject;
}
}
}
hierarchy = new HierarchyItem[parentObjects.Length];
for (int i = 0; i < parentObjects.Length; i++)
{
if (parentObjects[i] != null)
{
hierarchy[i] = new HierarchyItem(parentObjects[i].transform, null, this);
}
}
}
// ------------------------------------------------------
/// <summary>
/// Adds a tree node for the specified hierarchy item to a tree node
/// collection.
/// </summary>
/// <param name="item">
/// A hierarchy item.
/// </param>
/// <param name="coll">
/// The <code>TreeNodeCollection</code> to add the new node to.
/// </param>
private void AddNode(HierarchyItem item,
TreeNodeCollection coll)
{
// Skip the item if it is not one of the visible types.
Guid typeGuid = item.TypeGuid;
if (visibleTypeGuids != null &&
Array.IndexOf(visibleTypeGuids, typeGuid) == -1)
{
return;
}
// Add the item's icon to the end of the image list.
imageList.Images.Add(item.Icon);
int imageIndex = imageList.Images.Count - 1;
TreeNode node = new TreeNode();
node.Text = item.Caption;
node.ImageIndex = node.SelectedImageIndex = imageIndex;
node.Tag = item;
coll.Add(node);
// Recurse through the item's children.
foreach (HierarchyItem child in item.Children)
{
AddNode(child, node.Nodes);
}
node.Expand();
}
private static HierarchyItem buildHierarchy(IEnumerable <Item> elements)
{
RootHierarchyItem root = new RootHierarchyItem();
Dictionary <string, HierarchyItem> map = new Dictionary <string, HierarchyItem>();
foreach (Item itm in elements)
{
HierarchyItem e = new HierarchyItem(itm);
try
{
map.Add(itm.OtherData["DbKey"], e);
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
foreach (HierarchyItem i in map.Values)
{
if (i.AssociatedItem.OtherData["ParentDbKey"] != null && map.ContainsKey(i.AssociatedItem.OtherData["ParentDbKey"]))
{
map[i.AssociatedItem.OtherData["ParentDbKey"]].AddChild(i);
}
else
{
if (i.HasParent())
{
}
root.AddChild(i);
}
}
return(root);
}
//~ Methods ..........................................................
// ------------------------------------------------------
/// <summary>
/// Called when the Finish button is clicked in the wizard.
/// </summary>
/// <param name="e">
/// An <code>EventArgs</code> object.
/// </param>
protected override void OnFinish(EventArgs e)
{
base.OnFinish(e);
HierarchyItem projectItem = page1.SelectedProject;
string suiteName = page1.SuiteName;
HierarchyItem headerUnderTest = page1.HeaderUnderTest;
string superclass = page1.Superclass;
bool createSetUp = page1.CreateSetUp;
bool createTearDown = page1.CreateTearDown;
VCCodeFunction[] functions = page2.SelectedFunctions;
// Invoke the test suite generator to create the file and add it
// to the project.
TestSuiteGenerator generator = new TestSuiteGenerator(
projectItem, suiteName, headerUnderTest, superclass,
createSetUp, createTearDown, functions);
generator.Generate();
// Open the new test suite in the IDE.
HierarchyItem suiteFile = generator.GeneratedSuiteFile;
IVsProject vsproj = projectItem.Hierarchy as IVsProject;
Guid guidNull = Guid.Empty;
IVsWindowFrame windowFrame;
vsproj.OpenItem(suiteFile.ItemID, ref guidNull, IntPtr.Zero, out windowFrame);
}
private void AddChildItem(HierarchyItem item, bool isIncludeDelete)
{
if (isIncludeDelete)
{
foreach (HierarchyItem tvi in item.GetAllChildItem(true))
{
allDethChildItem.Add(tvi);
if (tvi.GetChildrenCount() > 0)
{
AddChildItem(tvi, true);
}
}
}
else
{
foreach (HierarchyItem tvi in item.GetAllChildItem(false))
{
allDethChildItem.Add(tvi);
if (tvi.GetChildrenCount() > 0)
{
AddChildItem(tvi, false);
}
}
}
}
public string Dump(HierarchyItem <Account> account)
{
var shiftedName = new string(' ', account.Level * 2) + account.Item.Name;
var parentForDump = account.Item.Parent?.Id ?? 0;
return(account.Item.Id + " ; " + shiftedName + " ; " + parentForDump + " ; " +
account.Item.IsFolder + " ; " + account.Item.IsClosed + " ; " + account.Item.IsExpanded);
}
private HierarchyItem CreateNode(XElement element, HierarchyData data)
{
HierarchyItem item;
item = new HierarchyItem(data);
item.Icons[(VSConstants.VSITEMID.Root, __VSHIERARCHYIMAGEASPECT.HIA_OpenFolderIcon)] = GetImageMoniker(element, "expanded");
/// <summary>
/// 移除资源树子物体
/// </summary>
public void RemoveChildren(HierarchyItem children)
{
if (_treeChildren == null)
{
return;
}
_treeChildren.Remove(children);
}
public static void Export(string path, HierarchyItem<Point3D> points)
{
Type tp;
if (exporters.TryGetValue(Path.GetExtension(path).ToLowerInvariant(), out tp))
{
((IHierarchyItemExporter<Point3D>)Activator.CreateInstance(tp)).Export(path, points);
}
}
private void DropUponEntityItem(HierarchyItem parent, List <ISceneGraphNode> nodes)
{
var item = parent as EntityItem;
var parentNode = item.Node;
var graph = m_SceneManager.GetGraphForScene(m_EntityManager.GetSharedComponentData <SceneGuid>(item.Entity));
graph.Insert(-1, nodes, parentNode);
SetSelectionAndExpandedState(nodes);
}
/// <summary>
/// 给资源树添加子物体
/// </summary>
public void AddChildren(HierarchyItem children)
{
if (_treeChildren == null)
{
_treeChildren = new List <HierarchyItem>();
}
_treeChildren.Add(children);
}
public int OnBeforeCloseProject(IVsHierarchy pHierarchy, int fRemoved)
{
string name = new HierarchyItem(pHierarchy).CanonicalName;
uint cookie = hierarchyCookies[name];
pHierarchy.UnadviseHierarchyEvents(cookie);
return(VSConstants.S_OK);
}
public void SetParent(HierarchyItem parent)
{
this.parent = parent;
var textPosition = parent.text.transform.localPosition;
var x = textPosition.x + Constants.HIERARCHY_ITEM_SPACE_LEVEL;
var pos = text.transform.localPosition;
text.transform.localPosition = new Vector3(x, pos.y, pos.z);
parent.arrowImage.enabled = true;
}
/// <summary>
/// 给资源树插入子物体
/// </summary>
public void InsertChildren(HierarchyItem indexOfItem, HierarchyItem insertItem)
{
if (_treeChildren == null)
{
_treeChildren = new List <HierarchyItem>();
_treeChildren.Add(insertItem);
return;
}
_treeChildren.Insert(_treeChildren.IndexOf(indexOfItem), insertItem);
}
private void ShowHierarchy(DataBand dataBand, int rowCount)
{
HierarchyItem rootItem = MakeHierarchy(dataBand, rowCount);
if (rootItem == null)
{
return;
}
ShowHierarchy(dataBand, rootItem, 1, "");
}
internal void PopulateWithHeader(HierarchyItem headerUnderTest)
{
functionsTree.Nodes.Clear();
ProjectItem projectItem = headerUnderTest.GetExtObjectAs<ProjectItem>();
VCFileCodeModel codeModel = projectItem.FileCodeModel as VCFileCodeModel;
PopulateRecursively(functionsTree.Nodes, codeModel.CodeElements);
functionsTree.ExpandAll();
}
internal void PopulateWithHeader(HierarchyItem headerUnderTest)
{
functionsTree.Nodes.Clear();
ProjectItem projectItem = headerUnderTest.GetExtObjectAs <ProjectItem>();
VCFileCodeModel codeModel = projectItem.FileCodeModel as VCFileCodeModel;
PopulateRecursively(functionsTree.Nodes, codeModel.CodeElements);
functionsTree.ExpandAll();
}
// ------------------------------------------------------
/// <summary>
/// Gets the path to the executable file generated by the active
/// configuration of the specified project.
/// </summary>
/// <param name="projectHier">
/// The project to get the executable file for.
/// </param>
/// <returns>
/// The full path to the executable generated by the active
/// configuration for this project.
/// </returns>
private string GetActiveExecutablePath(HierarchyItem projectHier)
{
Project project = projectHier.GetExtObjectAs <Project>();
Configuration activeConfig =
project.ConfigurationManager.ActiveConfiguration;
string outputPath =
activeConfig.Properties.Item("OutputPath").Value as string;
string outputName = ((object[])activeConfig.OutputGroups.Item(
"Built").FileNames)[0] as string;
return(Path.Combine(outputPath, outputName));
}
private void DropBetweenSceneItems(HierarchyItem parent, List <ISceneGraphNode> nodes, int insertAtIndex)
{
// Can't add entities before the first group.
if (insertAtIndex <= 0)
{
return;
}
var graph = m_SceneManager.GetGraphForScene((parent.children[insertAtIndex - 1] as SceneItem).Scene.SceneGuid);
graph.Add(nodes);
SetSelectionAndExpandedState(nodes);
}
public void OnBeginDrag(PointerEventData eventData)
{
if (draggedInstance.IsNotNull())
{
Destroy(draggedInstance.gameObject);
}
if (!draggable)
{
return;
}
draggedInstance = Instantiate <HierarchyItem>(this, eventData.position, Quaternion.identity, canvas.transform);
draggedInstance.rectTransform.pivot = new Vector2(0f, 1f);
dragging = true;
}
// ------------------------------------------------------
/// <summary>
/// Creates the test runner source file for the current startup
/// project and adds it to the project.
/// </summary>
/// <param name="doNotRunTests">
/// If true, the file will be generated but will not include any
/// statements to run any tests. If false, the tests will be run
/// based on the current selection in the CxxTest Suites view.
/// </param>
public void CreateTestRunnerFile(bool doNotRunTests)
{
TestSuiteCollection suites = AllTestSuites;
Dictionary <string, bool> testsToRun;
if (doNotRunTests)
{
testsToRun = null;
}
else
{
testsToRun = TryToGetTestsToRun();
}
HierarchyItem startupProject =
VsShellUtils.GetStartupProject(this);
string projectDir = startupProject.ProjectDirectory;
string workingDir = GetActiveWorkingDirectory(startupProject);
Project project = startupProject.GetExtObjectAs <Project>();
string runnerPath = Path.Combine(
projectDir, Constants.TestRunnerFilename);
// Remove the file from the project if necessary, and delete it
// from the file system if it exists.
VCProject vcproj = (VCProject)project.Object;
if (!vcproj.CanAddFile(runnerPath))
{
IVCCollection coll = (IVCCollection)vcproj.Files;
vcproj.RemoveFile(coll.Item(Constants.TestRunnerFilename));
}
if (File.Exists(runnerPath))
{
File.Delete(runnerPath);
}
TestRunnerGenerator generator =
new TestRunnerGenerator(runnerPath, suites, testsToRun);
generator.Generate();
// Add the file to the project.
vcproj.AddFile(runnerPath);
}
//private AutoSaveWindow window;
public HierarchyItem(Transform t, HierarchyItem parent, AutoSaveWindow window)
{
this.autoSave = t.GetComponent <ES3AutoSave>();
this.t = t;
this.components = t.GetComponents <Component>();
children = new HierarchyItem[t.childCount];
for (int i = 0; i < t.childCount; i++)
{
children[i] = new HierarchyItem(t.GetChild(i), this, window);
}
//this.window = window;
}
/// <summary>
/// change the visual of the editor config for this object
/// </summary>
/// <param name="selectedObject"></param>
/// <param name="iconType"></param>
/// <param name="_IsIconRecursive"></param>
/// <param name="coreBackground"></param>
/// <param name="_IsBackgroundRecursive"></param>
public static void AddCustomEditorToObject(GameObject selectedObject, bool create = true,
HierarchyIcon iconType = HierarchyIcon.None,
bool _IsIconRecursive = false,
Borodar.RainbowCore.CoreBackground coreBackground = Borodar.RainbowCore.CoreBackground.None,
bool _IsBackgroundRecursive = false)
{
GameObject hierarchy = GameObject.Find("RainbowHierarchyConf");
HierarchySceneConfig hierarchySceneConfig = hierarchy.GetComponent <HierarchySceneConfig>();
if (hierarchySceneConfig)
{
HierarchyItem newItem = hierarchySceneConfig.GetItem(selectedObject);
if (newItem == null)
{
if (!create)
{
return;
}
newItem = new HierarchyItem(HierarchyItem.KeyType.Object, selectedObject, selectedObject.name)
{
IconType = HierarchyIcon.None,
IsIconRecursive = false,
BackgroundType = Borodar.RainbowCore.CoreBackground.ClrIndigo,
IsBackgroundRecursive = false,
};
hierarchySceneConfig.AddItem(newItem);
}
else
{
if (!create)
{
hierarchySceneConfig.RemoveAll(selectedObject, HierarchyItem.KeyType.Object);
}
else
{
hierarchySceneConfig.RemoveAll(selectedObject, HierarchyItem.KeyType.Object);
newItem = new HierarchyItem(HierarchyItem.KeyType.Object, selectedObject, selectedObject.name)
{
IconType = HierarchyIcon.None,
IsIconRecursive = false,
BackgroundType = Borodar.RainbowCore.CoreBackground.ClrIndigo,
IsBackgroundRecursive = false,
};
hierarchySceneConfig.AddItem(newItem);
}
}
}
}
public TestSuiteGenerator(HierarchyItem project,
string suiteName, HierarchyItem headerUnderTest,
string superclass, bool createSetUp, bool createTearDown,
VCCodeFunction[] functions)
{
this.project = project;
this.suiteName = suiteName;
this.headerUnderTest = headerUnderTest;
this.superclass = superclass;
this.createSetUp = createSetUp;
this.createTearDown = createTearDown;
this.functions = functions;
GenerateUniqueStubNames();
}
public TestSuiteGenerator(HierarchyItem project,
string suiteName, HierarchyItem headerUnderTest,
string superclass, bool createSetUp, bool createTearDown,
VCCodeFunction[] functions)
{
this.project = project;
this.suiteName = suiteName;
this.headerUnderTest = headerUnderTest;
this.superclass = superclass;
this.createSetUp = createSetUp;
this.createTearDown = createTearDown;
this.functions = functions;
GenerateUniqueStubNames();
}
private void headerUnderTestBrowseButton_Click(object sender, EventArgs e)
{
HierarchyItemDialog dialog = new HierarchyItemDialog(serviceProvider);
dialog.Message = "Choose a header file in your project to generate a test suite from.";
dialog.SelectableTypeGuids = new Guid[] { VSConstants.GUID_ItemType_PhysicalFile };
if (dialog.ShowDialog() == DialogResult.OK)
{
HierarchyItem item = dialog.SelectedItem;
this.headerUnderTest = item;
headerUnderTestField.Text = item.ProjectRelativePath;
}
}
public int OnAfterOpenProject(IVsHierarchy pHierarchy, int fAdded)
{
HierarchyEventsHandler events = new HierarchyEventsHandler(
solution, pHierarchy);
uint cookie;
pHierarchy.AdviseHierarchyEvents(events, out cookie);
string name = new HierarchyItem(pHierarchy).CanonicalName;
hierarchyCookies[name] = cookie;
if(fAdded != 0)
CxxTestPackage.Instance.TryToRefreshTestSuitesView();
return VSConstants.S_OK;
}
public virtual void BuildTableOfContentsItem(StringBuilder builder, HierarchyItem<Heading> heading)
{
if (builder == null)
throw new ArgumentNullException("builder");
if (heading == null)
throw new ArgumentNullException("heading");
StartHierarchyItem(builder);
builder.Append("<a href=\"#");
builder.Append(heading.Item.AnchorName);
builder.Append("\">");
builder.Append(heading.Item.Title);
builder.Append("</a>");
BuildTableOfContentsLayer(builder, heading.Children);
EndHierarchyItem(builder);
}
public VsProjectViewFolder(ISparkSource source, IVsHierarchy hierarchy)
{
_source = source;
_hierarchy = hierarchy;
_root = new HierarchyItem(_hierarchy, 0xfffffffe);
var child = _root.FirstChild;
while (child != null)
{
if (string.Equals(child.Name, "Views", StringComparison.InvariantCultureIgnoreCase))
{
_views = child;
break;
}
child = child.NextSibling;
}
}
//~ Constructor ......................................................
// ------------------------------------------------------
/// <summary>
/// Creates a new CxxTest suite generating wizard.
/// </summary>
/// <param name="sp">
/// The service provider to use to access Visual Studio services.
/// </param>
/// <param name="headerUnderTest">
/// The hierarchy item representing the header that the test suite
/// should be generated from.
/// </param>
public NewCxxTestSuiteWizard(IServiceProvider sp,
HierarchyItem headerUnderTest)
{
serviceProvider = sp;
// Create the wizard pages and add them to the wizard.
page1 = new NewCxxTestSuiteWizardPage1(sp, headerUnderTest);
page2 = new NewCxxTestSuiteWizardPage2(sp);
AddPage(page1);
AddPage(page2);
this.BannerTitle = "New CxxTest Suite";
this.BannerMessage = "Select the name of the new CxxTest suite. " +
"You have the options to specify the header of the class " +
"under test and on the next page, the methods to be tested.";
}
internal NewCxxTestSuiteWizardPage1(IServiceProvider sp, HierarchyItem headerUnderTest)
{
InitializeComponent();
serviceProvider = sp;
this.headerUnderTest = headerUnderTest;
// Initialize the project list.
foreach (HierarchyItem item in VsShellUtils.GetLoadedProjects(serviceProvider))
{
existingProjectsCombo.Items.Add(new ProjectItem(item));
}
if (headerUnderTest != null)
{
string header = headerUnderTest.ProjectRelativePath;
headerUnderTestField.Text = header;
nameField.Text = Path.GetFileNameWithoutExtension(header) + "Tests";
bool madeSelection = false;
foreach (ProjectItem item in existingProjectsCombo.Items)
{
if (item.Item.Equals(headerUnderTest.ContainingProject))
{
existingProjectsCombo.SelectedItem = item;
madeSelection = true;
break;
}
}
if (!madeSelection)
{
existingProjectsCombo.SelectedIndex = 0;
}
}
superclassField.Text = "CxxTest::TestSuite";
}
public void RefreshFromLastRun()
{
containingProject = CxxTestPackage.Instance.LastRunProject;
suiteResults = CxxTestPackage.Instance.SuiteResultsOfLastRun;
derefereeResults = CxxTestPackage.Instance.DerefereeResultsOfLastRun;
if(hierarchyButton.Checked)
SwitchToHierarchyView();
else
hierarchyButton.Checked = true;
int total, failures, errors;
CountTestCases(out total, out failures, out errors);
testResultsProgress.Minimum = 0;
testResultsProgress.Maximum = total;
testResultsProgress.Value = total - failures - errors;
testResultsProgress.Mode = PassFailBarMode.Bar;
runsLabel.Text = string.Format("Runs: {0}", total);
errorsLabel.Text = string.Format("Errors: {0}", errors);
failuresLabel.Text = string.Format("Failures: {0}", failures);
}
// ------------------------------------------------------
/// <summary>
/// Called just before the form is closed.
/// </summary>
/// <param name="e">
/// A <code>CancelEventArgs</code> object.
/// </param>
protected override void OnClosing(CancelEventArgs e)
{
base.OnClosing(e);
// Keep track of the user's selection if they verified it by
// pressing OK.
if (DialogResult == DialogResult.OK)
{
selectedItem =
(HierarchyItem)hierarchyItemTree.SelectedNode.Tag;
}
}
// ------------------------------------------------------
/// <summary>
/// Adds a tree node for the specified hierarchy item to a tree node
/// collection.
/// </summary>
/// <param name="item">
/// A hierarchy item.
/// </param>
/// <param name="coll">
/// The <code>TreeNodeCollection</code> to add the new node to.
/// </param>
private void AddNode(HierarchyItem item,
TreeNodeCollection coll)
{
// Skip the item if it is not one of the visible types.
Guid typeGuid = item.TypeGuid;
if (visibleTypeGuids != null &&
Array.IndexOf(visibleTypeGuids, typeGuid) == -1)
return;
// Add the item's icon to the end of the image list.
imageList.Images.Add(item.Icon);
int imageIndex = imageList.Images.Count - 1;
TreeNode node = new TreeNode();
node.Text = item.Caption;
node.ImageIndex = node.SelectedImageIndex = imageIndex;
node.Tag = item;
coll.Add(node);
// Recurse through the item's children.
foreach (HierarchyItem child in item.Children)
AddNode(child, node.Nodes);
node.Expand();
}
private void PopulateTree(TestSuiteCollection suites)
{
fixingChecks = true;
// Preserve the original selection so that we can reselect them.
Dictionary<string, bool> selectedTests = SelectedTestCases;
// clear the current contents
testsTreeView.Nodes.Clear();
TreeNode solutionNode = new TreeNode();
HierarchyItem solHier = new HierarchyItem(suites.Solution as IVsHierarchy);
// Don't do anything if the solution is empty.
if (solHier.Name == null)
return;
solutionNode.Text = "Solution '" + solHier.Name + "'";
solutionNode.ImageKey = solutionNode.SelectedImageKey = "Solution";
testsTreeView.Nodes.Add(solutionNode);
foreach(TestSuite suite in suites.Suites)
{
AddTestSuiteToNode(suite, solutionNode, selectedTests);
}
fixingChecks = false;
testsTreeView.Sort();
solutionNode.ExpandAll();
}
private void RefreshHirearchy ()
{
if (schemaTabView.Selected.Identifier.ToString () == "Hierarchy") {
if (objectClassesList.SelectedRows.Count > 0) {
HierarchyItemDatasource ds = new HierarchyItemDatasource (_currentObject);
var mgr = _serverDTO.Connection.SchemaManager;
var dto = mgr.GetObjectClass (_currentObject);
HierarchyItem rootItem = new HierarchyItem (_currentObject);
HierarchyItem prevItem = rootItem;
while (dto != null) {
dto = mgr.GetObjectClass (dto.SuperClass);
if (dto != null) {
HierarchyItem currItem = new HierarchyItem (dto.Name);
prevItem.Children.Add (currItem);
prevItem = currItem;
}
ds.Item = rootItem;
}
this.HierarchyOutlineView.DataSource = ds;
this.HierarchyOutlineView.ReloadData ();
}
}
}
// ------------------------------------------------------
/// <summary>
/// Gets the path to the working directory used by the active
/// configuration of the specified project.
/// </summary>
/// <param name="projectHier">
/// The project to get the working directory for.
/// </param>
/// <returns>
/// The full path to the working directory used by the active
/// configuration for this project.
/// </returns>
private string GetActiveWorkingDirectory(HierarchyItem projectHier)
{
Project project = projectHier.GetExtObjectAs<Project>();
Configuration activeConfig =
project.ConfigurationManager.ActiveConfiguration;
Property workingDirProp =
activeConfig.Properties.Item("WorkingDirectory");
string workingDir = workingDirProp.Value as string;
if (string.IsNullOrEmpty(workingDir))
workingDir = projectHier.ProjectDirectory;
return workingDir;
}
public void Generate()
{
string projectDir = project.ProjectDirectory;
string headerName = suiteName + ".h";
string suitePath = Path.Combine(projectDir, headerName);
StreamWriter writer = File.CreateText(suitePath);
WriteHeaderFileContent(writer, suitePath);
writer.Close();
VCFilter testFilter = GetOrCreateTestFilter();
VCProjectItem item = (VCProjectItem)testFilter.AddFile(suitePath);
suiteFile = project.GetChildWithName(item.ItemName);
}
private static string GetDocumentPath(IVsHierarchy hierarchy, uint itemid)
{
var rootid = -2;
var rootItem = new HierarchyItem(hierarchy, (uint)rootid);
var viewItem = rootItem.FirstOrDefault(child => child.Name == "Views");
var docItem = new HierarchyItem(hierarchy, itemid);
var path = docItem.Name;
while (!Equals(docItem.Parent, viewItem) &&
!Equals(docItem.Parent, rootItem))
{
docItem = docItem.Parent;
path = docItem.Name + "\\" + path;
}
if (Equals(docItem.Parent, rootItem))
path = "$\\" + path;
return path;
}
// ------------------------------------------------------
/// <summary>
/// Gets the path to the executable file generated by the active
/// configuration of the specified project.
/// </summary>
/// <param name="projectHier">
/// The project to get the executable file for.
/// </param>
/// <returns>
/// The full path to the executable generated by the active
/// configuration for this project.
/// </returns>
private string GetActiveExecutablePath(HierarchyItem projectHier)
{
Project project = projectHier.GetExtObjectAs<Project>();
Configuration activeConfig =
project.ConfigurationManager.ActiveConfiguration;
string outputPath =
activeConfig.Properties.Item("OutputPath").Value as string;
string outputName = ((object[]) activeConfig.OutputGroups.Item(
"Built").FileNames)[0] as string;
return Path.Combine(outputPath, outputName);
}
// --------------------------------------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="HierarchyTraversalInfo"/> class.
/// </summary>
/// <param name="hierarchyNode">The hierarchy node.</param>
/// <param name="depth">The depth of the node.</param>
// --------------------------------------------------------------------------------------------
public HierarchyTraversalInfo(HierarchyItem hierarchyNode, int depth)
{
HierarchyNode = hierarchyNode;
Depth = depth;
}
private void headerUnderTestBrowseButton_Click(object sender, EventArgs e)
{
HierarchyItemDialog dialog = new HierarchyItemDialog(serviceProvider);
dialog.Message = "Choose a header file in your project to generate a test suite from.";
dialog.SelectableTypeGuids = new Guid[] { VSConstants.GUID_ItemType_PhysicalFile };
if (dialog.ShowDialog() == DialogResult.OK)
{
HierarchyItem item = dialog.SelectedItem;
this.headerUnderTest = item;
headerUnderTestField.Text = item.ProjectRelativePath;
}
}
public int OnBeforeCloseProject(IVsHierarchy pHierarchy, int fRemoved)
{
string name = new HierarchyItem(pHierarchy).CanonicalName;
uint cookie = hierarchyCookies[name];
pHierarchy.UnadviseHierarchyEvents(cookie);
return VSConstants.S_OK;
}
// ------------------------------------------------------
/// <summary>
/// Launches the tests for the solution.
/// </summary>
public void LaunchTests()
{
HierarchyItem startupProject =
VsShellUtils.GetStartupProject(this);
lastRunProject = startupProject;
if (startupProject == null)
return;
TryToSetTestResultsText("Running the tests...");
debuggerEvents.StartingTestRun = true;
uint flags =
(uint)__VSDBGLAUNCHFLAGS.DBGLAUNCH_StopDebuggingOnEnd;
string projectDir = startupProject.ProjectDirectory;
string workingDir = GetActiveWorkingDirectory(startupProject);
string exePath = GetActiveExecutablePath(startupProject);
Guid guidNativeOnlyEng =
new Guid("3B476D35-A401-11D2-AAD4-00C04F990171");
VsDebugTargetInfo debugTarget = new VsDebugTargetInfo();
debugTarget.bstrExe = exePath;
debugTarget.bstrCurDir = workingDir;
debugTarget.fSendStdoutToOutputWindow = 1;
debugTarget.grfLaunch = flags;
debugTarget.dlo = DEBUG_LAUNCH_OPERATION.DLO_CreateProcess;
debugTarget.clsidCustom = guidNativeOnlyEng;
VsShellUtilities.LaunchDebugger(this, debugTarget);
}
public ProjectItem(HierarchyItem item)
{
this.item = item;
}
// Constructor
public HierarchyItemDatasource (string currentObject)
{
Item = new HierarchyItem (currentObject);
}
// --------------------------------------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="HierarchyTraversalInfo"/> class.
/// </summary>
/// <param name="hierarchyNode">The hierarchy node.</param>
/// <param name="itemId">The item id.</param>
/// <param name="depth">The depth of the node.</param>
// --------------------------------------------------------------------------------------------
public HierarchyTraversalInfo(IVsHierarchy hierarchyNode, uint itemId, int depth)
{
HierarchyNode = new HierarchyItem(hierarchyNode, itemId);
Depth = depth;
}
