protected void doResolveTopPick(DrawContext dc, Point pickPoint) { PickedObjectList pol = dc.getPickedObjects(); if (pol != null && pol.size() == 1) { // If there is only one picked object, then it must be the top object so we're done. pol.get(0).setOnTop(); } else if (pol != null && pol.size() > 1) { // If there is more than one picked object, then find the picked object corresponding to the top color at // the pick point, and mark it as on top int colorCode = dc.getPickColorAtPoint(pickPoint); if (colorCode != 0) { foreach (PickedObject po in pol) { if (po != null && po.getColorCode() == colorCode) { po.setOnTop(); break; // No need to check the remaining picked objects. } } } } }
public Position getCurrentPosition() { if (this.sceneController == null) { return(null); } PickedObjectList pol = this.getSceneController().getPickedObjectList(); if (pol == null || pol.size() < 1) { return(null); } Position p = null; PickedObject top = pol.getTopPickedObject(); if (top != null && top.hasPosition()) { p = top.getPosition(); } else if (pol.getTerrainObject() != null) { p = pol.getTerrainObject().getPosition(); } return(p); }
public SelectEvent(Object source, String eventAction, Rectangle pickRectangle, PickedObjectList pickedObjects) : base(source) { this.eventAction = eventAction; this.pickPoint = default(Point); this.pickRect = pickRectangle; this.mouseEvent = null; this.pickedObjects = pickedObjects; }
public SelectEvent(object source, string eventAction, MouseEvent mouseEvent, PickedObjectList pickedObjects) : base(source) { this.eventAction = eventAction; this.pickPoint = mouseEvent != null?mouseEvent.getPoint() : null; this.pickRect = default(Rectangle); this.mouseEvent = mouseEvent; this.pickedObjects = pickedObjects; }
protected PickedObjectList getCurrentBoxSelection() { if (this.sceneController == null) { return(null); } PickedObjectList pol = this.sceneController.getObjectsInPickRectangle(); return(pol != null && pol.size() > 0 ? pol : null); }
protected Position computeSelectedPosition() { PickedObjectList pickedObjects = this.wwd.getObjectsAtCurrentPosition(); if (pickedObjects != null) { if (pickedObjects.getTerrainObject() != null) { return(pickedObjects.getTerrainObject().getPosition()); } } return(null); }
protected void doDeepPick(DrawContext dc) { PickedObjectList currentPickedObjects = this.lastPickedObjects; PickedObjectList currentObjectsInPickRect = this.lastObjectsInPickRect; dc.setDeepPickingEnabled(true); this.doNonTerrainPick(dc); dc.setDeepPickingEnabled(false); this.lastPickedObjects = this.mergePickedObjectLists(currentPickedObjects, dc.getPickedObjects()); this.lastObjectsInPickRect = this.mergePickedObjectLists(currentObjectsInPickRect, dc.getObjectsInPickRectangle()); }
protected PickedObject getCurrentSelection() { if (this.sceneController == null) { return(null); } PickedObjectList pol = this.getSceneController().getPickedObjectList(); if (pol == null || pol.size() < 1) { return(null); } PickedObject top = pol.getTopPickedObject(); return(top.isTerrain() ? null : top); }
protected PickedObjectList mergePickedObjectLists(PickedObjectList listA, PickedObjectList listB) { if (listA == null || listB == null || !listA.hasNonTerrainObjects() || !listB.hasNonTerrainObjects()) { return(listA); } foreach (PickedObject pb in listB) { if (pb.isTerrain()) { continue; } bool common = false; // cannot modify listA within its iterator, so use a flag to indicate commonality foreach (PickedObject pa in listA) { if (pa.isTerrain()) { continue; } if (pa.getObject() == pb.getObject()) { common = true; break; } } if (!common) { listA.add(pb); } } return(listA); }
protected void pick(DrawContext dc) { this.pickTime = System.currentTimeMillis(); this.lastPickedObjects = null; this.lastObjectsInPickRect = null; try { dc.enablePickingMode(); this.pickTerrain(dc); this.doNonTerrainPick(dc); if (this.isDeferOrderedRendering()) { return; } this.resolveTopPick(dc); this.lastPickedObjects = new PickedObjectList(dc.getPickedObjects()); this.lastObjectsInPickRect = new PickedObjectList(dc.getObjectsInPickRectangle()); if (this.isDeepPickEnabled() && (this.lastPickedObjects.hasNonTerrainObjects() || this.lastObjectsInPickRect.hasNonTerrainObjects())) { this.doDeepPick(dc); } } catch (Throwable e) { Logging.logger().log(Level.SEVERE, Logging.getMessage("BasicSceneController.ExceptionDuringPick"), e); } finally { dc.disablePickingMode(); this.pickTime = System.currentTimeMillis() - this.pickTime; } }
/** Releases resources associated with this scene controller. */ public void dispose() { if (this.lastPickedObjects != null) { this.lastPickedObjects.clear(); } this.lastPickedObjects = null; if (this.lastObjectsInPickRect != null) { this.lastObjectsInPickRect.clear(); } this.lastObjectsInPickRect = null; if (this.dc != null) { this.dc.dispose(); } if (this.textRendererCache != null) { this.textRendererCache.dispose(); } }
public DragSelectEvent(object source, string eventAction, MouseEvent mouseEvent, PickedObjectList pickedObjects, Point previousPickPoint) : base(source, eventAction, mouseEvent, pickedObjects) { this.previousPickPoint = previousPickPoint; }
protected void doResolveTopPick(DrawContext dc, Rectangle pickRect) { PickedObjectList pol = dc.getObjectsInPickRectangle(); if (pol != null && pol.size() == 1) { // If there is only one picked object, then it must be the top object so we're done. pol.get(0).setOnTop(); } else if (pol != null && pol.size() > 1) { int[] minAndMaxColorCodes = null; foreach (PickedObject po in pol) { int colorCode = po.getColorCode(); // Put all of the eligible picked objects in a map to provide constant time access to a picked object // by its color code. Since the number of unique color codes and picked objects may both be large, using // a hash map reduces the complexity of the next loop from O(n*m) to O(n*c), where n and m are the // lengths of the unique color list and picked object list, respectively, and c is the constant time // associated with a hash map access. this.pickableObjects.put(colorCode, po); // Keep track of the minimum and maximum color codes of the scene's picked objects. These values are // used to cull the number of colors that the draw context must consider with identifying the unique // pick colors in the specified screen rectangle. if (minAndMaxColorCodes == null) { minAndMaxColorCodes = new int[] { colorCode, colorCode } } ; else { if (minAndMaxColorCodes[0] > colorCode) { minAndMaxColorCodes[0] = colorCode; } if (minAndMaxColorCodes[1] < colorCode) { minAndMaxColorCodes[1] = colorCode; } } } // If there is more than one picked object, then find the picked objects corresponding to each of the top // colors in the pick rectangle, and mark them all as on top. int[] colorCodes = dc.getPickColorsInRectangle(pickRect, minAndMaxColorCodes); if (colorCodes != null && colorCodes.length > 0) { // Find the top picked object for each unique color code, if any, and mark it as on top. foreach (int colorCode in colorCodes) { if (colorCode != 0) // This should never happen, but we check anyway. { PickedObject po = this.pickableObjects.get(colorCode); if (po != null) { po.setOnTop(); } } } } // Clear the map of eligible picked objects so that the picked objects from this frame do not affect the // next frame. This also ensures that we do not leak memory by retaining references to picked objects. this.pickableObjects.clear(); } }
protected void setPickedObjectList(PickedObjectList pol) { this.lastPickedObjects = pol; }