protected void onHorizontalTranslateRel(
Angle forwardChange, Angle sideChange, ViewInputAttributes.ActionAttributes actionAttribs) {
View view = this.getView();
if (view == null) // include this test to ensure any derived implementation performs it
{
return;
}
if (forwardChange.equals(Angle.ZERO) && sideChange.equals(Angle.ZERO)) {
return;
}
if (view instanceof BasicFlyView) {
Vec4 forward = view.getForwardVector();
Vec4 up = view.getUpVector();
Vec4 side = forward.transformBy3(Matrix.fromAxisAngle(Angle.fromDegrees(90), up));
forward = forward.multiply3(forwardChange.getDegrees());
side = side.multiply3(sideChange.getDegrees());
Vec4 eyePoint = view.getEyePoint();
eyePoint = eyePoint.add3(forward.add3(side));
Position newPosition = view.getGlobe().computePositionFromPoint(eyePoint);
this.setEyePosition(this.uiAnimControl, view, newPosition, actionAttribs);
view.firePropertyChange(AVKey.VIEW, null, view);
}
}
/**
* Compute the positions of the arrow head of the graphic's legs.
*
* @param dc Current draw context
* @param base Position of the arrow's starting point.
* @param tip Position of the arrow head tip.
* @param arrowLength Length of the arrowhead as a fraction of the total line length.
* @param arrowAngle Angle of the arrow head.
* @return Positions required to draw the arrow head.
*/
protected List<Position> computeArrowheadPositions(
DrawContext dc, Position base, Position tip, double arrowLength, Angle arrowAngle) {
// Build a triangle to represent the arrowhead. The triangle is built from two vectors, one
// parallel to the
// segment, and one perpendicular to it.
Globe globe = dc.getGlobe();
Vec4 ptA = globe.computePointFromPosition(base);
Vec4 ptB = globe.computePointFromPosition(tip);
// Compute parallel component
Vec4 parallel = ptA.subtract3(ptB);
Vec4 surfaceNormal = globe.computeSurfaceNormalAtPoint(ptB);
// Compute perpendicular component
Vec4 perpendicular = surfaceNormal.cross3(parallel);
double finalArrowLength = arrowLength * parallel.getLength3();
double arrowHalfWidth = finalArrowLength * arrowAngle.tanHalfAngle();
perpendicular = perpendicular.normalize3().multiply3(arrowHalfWidth);
parallel = parallel.normalize3().multiply3(finalArrowLength);
// Compute geometry of direction arrow
Vec4 vertex1 = ptB.add3(parallel).add3(perpendicular);
Vec4 vertex2 = ptB.add3(parallel).subtract3(perpendicular);
return TacticalGraphicUtil.asPositionList(globe, vertex1, vertex2, ptB);
}
protected void assembleHeightControlPoints() {
if (this.controlPoints.size() < 2) return;
// Add one control point for the height between the first and second vertices.
// TODO: ensure that this control point is visible
Position firstVertex = this.controlPoints.get(0).getPosition();
Position secondVertex = this.controlPoints.get(1).getPosition();
Globe globe = this.wwd.getModel().getGlobe();
// Get cartesian points for the vertices
Vec4 firstPoint = globe.computePointFromPosition(firstVertex);
Vec4 secondPoint = globe.computePointFromPosition(secondVertex);
// Find the midpoint of the line segment that connects the vertices
Vec4 halfwayPoint = firstPoint.add3(secondPoint).divide3(2.0);
Position halfwayPosition = globe.computePositionFromPoint(halfwayPoint);
this.controlPoints.add(
new ControlPointMarker(
CHANGE_HEIGHT_ACTION,
halfwayPosition,
halfwayPoint,
this.heightControlAttributes,
this.controlPoints.size()));
}
protected Vec4[] calculateNormals(int width, int height, Vec4[] verts, int padding) {
int padding2 = padding * 2;
if (verts.length != (width + padding2) * (height + padding2))
throw new IllegalStateException("Illegal vertices length");
Vec4[] norms = new Vec4[width * height];
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
// v2
// |
// v1-v0-v3
// |
// v4
Vec4 v0 =
verts[getArrayIndex(width + padding2, height + padding2, x + padding, y + padding)];
if (v0 != null) {
Vec4 v1 =
verts[
getArrayIndex(width + padding2, height + padding2, x + padding - 1, y + padding)];
Vec4 v2 =
verts[
getArrayIndex(width + padding2, height + padding2, x + padding, y + padding - 1)];
Vec4 v3 =
verts[
getArrayIndex(width + padding2, height + padding2, x + padding + 1, y + padding)];
Vec4 v4 =
verts[
getArrayIndex(width + padding2, height + padding2, x + padding, y + padding + 1)];
Vec4[] normals = new Vec4[4];
normals[0] =
v1 != null && v2 != null
? v1.subtract3(v0).cross3(v0.subtract3(v2)).normalize3()
: null;
normals[1] =
v2 != null && v3 != null
? v2.subtract3(v0).cross3(v0.subtract3(v3)).normalize3()
: null;
normals[2] =
v3 != null && v4 != null
? v3.subtract3(v0).cross3(v0.subtract3(v4)).normalize3()
: null;
normals[3] =
v4 != null && v1 != null
? v4.subtract3(v0).cross3(v0.subtract3(v1)).normalize3()
: null;
Vec4 normal = Vec4.ZERO;
for (Vec4 n : normals) {
if (n != null) normal = normal.add3(n);
}
if (normal != Vec4.ZERO) {
norms[getArrayIndex(width, height, x, y)] = normal.normalize3();
}
}
}
}
return norms;
}
protected void assembleVertexControlPoints(DrawContext dc) {
Terrain terrain = dc.getTerrain();
ExtrudedPolygon polygon = this.getPolygon();
Position refPos = polygon.getReferencePosition();
Vec4 refPoint = terrain.getSurfacePoint(refPos.getLatitude(), refPos.getLongitude(), 0);
int altitudeMode = polygon.getAltitudeMode();
double height = polygon.getHeight();
Vec4 vaa = null;
double vaaLength = 0; // used to compute independent length of each cap vertex
double vaLength = 0;
int i = 0;
for (LatLon location : polygon.getOuterBoundary()) {
Vec4 vert;
// Compute the top/cap point.
if (altitudeMode == WorldWind.CONSTANT || !(location instanceof Position)) {
if (vaa == null) {
// Compute the vector lengths of the top and bottom points at the reference position.
vaa = refPoint.multiply3(height / refPoint.getLength3());
vaaLength = vaa.getLength3();
vaLength = refPoint.getLength3();
}
// Compute the bottom point, which is on the terrain.
vert = terrain.getSurfacePoint(location.getLatitude(), location.getLongitude(), 0);
double delta = vaLength - vert.dot3(refPoint) / vaLength;
vert = vert.add3(vaa.multiply3(1d + delta / vaaLength));
} else if (altitudeMode == WorldWind.RELATIVE_TO_GROUND) {
vert =
terrain.getSurfacePoint(
location.getLatitude(),
location.getLongitude(),
((Position) location).getAltitude());
} else // WorldWind.ABSOLUTE
{
vert =
terrain
.getGlobe()
.computePointFromPosition(
location.getLatitude(),
location.getLongitude(),
((Position) location).getAltitude() * terrain.getVerticalExaggeration());
}
Position vertexPosition = this.wwd.getModel().getGlobe().computePositionFromPoint(vert);
this.controlPoints.add(
new ControlPointMarker(
MOVE_VERTEX_ACTION, vertexPosition, vert, this.vertexControlAttributes, i));
i++;
}
}
/**
* Determine the positions that make up the arrowhead.
*
* @param dc Current draw context.
* @param startPosition Position of the arrow's base.
* @param endPosition Position of the arrow head tip.
* @return Positions that define the arrowhead.
*/
protected List<Position> computeArrowheadPositions(
DrawContext dc, Position startPosition, Position endPosition) {
Globe globe = dc.getGlobe();
// Arrowhead looks like this:
// _
// A\ | 1/2 width
// ________B\ _|
// Pt. 1 /
// C/
// | |
// Length
Vec4 p1 = globe.computePointFromPosition(startPosition);
Vec4 pB = globe.computePointFromPosition(endPosition);
// Find vector in the direction of the arrow
Vec4 vB1 = p1.subtract3(pB);
double arrowLengthFraction = this.getArrowLength();
// Find the point at the base of the arrowhead
Vec4 arrowBase = pB.add3(vB1.multiply3(arrowLengthFraction));
Vec4 normal = globe.computeSurfaceNormalAtPoint(arrowBase);
// Compute the length of the arrowhead
double arrowLength = vB1.getLength3() * arrowLengthFraction;
double arrowHalfWidth = arrowLength * this.getArrowAngle().tanHalfAngle();
// Compute a vector perpendicular to the segment and the normal vector
Vec4 perpendicular = vB1.cross3(normal);
perpendicular = perpendicular.normalize3().multiply3(arrowHalfWidth);
// Find points A and C
Vec4 pA = arrowBase.add3(perpendicular);
Vec4 pC = arrowBase.subtract3(perpendicular);
return TacticalGraphicUtil.asPositionList(globe, pA, pB, pC);
}
protected void addToolTip(DrawContext dc, WWIcon icon, Vec4 iconPoint) {
if (icon.getToolTipFont() == null && icon.getToolTipText() == null) return;
Vec4 screenPoint = dc.getView().project(iconPoint);
if (screenPoint == null) return;
if (icon.getToolTipOffset() != null) screenPoint = screenPoint.add3(icon.getToolTipOffset());
OrderedText tip =
new OrderedText(
icon.getToolTipText(),
icon.getToolTipFont(),
screenPoint,
icon.getToolTipTextColor(),
0d);
dc.addOrderedRenderable(tip);
}
public void lookAt(Position lookAtPos, long timeToMove) {
BasicFlyView view = (BasicFlyView) this.getView();
Vec4 lookDirection;
double distanceToSurface;
Vec4 currentLookAtPt = view.getCenterPoint();
Position newPosition;
if (currentLookAtPt == null) {
view.getGlobe().computePointFromPosition(lookAtPos);
double elevAtLookAtPos =
view.getGlobe().getElevation(lookAtPos.getLatitude(), lookAtPos.getLongitude());
newPosition = new Position(lookAtPos, elevAtLookAtPos + 10000);
} else {
Vec4 currentEyePt = view.getEyePoint();
distanceToSurface = currentEyePt.distanceTo3(currentLookAtPt);
lookDirection = currentLookAtPt.subtract3(currentEyePt).normalize3();
Vec4 newLookAtPt = view.getGlobe().computePointFromPosition(lookAtPos);
Vec4 flyToPoint = newLookAtPt.add3(lookDirection.multiply3(-distanceToSurface));
newPosition = view.getGlobe().computePositionFromPoint(flyToPoint);
}
ViewUtil.ViewState viewCoords = view.getViewState(newPosition, lookAtPos);
FlyToFlyViewAnimator panAnimator =
FlyToFlyViewAnimator.createFlyToFlyViewAnimator(
view,
view.getEyePosition(),
newPosition,
view.getHeading(),
viewCoords.getHeading(),
view.getPitch(),
viewCoords.getPitch(),
view.getEyePosition().getElevation(),
viewCoords.getPosition().getElevation(),
timeToMove,
WorldWind.ABSOLUTE);
this.gotoAnimControl.put(VIEW_ANIM_PAN, panAnimator);
this.getView().firePropertyChange(AVKey.VIEW, null, this.getView());
view.firePropertyChange(AVKey.VIEW, null, view);
}
/**
* Compute points on either side of a line segment. This method requires a point on the line, and
* either a next point, previous point, or both.
*
* @param point Center point about which to compute side points.
* @param prev Previous point on the line. May be null if {@code next} is non-null.
* @param next Next point on the line. May be null if {@code prev} is non-null.
* @param leftPositions Left position will be added to this list.
* @param rightPositions Right position will be added to this list.
* @param halfWidth Distance from the center line to the left or right lines.
* @param globe Current globe.
*/
protected void generateParallelPoints(
Vec4 point,
Vec4 prev,
Vec4 next,
List<Position> leftPositions,
List<Position> rightPositions,
double halfWidth,
Globe globe) {
if ((point == null) || (prev == null && next == null)) {
String message = Logging.getMessage("nullValue.PointIsNull");
Logging.logger().severe(message);
throw new IllegalArgumentException(message);
}
if (leftPositions == null || rightPositions == null) {
String message = Logging.getMessage("nullValue.PositionListIsNull");
Logging.logger().severe(message);
throw new IllegalArgumentException(message);
}
if (globe == null) {
String message = Logging.getMessage("nullValue.GlobeIsNull");
Logging.logger().severe(message);
throw new IllegalArgumentException(message);
}
Vec4 offset;
Vec4 normal = globe.computeSurfaceNormalAtPoint(point);
// Compute vector in the direction backward along the line.
Vec4 backward = (prev != null) ? prev.subtract3(point) : point.subtract3(next);
// Compute a vector perpendicular to segment BC, and the globe normal vector.
Vec4 perpendicular = backward.cross3(normal);
double length;
// If both next and previous points are supplied then calculate the angle that bisects the angle
// current, next, prev.
if (next != null && prev != null && !Vec4.areColinear(prev, point, next)) {
// Compute vector in the forward direction.
Vec4 forward = next.subtract3(point);
// Calculate the vector that bisects angle ABC.
offset = forward.normalize3().add3(backward.normalize3());
offset = offset.normalize3();
// Compute the scalar triple product of the vector BC, the normal vector, and the offset
// vector to
// determine if the offset points to the left or the right of the control line.
double tripleProduct = perpendicular.dot3(offset);
if (tripleProduct < 0) {
offset = offset.multiply3(-1);
}
// Determine the length of the offset vector that will keep the left and right lines parallel
// to the control
// line.
Angle theta = backward.angleBetween3(offset);
if (!Angle.ZERO.equals(theta)) length = halfWidth / theta.sin();
else length = halfWidth;
} else {
offset = perpendicular.normalize3();
length = halfWidth;
}
offset = offset.multiply3(length);
// Determine the left and right points by applying the offset.
Vec4 ptRight = point.add3(offset);
Vec4 ptLeft = point.subtract3(offset);
// Convert cartesian points to geographic.
Position posLeft = globe.computePositionFromPoint(ptLeft);
Position posRight = globe.computePositionFromPoint(ptRight);
leftPositions.add(posLeft);
rightPositions.add(posRight);
}
protected void onMoveTo(
Position focalPosition,
ViewInputAttributes.DeviceAttributes deviceAttributes,
ViewInputAttributes.ActionAttributes actionAttribs) {
BasicFlyView view = (BasicFlyView) this.getView();
if (view == null) // include this test to ensure any derived implementation performs it
{
return;
}
// We're treating a speed parameter as smoothing here. A greater speed results in greater
// smoothing and
// slower response. Therefore the min speed used at lower altitudes ought to be *greater* than
// the max
// speed used at higher altitudes.
double smoothing = this.getScaleValueElevation(deviceAttributes, actionAttribs);
if (!actionAttribs.isEnableSmoothing()) smoothing = 0.0;
Vec4 currentLookAtPt = view.getCenterPoint();
if (currentLookAtPt == null) {
currentLookAtPt = view.getGlobe().computePointFromPosition(focalPosition);
}
Vec4 currentEyePt = view.getEyePoint();
double distanceToSurface = currentEyePt.distanceTo3(currentLookAtPt);
Vec4 lookDirection = currentEyePt.subtract3(currentLookAtPt).normalize3();
Vec4 newLookAtPt = view.getGlobe().computePointFromPosition(focalPosition);
Vec4 flyToPoint = newLookAtPt.add3(lookDirection.multiply3(distanceToSurface));
Position newPosition = view.getGlobe().computePositionFromPoint(flyToPoint);
ViewUtil.ViewState viewCoords = view.getViewState(newPosition, focalPosition);
this.stopAnimators();
this.gotoAnimControl.put(
VIEW_ANIM_HEADING,
new RotateToAngleAnimator(
view.getHeading(),
viewCoords.getHeading(),
smoothing,
ViewPropertyAccessor.createHeadingAccessor(view)));
this.gotoAnimControl.put(
VIEW_ANIM_PITCH,
new RotateToAngleAnimator(
view.getPitch(),
viewCoords.getPitch(),
smoothing,
ViewPropertyAccessor.createPitchAccessor(view)));
double elevation =
((FlyViewLimits) view.getViewPropertyLimits())
.limitEyeElevation(newPosition, view.getGlobe());
if (elevation != newPosition.getElevation()) {
newPosition = new Position(newPosition, elevation);
}
this.gotoAnimControl.put(
VIEW_ANIM_POSITION,
new MoveToPositionAnimator(
view.getEyePosition(),
newPosition,
smoothing,
ViewPropertyAccessor.createEyePositionAccessor(view)));
view.firePropertyChange(AVKey.VIEW, null, view);
}
protected Vec4[] calculateBentNormals(int width, int height, Vec4[] verts, int padding) {
int padding2 = padding * 2;
if (verts.length != (width + padding2) * (height + padding2))
throw new IllegalStateException("Illegal vertices length");
Vec4[] norms = new Vec4[width * height];
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
Vec4 vec =
verts[getArrayIndex(width + padding2, height + padding2, x + padding, y + padding)];
if (vec != null) {
Vec4 vecnorm = vec.normalize3();
Vec4[] maxes = new Vec4[16];
double[] angles = new double[16];
for (int i = 0; i < angles.length; i++) {
angles[i] = Double.MAX_VALUE;
}
// 2 3 4 5 6
// 1 7
// 0 8
// 15 9
// 14 13 12 11 10
// for (int i = 1; i <= padding; i++)
for (int i = 2; i <= padding; i += 2) {
Vec4[] vecs = new Vec4[16];
vecs[0] =
verts[
getArrayIndex(
width + padding2, height + padding2, x + padding - i, y + padding)];
vecs[2] =
verts[
getArrayIndex(
width + padding2, height + padding2, x + padding - i, y + padding - i)];
vecs[4] =
verts[
getArrayIndex(
width + padding2, height + padding2, x + padding, y + padding - i)];
vecs[6] =
verts[
getArrayIndex(
width + padding2, height + padding2, x + padding + i, y + padding - i)];
vecs[8] =
verts[
getArrayIndex(
width + padding2, height + padding2, x + padding + i, y + padding)];
vecs[10] =
verts[
getArrayIndex(
width + padding2, height + padding2, x + padding + i, y + padding + i)];
vecs[12] =
verts[
getArrayIndex(
width + padding2, height + padding2, x + padding, y + padding + i)];
vecs[14] =
verts[
getArrayIndex(
width + padding2, height + padding2, x + padding - i, y + padding + i)];
if (i % 2 == 0) {
int i2 = i / 2;
vecs[1] =
verts[
getArrayIndex(
width + padding2, height + padding2, x + padding - i, y + padding - i2)];
vecs[3] =
verts[
getArrayIndex(
width + padding2, height + padding2, x + padding - i2, y + padding - i)];
vecs[5] =
verts[
getArrayIndex(
width + padding2, height + padding2, x + padding + i2, y + padding - i)];
vecs[7] =
verts[
getArrayIndex(
width + padding2, height + padding2, x + padding + i, y + padding - i2)];
vecs[9] =
verts[
getArrayIndex(
width + padding2, height + padding2, x + padding + i, y + padding + i2)];
vecs[11] =
verts[
getArrayIndex(
width + padding2, height + padding2, x + padding + i2, y + padding + i)];
vecs[13] =
verts[
getArrayIndex(
width + padding2, height + padding2, x + padding - i2, y + padding + i)];
vecs[15] =
verts[
getArrayIndex(
width + padding2, height + padding2, x + padding - i, y + padding + i2)];
}
for (int j = 0; j < maxes.length; j++) {
if (vecs[j] != null) {
Vec4 v = vecs[j].subtract3(vec).normalize3();
double angle = Math.acos(v.dot3(vecnorm));
if (angle < angles[j]) {
angles[j] = angle;
maxes[j] = v;
}
}
}
}
Vec4 normal = Vec4.ZERO;
for (int i = 0; i < maxes.length; i++) {
if (maxes[i] != null) {
Vec4 n = maxes[i].cross3(vecnorm).cross3(maxes[i]);
normal = normal.add3(n);
}
}
if (normal != Vec4.ZERO) {
norms[getArrayIndex(width, height, x, y)] = normal.normalize3();
}
}
}
}
return norms;
}
// Rendering
public void draw(DrawContext dc) {
GL gl = dc.getGL();
boolean attribsPushed = false;
boolean modelviewPushed = false;
boolean projectionPushed = false;
try {
gl.glPushAttrib(
GL.GL_DEPTH_BUFFER_BIT
| GL.GL_COLOR_BUFFER_BIT
| GL.GL_ENABLE_BIT
| GL.GL_TEXTURE_BIT
| GL.GL_TRANSFORM_BIT
| GL.GL_VIEWPORT_BIT
| GL.GL_CURRENT_BIT);
attribsPushed = true;
gl.glDisable(GL.GL_TEXTURE_2D); // no textures
gl.glEnable(GL.GL_BLEND);
gl.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);
gl.glDisable(GL.GL_DEPTH_TEST);
double width = this.size.width;
double height = this.size.height;
// Load a parallel projection with xy dimensions (viewportWidth, viewportHeight)
// into the GL projection matrix.
java.awt.Rectangle viewport = dc.getView().getViewport();
gl.glMatrixMode(javax.media.opengl.GL.GL_PROJECTION);
gl.glPushMatrix();
projectionPushed = true;
gl.glLoadIdentity();
double maxwh = width > height ? width : height;
gl.glOrtho(0d, viewport.width, 0d, viewport.height, -0.6 * maxwh, 0.6 * maxwh);
gl.glMatrixMode(GL.GL_MODELVIEW);
gl.glPushMatrix();
modelviewPushed = true;
gl.glLoadIdentity();
// Scale to a width x height space
// located at the proper position on screen
double scale = this.computeScale(viewport);
Vec4 locationSW = this.computeLocation(viewport, scale);
gl.glTranslated(locationSW.x(), locationSW.y(), locationSW.z());
gl.glScaled(scale, scale, 1);
// Compute scale size in real world
Position referencePosition = dc.getViewportCenterPosition();
if (referencePosition != null) {
Vec4 groundTarget = dc.getGlobe().computePointFromPosition(referencePosition);
Double distance = dc.getView().getEyePoint().distanceTo3(groundTarget);
this.pixelSize = dc.getView().computePixelSizeAtDistance(distance);
Double scaleSize = this.pixelSize * width * scale; // meter
String unitLabel = "m";
if (this.unit.equals(UNIT_METRIC)) {
if (scaleSize > 10000) {
scaleSize /= 1000;
unitLabel = "Km";
}
} else if (this.unit.equals(UNIT_IMPERIAL)) {
scaleSize *= 3.280839895; // feet
unitLabel = "ft";
if (scaleSize > 5280) {
scaleSize /= 5280;
unitLabel = "mile(s)";
}
}
// Rounded division size
int pot = (int) Math.floor(Math.log10(scaleSize));
if (!Double.isNaN(pot)) {
int digit = Integer.parseInt(String.format("%.0f", scaleSize).substring(0, 1));
double divSize = digit * Math.pow(10, pot);
if (digit >= 5) divSize = 5 * Math.pow(10, pot);
else if (digit >= 2) divSize = 2 * Math.pow(10, pot);
double divWidth = width * divSize / scaleSize;
// Draw scale
if (!dc.isPickingMode()) {
// Set color using current layer opacity
Color backColor = this.getBackgroundColor(this.color);
float[] colorRGB = backColor.getRGBColorComponents(null);
gl.glColor4d(
colorRGB[0],
colorRGB[1],
colorRGB[2],
(double) backColor.getAlpha() / 255d * this.getOpacity());
gl.glTranslated((width - divWidth) / 2, 0d, 0d);
this.drawScale(dc, divWidth, height);
colorRGB = this.color.getRGBColorComponents(null);
gl.glColor4d(colorRGB[0], colorRGB[1], colorRGB[2], this.getOpacity());
gl.glTranslated(-1d / scale, 1d / scale, 0d);
this.drawScale(dc, divWidth, height);
// Draw label
String label = String.format("%.0f ", divSize) + unitLabel;
gl.glLoadIdentity();
gl.glDisable(GL.GL_CULL_FACE);
drawLabel(
dc,
label,
locationSW.add3(
new Vec4(divWidth * scale / 2 + (width - divWidth) / 2, height * scale, 0)));
} else {
// Picking
this.pickSupport.clearPickList();
this.pickSupport.beginPicking(dc);
// Draw unique color across the map
Color color = dc.getUniquePickColor();
int colorCode = color.getRGB();
// Add our object(s) to the pickable list
this.pickSupport.addPickableObject(colorCode, this, referencePosition, false);
gl.glColor3ub((byte) color.getRed(), (byte) color.getGreen(), (byte) color.getBlue());
gl.glTranslated((width - divWidth) / 2, 0d, 0d);
this.drawRectangle(dc, divWidth, height);
// Done picking
this.pickSupport.endPicking(dc);
this.pickSupport.resolvePick(dc, dc.getPickPoint(), this);
}
}
}
} finally {
if (projectionPushed) {
gl.glMatrixMode(GL.GL_PROJECTION);
gl.glPopMatrix();
}
if (modelviewPushed) {
gl.glMatrixMode(GL.GL_MODELVIEW);
gl.glPopMatrix();
}
if (attribsPushed) gl.glPopAttrib();
}
}