/// <summary> /// todo bzw. nachfrage: geht die methode findall nicht alleine alle elemente der collection durch? wird in der foreach-schleife dadurch nicht doppelt gearbeitet? /// Sucht rekusiv alle Kindelemente eines Knotens und ermittelt dessen Eingenschaften /// </summary> /// <param name="top">teh current tree object</param> /// <param name="collection">gibt die AutomationElement-Collection an</param> /// <param name="depth">gibt an wie tief der Suche ausgehend vom Root-Element an.</param> private void findChildrenOfNode(Object top, AutomationElementCollection collection, int depth) { #region set grantFilterStrategiesChildren if (collection != null && collection.Count > 0 && !strategyMgr.getSpecifiedTree().IsRoot(top)) { OSMElements.OSMElement osmTop = strategyMgr.getSpecifiedTree().GetData(top); if (osmTop.properties.grantFilterStrategiesChildren == null) { osmTop.properties.grantFilterStrategiesChildren = new List <string>(); } if (!osmTop.properties.grantFilterStrategiesChildren.Contains(Settings.filterStrategyTypeToUserName(this.GetType()))) { osmTop.properties.grantFilterStrategiesChildren.Add(Settings.filterStrategyTypeToUserName(this.GetType())); } } #endregion foreach (AutomationElement element in collection) { if (strategyMgr.getSpecifiedTree().Depth(top) < depth || depth <= -1) { OSMElements.OSMElement osmElement = new OSMElements.OSMElement(); osmElement.properties = setProperties(element); Object node = strategyMgr.getSpecifiedTree().AddChild(top, osmElement); AutomationElementCollection c = element.FindAll(TreeScope.Children, Condition.TrueCondition); findChildrenOfNode(node, c, depth); } } }
/// <summary> /// Seeks to an <see cref="OSMElements.OSMElement"/> the appropriate <see cref="AutomationElement"/> /// </summary> /// <param name="osmElement">OSM element</param> /// <returns>the appropriate <see cref="AutomationElement"</returns> private AutomationElement getAutomationelementOfOsmElement(OSMElements.OSMElement osmElement) { AutomationElement au; Condition cond = setPropertiesCondition(osmElement.properties); if (osmElement.properties.hWndFiltered != IntPtr.Zero) { //ist der Weg wirklich schneller? IntPtr pointer = strategyMgr.getSpecifiedOperationSystem().getProcessHwndFromHwnd(deliverElementID(osmElement.properties.hWndFiltered)); AutomationElement mainWindowElement = deliverAutomationElementFromHWND(pointer); //au = mainWindowElement.FindFirst(TreeScope.Children, cond); if (mainWindowElement == null) { return(null); } au = mainWindowElement.FindFirst(TreeScope.Subtree, cond); } else { if (grantTrees.filteredTree != null && strategyMgr.getSpecifiedTree().HasChild(grantTrees.filteredTree) && strategyMgr.getSpecifiedTree().GetData(strategyMgr.getSpecifiedTree().Child(grantTrees.filteredTree)).properties.hWndFiltered != IntPtr.Zero) { IntPtr hwnd = strategyMgr.getSpecifiedTree().GetData(strategyMgr.getSpecifiedTree().Child(grantTrees.filteredTree)).properties.hWndFiltered; //IntPtr pointer = strategyMgr.getSpecifiedOperationSystem().getProcessHwndFromHwnd(deliverElementID(strategyMgr.filteredTree.Child.Data.properties.hWndFiltered)); AutomationElement element = AutomationElement.FromHandle(hwnd); au = element.FindFirst(TreeScope.Descendants, cond); } else { au = AutomationElement.RootElement.FindFirst(TreeScope.Descendants, cond); //Attention: it is possible that another element will be found } } return(au); }
private OSMElements.OSMElement addElementInBrailleTree(object filteredNode, TextviewElement tve, int width, ref int startXPosition, int startYPosition) { OSMElements.OSMElement osmFiltered = strategyMgr.getSpecifiedTree().GetData(filteredNode); int depth = strategyMgr.getSpecifiedTree().Depth(filteredNode) * shiftingPerDepth; TextviewObject tvo = grantTrees.TextviewObject; OSMElements.OSMElement osmBraille = new OSMElements.OSMElement(); GeneralProperties propBraille = new GeneralProperties(); BrailleRepresentation braille = new BrailleRepresentation(); braille.isVisible = true; propBraille.controlTypeFiltered = "Text"; braille.isGroupChild = true; braille.typeOfView = tvo.typeOfView; braille.screenName = tvo.screenName; braille.displayedGuiElementType = tve.property; braille.viewName = osmFiltered.properties.IdGenerated + "_" + tve.order; propBraille.boundingRectangleFiltered = new Rect(startXPosition, startYPosition, width, 5);//TODO: richtig machen osmBraille.properties = propBraille; osmBraille.brailleRepresentation = braille; propBraille.IdGenerated = treeOperation.generatedIds.generatedIdBrailleNode(osmBraille); osmBraille.properties = propBraille; treeOperation.osmTreeConnector.addOsmConnection(osmFiltered.properties.IdGenerated, propBraille.IdGenerated); treeOperation.updateNodes.updateNodeOfBrailleUi(ref osmBraille); return(osmBraille); }
/// <summary> /// Generates an id for one node of the braille (output) tree. /// </summary> /// <param name="node">one node of the braille tree</param> /// <returns>the generated id</returns> public String generatedIdBrailleNode(OSMElements.OSMElement osmElement) { /* https://blogs.msdn.microsoft.com/csharpfaq/2006/10/09/how-do-i-calculate-a-md5-hash-from-a-string/ * http://stackoverflow.com/questions/12979212/md5-hash-from-string * http://stackoverflow.com/questions/10520048/calculate-md5-checksum-for-a-file */ GeneralProperties properties = osmElement.properties; BrailleRepresentation braille = osmElement.brailleRepresentation; String result = properties.controlTypeFiltered + braille.displayedGuiElementType + braille.screenName + braille.viewName + properties.boundingRectangleFiltered.ToString() + properties.controlTypeFiltered + (braille.typeOfView == null? "":braille.typeOfView) + (braille.uiElementSpecialContent == null? "": braille.uiElementSpecialContent.ToString()); byte[] hash; using (var md5 = MD5.Create()) { hash = md5.ComputeHash(Encoding.UTF8.GetBytes(result)); } StringBuilder sb = new StringBuilder(); foreach (byte b in hash) { sb.Append(b.ToString("X2")); } return(sb.ToString()); }
/// <summary> /// Adds all elements (of the subtree) as Sysmbols to the braille tree /// </summary> /// <param name="subtree">subtree to add as Symbols</param> /// <param name="lastRect">position of the last UI element which was added</param> /// <param name="idToIgnore">a list of all (ids of) elements which should NOT be added as symbol</param> public void addsAllElementsAsSymbols(object subtree, ref Rect lastRect, string[] idToIgnore = null) { ATemplateUi generalUiInstance = new TemplateNode(strategyMgr, grantTrees, treeOperation); RendererUiElementConnector defaultRendererUiConnector = new RendererUiElementConnector("Text", "Text", new RendererUiElementConnector.SizeUiElement(5, 21)); foreach (Object node in strategyMgr.getSpecifiedTree().DirectChildrenNodes(subtree)) { /* Prüfen, ob der Knoten Ignoriert werden soll * nicht ignorieren -> Kinder * nur Kinder Zeichnen -> ControllType der Eltern beachten --> evtl. werden mehrere Kinder mit einmal dargestellt */ OSMElements.OSMElement osmNode = strategyMgr.getSpecifiedTree().GetData(node); if (idToIgnore == null || !idToIgnore.Contains(osmNode.properties.IdGenerated)) { RendererUiElementConnector connector = rendererUiElementConnectorContainsControltype(osmNode.properties.controlTypeFiltered); if (connector == null && strategyMgr.getSpecifiedTree().HasChild(node)) { //consider the children addsAllElementsAsSymbols(node, ref lastRect, idToIgnore); } else { if (connector == null) { connector = defaultRendererUiConnector; } //TODO: use a diffenent template for every element type? generalUiInstance.createUiElementFromTemplate(node, createTemplateObjectFromNode(node, connector, ref lastRect));//new type of view } } } }
/// <summary> /// Adds a parent element in the tree. /// </summary> /// <param name="parentElement">the parent Automation element</param> /// <param name="tree">the tree</param> private void addParentOfNode(AutomationElement parentElement, ref Object tree) { Object tree2 = getStrategyMgr().getSpecifiedTree().NewTree(); OSMElements.OSMElement osmElement = new OSMElements.OSMElement(); osmElement.properties = setProperties(parentElement); #region set grantFilterStrategiesChildren if (tree != null) { OSMElements.OSMElement osmChild = strategyMgr.getSpecifiedTree().GetData(tree); if (osmChild != null && !osmChild.Equals(new OSMElements.OSMElement())) { if (osmChild.properties.grantFilterStrategiesChildren != null) { osmElement.properties.grantFilterStrategiesChildren = osmChild.properties.grantFilterStrategiesChildren; } else { osmElement.properties.grantFilterStrategiesChildren = new List <string>(); osmElement.properties.grantFilterStrategiesChildren.Add(osmChild.properties.grantFilterStrategy); } } } #endregion Object node = strategyMgr.getSpecifiedTree().AddChild(tree2, osmElement); strategyMgr.getSpecifiedTree().AddChild(node, tree); strategyMgr.getSpecifiedTree().Clear(tree); strategyMgr.getSpecifiedTree().AddChild(tree, tree2); }
public void getScreenshotPointInApplicationTest() { initilaizeFilteredTree(); strategyMgr.getSpecifiedGeneralTemplateUi().generatedUiFromTemplate(pathToTemplate); strategyMgr.getSpecifiedBrailleDisplay().setActiveAdapter(); strategyMgr.getSpecifiedBrailleDisplay().generatedBrailleUi(); //in dem genutzten Template ist bei der View 'lv' der Screenshot strategyMgr.getSpecifiedBrailleDisplay().setVisibleScreen("lv"); int pointX = 6; int pointY = 42; Object nodeAtPoint = guiFuctions.getBrailleNodeAtPoint(pointX, pointY); int clickX; int clickY; guiFuctions.getScreenshotPointInApplication(nodeAtPoint, pointX, pointY, out clickX, out clickY); //nun folgt der Abgleich, ob die richtige Position ermittelt wurde => es sollte der Button '7' auf dem Taschenrechner sein OSMElements.OSMElement dataOfPoint = strategyMgr.getSpecifiedFilter().getOSMElement(clickX, clickY); Assert.AreEqual("Button", dataOfPoint.properties.controlTypeFiltered, "Es hätte der Button sein sollen!"); Assert.AreEqual("7", dataOfPoint.properties.nameFiltered, "auf dem Button hätte die Zahl '7' stehen müssen!"); List <Object> searchresult = treeOperation.searchNodes.getNodesByProperties(grantTrees.filteredTree, dataOfPoint.properties); Assert.AreNotEqual(null, searchresult, "Es hätte ein Knoten im gefilterten Baum gefunden werden müssen!"); Assert.AreNotEqual(new List <Object>(), searchresult, "Es hätte ein Knoten im gefilterten Baum gefunden werden müssen!"); Assert.AreEqual(1, searchresult.Count, "Es hätte genau ein Knoten gefunden werden müssen!"); strategyMgr.getSpecifiedBrailleDisplay().removeActiveAdapter(); guiFuctions.deleteGrantTrees(); }
/// <summary> /// Adds a navigatiobar for the screen /// </summary> /// <param name="pathToXml">path of the used template (XML)</param> /// <param name="screenName">name of the screen on wich the navigation bar should be added</param> /// <param name="typeOfView">name of the type of view in which the navigation bar should be added</param> public void addNavigationbarForScreen(string pathToXml, String screenName, String typeOfView) { TemplateUiObject templateObject = getTemplateUiObjectOfNavigationbarScreen(pathToXml); if (templateObject.Equals(new TemplateUiObject())) { return; } List <String> screens = treeOperation.searchNodes.getPosibleScreenNames(typeOfView); List <String> screenNavi = new List <string>(); //screenNavi.Add(strategyMgr.getSpecifiedTree().GetData(subtree).brailleRepresentation.screenName); screenNavi.Add(screenName); templateObject.Screens = screenNavi; List <OSMElements.OSMElement> groupElementsStatic = calculatePositionOfScreenTab(screens, templateObject); if (groupElementsStatic == null || groupElementsStatic.Equals(new List <OSMElements.OSMElement>())) { return; } templateObject.groupElements = groupElementsStatic; Object tree = grantTrees.filteredTree; BrailleRepresentation br = templateObject.osm.brailleRepresentation; br.groupelementsOfSameType = new GroupelementsOfSameType(); OSMElements.OSMElement osm = templateObject.osm; osm.brailleRepresentation = br; templateObject.osm = osm; ATemplateUi generalUiInstance = new TemplateGroupStatic(strategyMgr, grantTrees, treeOperation); generalUiInstance.createUiElementFromTemplate(tree, templateObject); }
/// <summary> /// Erstellt einen Braille-Tree, welcher zum Testen der suchen genutzt werden kann /// </summary> private void initilaizeBrailleTree2Screens() { #region 1. node OSMElements.OSMElement osm = new OSMElements.OSMElement(); osm.brailleRepresentation.isVisible = true; osm.brailleRepresentation.screenName = "TestScreen"; osm.brailleRepresentation.viewName = "TestView"; osm.brailleRepresentation.typeOfView = VIEWCATEGORYSYMBOLVIEW; osm.properties.boundingRectangleFiltered = new Rect(0, 0, 20, 10); osm.properties.controlTypeFiltered = "Text"; osm.properties.valueFiltered = "Test"; treeOperation.updateNodes.addNodeInBrailleTree(osm); #endregion #region 2. node OSMElements.OSMElement osm2 = new OSMElements.OSMElement(); osm2.brailleRepresentation.isVisible = true; osm2.brailleRepresentation.screenName = "TestScreen -2"; osm2.brailleRepresentation.viewName = "TestView"; osm2.brailleRepresentation.typeOfView = VIEWCATEGORYSYMBOLVIEW; osm2.properties.boundingRectangleFiltered = new Rect(0, 0, 20, 10); osm2.properties.controlTypeFiltered = "Text"; osm2.properties.valueFiltered = "Test"; treeOperation.updateNodes.addNodeInBrailleTree(osm2); #endregion }
public void updateImg() { if (grantTrees.filteredTree == null) { Console.WriteLine("Die Anwendung wurde noch nicht gefiltert - bitte 'F5' drücken"); return; } String brailleId = ""; GeneralProperties propertiesForSearch = new GeneralProperties(); propertiesForSearch.controlTypeFiltered = "Screenshot"; List <Object> treeElement = treeOperation.searchNodes.getNodesByProperties(grantTrees.brailleTree, propertiesForSearch, OperatorEnum.and); if (treeElement.Count > 0) { brailleId = strategyMgr.getSpecifiedTree().GetData(treeElement[0]).properties.IdGenerated; } if (brailleId.Equals("")) { return; } OsmTreeConnectorTuple osmRelationships = grantTrees.osmTreeConnections.Find(r => r.BrailleTreeId.Equals(brailleId) || r.FilteredTreeId.Equals(brailleId)); if (osmRelationships != null) { //strategyMgr.getSpecifiedFilter().updateNodeOfFilteredTree(osmRelationships.FilteredTree); treeOperation.updateNodes.filteredNodeElementOfApplication(osmRelationships.FilteredTreeId); OSMElements.OSMElement relatedBrailleTreeObject = treeOperation.searchNodes.getBrailleTreeOsmElementById(osmRelationships.BrailleTreeId); if (!relatedBrailleTreeObject.Equals(new OSMElements.OSMElement())) { strategyMgr.getSpecifiedBrailleDisplay().updateViewContent(ref relatedBrailleTreeObject); } } }
/// <summary> /// Wechselt zwischen screen1 und screen2 /// </summary> public void changeScreen(String name) { if (name.Equals("")) { return; } if (strategyMgr.getSpecifiedBrailleDisplay() == null) { return; } if (getPosibleScreens().Contains(name)) { strategyMgr.getSpecifiedBrailleDisplay().setVisibleScreen(name); } // ITreeStrategy<OSMElement.OSMElement> subtreeFiltered = strategyMgr.getSpecifiedTreeOperations().getSubtreeOfScreen(visibleScreen); //Screenshots aktualisieren beim Screen-Wechsel Object subnodesOfScreen = treeOperation.searchNodes.getSubtreeOfScreen(name); GeneralProperties prop = new GeneralProperties(); prop.controlTypeFiltered = "Screenshot"; List <Object> screenshotNodes = treeOperation.searchNodes.getNodesByProperties(subnodesOfScreen, prop); foreach (Object node in screenshotNodes) { OSMElements.OSMElement osmScreenshot = strategyMgr.getSpecifiedTree().GetData(node); strategyMgr.getSpecifiedBrailleDisplay().updateViewContent(ref osmScreenshot); strategyMgr.getSpecifiedTree().SetData(node, osmScreenshot); grantTrees.brailleTree = strategyMgr.getSpecifiedTree().Root(node); } }
/// <summary> /// filters the siblings of the AutomationElement /// </summary> /// <param name="automationElement">the AutomationElementn</param> /// <param name="tree">the tree object</param> private void filterSibling(AutomationElement automationElement, ref Object tree) { //TreeWalker walker = TreeWalker.ControlViewWalker; TreeWalker walker = TreeWalker.ContentViewWalker; AutomationElement elementParent = walker.GetParent(automationElement); int depth = 0; // filterChildren(elementParent, 0, ref tree); // depth is null ==> all siblings will be "top nodes" (see https://www.codeproject.com/Articles/12476/A-Generic-Tree-Collection ) //oder walker.GetPreviousSibling(mainElement); walker.GetNextSibling(mainElement); AutomationElementCollection collection = elementParent.FindAll(TreeScope.Children, Condition.TrueCondition); //findChildrenOfNode(tree, collection, depth); foreach (AutomationElement element in collection) { if (!element.Equals(automationElement) && (strategyMgr.getSpecifiedTree().Depth(tree) < depth || depth <= -1)) { OSMElements.OSMElement osmElement = new OSMElements.OSMElement(); osmElement.properties = setProperties(element); Object node = strategyMgr.getSpecifiedTree().AddChild(tree, osmElement); AutomationElementCollection c = element.FindAll(TreeScope.Children, Condition.TrueCondition); } } }
/// <summary> /// Setzt die Beziehung von dem "realen" GUI Element zu dem UI-Element auf der Stiftplatte umd die Darstellung eines Screenshots zu testen /// falls noch kein Baum gefiltert wurde, so wird die Anwendung gefiltert /// </summary> public void setOSMRelationshipImg() { if (strategyMgr.getSpecifiedOperationSystem().deliverCursorPosition()) { try { IFilterStrategy filterStrategy = strategyMgr.getSpecifiedFilter(); if (grantTree.filteredTree == null) { filterTreeOfApplication(); } if (strategyMgr.getSpecifiedOperationSystem().deliverCursorPosition()) { int pointX; int pointY; strategyMgr.getSpecifiedOperationSystem().getCursorPoint(out pointX, out pointY); OSMElements.OSMElement osmElement = filterStrategy.getOSMElement(pointX, pointY); GeneralProperties propertiesForSearch = new GeneralProperties(); propertiesForSearch.controlTypeFiltered = "Screenshot"; List <Object> treeElement = treeOperation.searchNodes.getNodesByProperties(grantTree.brailleTree, propertiesForSearch, OperatorEnum.and); if (treeElement.Count > 0) { treeOperation.osmTreeConnector.addOsmConnection(osmElement.properties.IdGenerated, strategyMgr.getSpecifiedTree().GetData(treeElement[0]).properties.IdGenerated); } } } catch (Exception ex) { Console.WriteLine("An error occurred: '{0}'", ex); } } }
/// <summary> /// filters a subtree /// </summary> /// <param name="element">the AutomationElement of the filtered element</param> /// <param name="tree">the tree object</param> private void filterSubtree(AutomationElement element, ref Object tree) { OSMElements.OSMElement osmElement = new OSMElements.OSMElement(); osmElement.properties = setProperties(element); Object treeTop = strategyMgr.getSpecifiedTree().AddChild(tree, osmElement); filterChildren(element, -1, ref treeTop); tree = strategyMgr.getSpecifiedTree().Root(treeTop); }
/// <summary> /// filters an application depending on a given OSM element /// </summary> /// <param name="osmElementOfFirstNodeOfSubtree">osm element of the to filtered application</param> /// <param name="treeScope">kind of filtering</param> /// <returns>the filtered (sub-)tree</returns> public Object filtering(OSMElements.OSMElement osmElementOfFirstNodeOfSubtree, TreeScopeEnum treeScope) { AutomationElement au = getAutomationelementOfOsmElement(osmElementOfFirstNodeOfSubtree); if (au != null) { return(filtering(au, treeScope, -1)); } return(null); }
/// <summary> /// searches a filtered node ID (in <c>grantTrees.filteredTree</c> ) by a given HWND /// </summary> /// <param name="hwnd">a hwnd of a node</param> /// <returns>the node ID OR <c>null</c></returns> public String getIdFilteredNodeByHwnd(IntPtr hwnd) { Object node = getFilteredNodeByHwnd(hwnd); if (node == null) { return(null); } OSMElements.OSMElement osmData = strategyMgr.getSpecifiedTree().GetData(node); return(osmData.properties.IdGenerated); }
/// <summary> /// Generates ids for the whole filtered tree. /// </summary> /// <param name="parentNode">reference to the filtered tree object</param> public void generatedIdsOfFilteredTree(ref Object tree) { foreach (Object node in strategyMgr.getSpecifiedTree().AllNodes(tree)) { if (strategyMgr.getSpecifiedTree().GetData(node).properties.IdGenerated == null) { OSMElements.OSMElement osm = strategyMgr.getSpecifiedTree().GetData(node); osm.properties.IdGenerated = generatedIdFilteredNode(node); strategyMgr.getSpecifiedTree().SetData(node, osm); } } }
/// <summary> /// Seeks new data for a node /// </summary> /// <param name="osmElementFilteredNode">OSM element to update</param> /// <returns>new properties for a node</returns> public GeneralProperties updateNodeContent(OSMElements.OSMElement osmElementFilteredNode) { GeneralProperties propertiesUpdated = new GeneralProperties(); AutomationElement au = getAutomationelementOfOsmElement(osmElementFilteredNode); if (au != null) { propertiesUpdated = setProperties(au); propertiesUpdated.IdGenerated = osmElementFilteredNode.properties.IdGenerated; } return(propertiesUpdated); }
/// <summary> /// filters an application deppending on a given AutomationElement (to the specified depth) /// </summary> /// <param name="element">the AutomationElement of the filtered element</param> /// <param name="depth">depth of filtering for the <paramref name="treeScope"/> of 'Parent', 'Children' and 'Application'; <code>-1</code> means the whole depth</param> /// <param name="tree">the tree object</param> private void filterApplication(AutomationElement element, int depth, ref Object tree) { IntPtr mainAppHwdn = strategyMgr.getSpecifiedOperationSystem().getProcessHwndFromHwnd(element.Current.ProcessId); AutomationElement mainAppAutomationelement = deliverAutomationElementFromHWND(mainAppHwdn); OSMElements.OSMElement osmElement = new OSMElements.OSMElement(); osmElement.properties = setProperties(mainAppAutomationelement); Object top = strategyMgr.getSpecifiedTree().AddChild(tree, osmElement); filterChildren(mainAppAutomationelement, -1, ref top); }
/// <summary> /// depending on the given properties, all nodes with these properties are searched (depth-first search). /// Properties which are null or the default value is set are ignore /// </summary> /// <param name="tree">tree object for search </param> /// <param name="properties">properties for the search</param> /// <param name="oper">Operator for combining the properties (and, or) </param> /// <returns>A list of the found tree objects</returns> public List <Object> getNodesByProperties(Object tree, OSMElements.OSMElement properties, OperatorEnum oper = OperatorEnum.and) { List <Object> result = new List <Object>(); if (tree == null) { return(result); } List <String> listOfUsedProperties = OSMElements.OSMElement.getAllTypes(); listOfUsedProperties = trimListOfProperties(listOfUsedProperties, properties); foreach (Object node in strategyMgr.getSpecifiedTree().AllNodes(tree)) { OSMElements.OSMElement nodeData = strategyMgr.getSpecifiedTree().GetData(node); Boolean isToAdd = true; foreach (String s in listOfUsedProperties) { Boolean resultEquals = false; var data_1 = OSMElements.OSMElement.getElement(s, nodeData); var data_2 = OSMElements.OSMElement.getElement(s, properties); if ((data_1 != null && data_1.Equals(data_2)) || (data_1 == null && data_2 == null)) { resultEquals = true; } else { resultEquals = false; } if (OperatorEnum.Equals(oper, OperatorEnum.and)) { isToAdd = isToAdd && resultEquals; if (!isToAdd) { break; } } else { if (OperatorEnum.Equals(oper, OperatorEnum.or)) { isToAdd = isToAdd || resultEquals; } } } if (isToAdd) { result.Add(node); } } return(result); }
private OSMElements.OSMElement createChildBrailleNode(Object filteredSubtree, TemplateUiObject templateObject, String viewName) { //TODO: falls eine Beziehung im Baum erstellt werden soll muss diese hier? noch gesetzt werden => geht nicht ID ist noch nicht vorhanden OSMElements.OSMElement brailleNode = templateObject.osm; GeneralProperties prop = templateObject.osm.properties; BrailleRepresentation braille = templateObject.osm.brailleRepresentation; prop.isEnabledFiltered = false; braille.isVisible = true; if (templateObject.osm.properties.controlTypeFiltered.Equals("DropDownMenuItem")) { OSMElements.UiElements.DropDownMenuItem dropDownMenu = new OSMElements.UiElements.DropDownMenuItem(); if (strategyMgr.getSpecifiedTree().HasChild(filteredSubtree) && strategyMgr.getSpecifiedTree().GetData(strategyMgr.getSpecifiedTree().Child(filteredSubtree)).properties.controlTypeFiltered.Contains("Item")) { dropDownMenu.hasChild = true; } if (strategyMgr.getSpecifiedTree().HasNext(filteredSubtree) && strategyMgr.getSpecifiedTree().GetData(strategyMgr.getSpecifiedTree().Next(filteredSubtree)).properties.controlTypeFiltered.Contains("Item")) { dropDownMenu.hasNext = true; } if (strategyMgr.getSpecifiedTree().HasPrevious(filteredSubtree) && strategyMgr.getSpecifiedTree().GetData(strategyMgr.getSpecifiedTree().Previous(filteredSubtree)).properties.controlTypeFiltered.Contains("Item")) { dropDownMenu.hasPrevious = true; } if (strategyMgr.getSpecifiedTree().HasParent(filteredSubtree) && strategyMgr.getSpecifiedTree().GetData(strategyMgr.getSpecifiedTree().Parent(filteredSubtree)).properties.controlTypeFiltered.Contains("Item")) { dropDownMenu.isChild = true; } dropDownMenu.isOpen = false; dropDownMenu.isVertical = false; braille.uiElementSpecialContent = dropDownMenu; } if (templateObject.osm.properties.controlTypeFiltered.Equals("TabItem")) { OSMElements.UiElements.TabItem tabView = new OSMElements.UiElements.TabItem(); //tabView.orientation = templateObject.orientation; //braille.uiElementSpecialContent = tabView; braille.uiElementSpecialContent = templateObject.osm.brailleRepresentation.uiElementSpecialContent; } if (templateObject.Screens == null) { Debug.WriteLine("Achtung, hier wurde kein Screen angegeben!"); return(new OSMElements.OSMElement()); } braille.screenName = templateObject.Screens[0]; // hier wird immer nur ein Screen-Name übergeben braille.viewName = viewName; brailleNode.properties = prop; brailleNode.brailleRepresentation = braille; prop.IdGenerated = treeOperation.generatedIds.generatedIdBrailleNode(brailleNode); brailleNode.properties = prop; return(brailleNode); }
/// <summary> /// Determinates the screen name to a given screen id /// </summary> /// <param name="screenId">the id of the screen</param> /// <returns>Returns the screen name OR <c>null</c></returns> public String getScreenIdToScreenName(String screenId) { if (screenId == null) { return(null); } OSMElements.OSMElement osm = getBrailleTreeOsmElementById(screenId); if (osm == null || osm.Equals(new OSMElements.OSMElement()) || osm.brailleRepresentation == null) { return(null); } return(osm.brailleRepresentation.screenName); }
public void getBrailleNodeAtPointTest() { initilaizeBrailleTree2Nodes(); strategyMgr.getSpecifiedBrailleDisplay().setActiveAdapter(); strategyMgr.getSpecifiedBrailleDisplay().generatedBrailleUi(); strategyMgr.getSpecifiedBrailleDisplay().setVisibleScreen("TestScreen"); Object nodeAtPoint = guiFuctions.getBrailleNodeAtPoint(5, 35); Assert.AreNotEqual(null, nodeAtPoint, "Es hätte ein Knoten gefunden werden sollen!"); OSMElements.OSMElement data = strategyMgr.getSpecifiedTree().GetData(nodeAtPoint); Assert.AreEqual("TestView - 2", data.brailleRepresentation.viewName, "An der Position (5,35) hätte die 'TestView - 2' sein sollen!"); strategyMgr.getSpecifiedBrailleDisplay().removeActiveAdapter(); guiFuctions.deleteGrantTrees(); }
/// <summary> /// Sets some "special" properties for the first node /// </summary> /// <param name="tree">the tree object</param> private void setSpecialPropertiesOfFirstNode(ref Object tree) { if (strategyMgr.getSpecifiedTree().HasChild(tree)) { // Settings settings = new Settings(); OSMElements.OSMElement osm = new OSMElements.OSMElement(); osm.brailleRepresentation = strategyMgr.getSpecifiedTree().GetData(strategyMgr.getSpecifiedTree().Child(tree)).brailleRepresentation; osm.properties = strategyMgr.getSpecifiedTree().GetData(strategyMgr.getSpecifiedTree().Child(tree)).properties; // osm.properties.grantFilterStrategy = settings.filterStrategyTypeToUserName(this.GetType()); osm.properties.processName = strategyMgr.getSpecifiedOperationSystem().getProcessNameOfApplication(osm.properties.processIdFiltered); osm.properties.appPath = strategyMgr.getSpecifiedOperationSystem().getFileNameOfApplicationByMainWindowTitle(osm.properties.processIdFiltered); strategyMgr.getSpecifiedTree().SetData(strategyMgr.getSpecifiedTree().Child(tree), osm); } }
/// <summary> /// depending on the given properties, all nodes with these properties are searched (depth-first search). /// Only properties that have been specified are taken into account. /// </summary> /// <param name="tree">tree object for search </param> /// <param name="generalProperties">properties for the search</param> /// <param name="oper">Operator for combining the properties (and, or) </param> /// <returns>A list of the found tree objects</returns> public List <Object> getNodesByProperties(Object tree, OSMElements.GeneralProperties generalProperties, OperatorEnum oper = OperatorEnum.and) {//TODO: many properties are still missing List <Object> result = new List <Object>(); if (tree == null) { return(result); } foreach (Object node in strategyMgr.getSpecifiedTree().AllNodes(tree)) { OSMElements.OSMElement nodeData = strategyMgr.getSpecifiedTree().GetData(node); Boolean propertieLocalizedControlType = generalProperties.localizedControlTypeFiltered == null || nodeData.properties.localizedControlTypeFiltered.Equals(generalProperties.localizedControlTypeFiltered); Boolean propertieName = generalProperties.nameFiltered == null || nodeData.properties.nameFiltered.Equals(generalProperties.nameFiltered); Boolean propertieIsEnabled = generalProperties.isEnabledFiltered == null || nodeData.properties.isEnabledFiltered == generalProperties.isEnabledFiltered; Boolean propertieBoundingRectangle = generalProperties.boundingRectangleFiltered == new System.Windows.Rect() || nodeData.properties.boundingRectangleFiltered.Equals(generalProperties.boundingRectangleFiltered); Boolean propertieIdGenerated = generalProperties.IdGenerated == null || generalProperties.IdGenerated.Equals(nodeData.properties.IdGenerated); Boolean propertieAccessKey = generalProperties.accessKeyFiltered == null || generalProperties.accessKeyFiltered.Equals(nodeData.properties.accessKeyFiltered); Boolean acceleratorKey = generalProperties.acceleratorKeyFiltered == null || generalProperties.acceleratorKeyFiltered.Equals(nodeData.properties.acceleratorKeyFiltered); Boolean runtimeId = generalProperties.runtimeIDFiltered == null || Enumerable.SequenceEqual(generalProperties.runtimeIDFiltered, nodeData.properties.runtimeIDFiltered); Boolean automationId = generalProperties.autoamtionIdFiltered == null || generalProperties.autoamtionIdFiltered.Equals(nodeData.properties.autoamtionIdFiltered); //ist zumindest bei Skype für ein UI-Element nicht immer gleich Boolean controlType = generalProperties.controlTypeFiltered == null || generalProperties.controlTypeFiltered.Equals(nodeData.properties.controlTypeFiltered); if (OperatorEnum.Equals(oper, OperatorEnum.and)) { if (propertieBoundingRectangle && propertieLocalizedControlType && propertieIdGenerated && propertieAccessKey && acceleratorKey && runtimeId && controlType && propertieName && propertieIsEnabled) { result.Add(node); } } if (OperatorEnum.Equals(oper, OperatorEnum.or)) {//TODO: add properties if ((generalProperties.localizedControlTypeFiltered != null && propertieLocalizedControlType) || (generalProperties.nameFiltered != null && propertieName) || (generalProperties.isEnabledFiltered != null && propertieIsEnabled) || (generalProperties.boundingRectangleFiltered != new System.Windows.Rect() && propertieBoundingRectangle) || (generalProperties.IdGenerated != null && propertieIdGenerated) || (generalProperties.accessKeyFiltered != null && propertieAccessKey) || (generalProperties.acceleratorKeyFiltered != null && acceleratorKey) || (generalProperties.runtimeIDFiltered != null && runtimeId) || (generalProperties.controlTypeFiltered != null && controlType) ) { result.Add(node); } } } return(result); }
private OSMElements.OSMElement createParentBrailleNode(Object filteredSubtree, TemplateUiObject templateObject) { OSMElements.OSMElement brailleNode = new OSMElements.OSMElement(); brailleNode.brailleRepresentation = templateObject.osm.brailleRepresentation; brailleNode.properties = templateObject.osm.properties; brailleNode.properties.isEnabledFiltered = false; brailleNode.properties.controlTypeFiltered = "GroupElement"; brailleNode.properties.isContentElementFiltered = false; //-> es ist Elternteil einer Gruppe brailleNode.brailleRepresentation.isVisible = true; if (templateObject.Screens == null) { Debug.WriteLine("Achtung, hier wurde kein Screen angegeben!"); return(new OSMElements.OSMElement()); } brailleNode.brailleRepresentation.screenName = templateObject.Screens[0]; // hier wird immer nur ein Screen-Name übergeben brailleNode.brailleRepresentation.viewName = "_" + templateObject.viewName + "_groupElementsStatic_Count_" + templateObject.groupElements.Count(); brailleNode.brailleRepresentation.templateFullName = templateObject.groupImplementedClassTypeFullName; brailleNode.brailleRepresentation.templateNamspace = templateObject.groupImplementedClassTypeDllName; if (templateObject.osm.brailleRepresentation.boarder != null) { brailleNode.brailleRepresentation.boarder = templateObject.osm.brailleRepresentation.boarder; } if (templateObject.osm.brailleRepresentation.padding != null) { brailleNode.brailleRepresentation.padding = templateObject.osm.brailleRepresentation.padding; } if (templateObject.osm.brailleRepresentation.margin != null) { brailleNode.brailleRepresentation.margin = templateObject.osm.brailleRepresentation.margin; } String idGenerated = treeOperation.updateNodes.addNodeInBrailleTree(brailleNode); if (idGenerated == null) { Debug.WriteLine("Es konnte keine Id erstellt werden."); return(new OSMElements.OSMElement()); } brailleNode.properties.IdGenerated = idGenerated; if (filteredSubtree != null && strategyMgr.getSpecifiedTree().GetData(filteredSubtree) != null) { treeOperation.osmTreeConnector.addOsmConnection(strategyMgr.getSpecifiedTree().GetData(filteredSubtree).properties.IdGenerated, idGenerated); } treeOperation.updateNodes.updateNodeOfBrailleUi(ref brailleNode); return(brailleNode); }
/// <summary> /// searches a filtered node (in <c>grantTrees.filteredTree</c> ) by a given HWND /// </summary> /// <param name="hwnd">a hwnd of a node</param> /// <returns>the node object OR <c>null</c></returns> public Object getFilteredNodeByHwnd(IntPtr hwnd) { if (IntPtr.Zero.Equals(hwnd) || grantTrees.filteredTree == null) { return(null); } foreach (Object node in strategyMgr.getSpecifiedTree().AllNodes(grantTrees.filteredTree)) { OSMElements.OSMElement osmData = strategyMgr.getSpecifiedTree().GetData(node); if (hwnd.Equals(osmData.properties.hWndFiltered)) { return(node); } } return(null); }
internal bool existViewInTree(Object subtree, String viewName) { if (viewName == null || viewName.Equals("")) { return(false); } foreach (Object o in strategyMgr.getSpecifiedTree().AllChildrenNodes(subtree)) { OSMElements.OSMElement data = strategyMgr.getSpecifiedTree().GetData(o); if (viewName.Equals(data.brailleRepresentation.viewName)) { return(true); } } return(false); }
public void getBrailleNodeInGroupAtPointTest() { initilaizeFilteredTree(); strategyMgr.getSpecifiedGeneralTemplateUi().generatedUiFromTemplate(pathToTemplate); strategyMgr.getSpecifiedBrailleDisplay().setActiveAdapter(); strategyMgr.getSpecifiedBrailleDisplay().generatedBrailleUi(); // auf dem Screen 'a1' befindet sich der gesuchte Knoten strategyMgr.getSpecifiedBrailleDisplay().setVisibleScreen("a1"); Object nodeAtPoint = guiFuctions.getBrailleNodeAtPoint(25, 25); Assert.AreNotEqual(null, nodeAtPoint, "Es hätte ein Knoten gefunden werden sollen!"); OSMElements.OSMElement data = strategyMgr.getSpecifiedTree().GetData(nodeAtPoint); Assert.AreEqual("0", data.properties.valueFiltered, "An der Position (25,25) hätte der Button mit der Ziffer '0' sein sollen. Somit hätte der Value auch '0' sein sollen!"); strategyMgr.getSpecifiedBrailleDisplay().removeActiveAdapter(); guiFuctions.deleteGrantTrees(); }
private OSMElements.OSMElement addSeparatorElementInBrailleTree(String separator, ref int startX, int startY) { OSMElements.OSMElement osmBraille = new OSMElements.OSMElement(); osmBraille.brailleRepresentation.isVisible = true; osmBraille.properties.controlTypeFiltered = "Text"; osmBraille.brailleRepresentation.isGroupChild = true; osmBraille.brailleRepresentation.typeOfView = grantTrees.TextviewObject.typeOfView; osmBraille.brailleRepresentation.screenName = grantTrees.TextviewObject.screenName; osmBraille.brailleRepresentation.viewName = "separator"; osmBraille.properties.valueFiltered = separator; osmBraille.properties.boundingRectangleFiltered = new Rect(startX, startY, separator.Length * 3, 5);//TODO: richtig machen osmBraille.properties.IdGenerated = treeOperation.generatedIds.generatedIdBrailleNode(osmBraille); return(osmBraille); }