int XKeyPress(int w, int client_data, int call_data, int continue_to_dispatch) {
int result = 0;
XKeyEvent xEvent = new XKeyEvent();
OS.memmove(xEvent, call_data, XKeyEvent.sizeof);
int[] keysym = new int[1];
OS.XLookupString(xEvent, null, 0, keysym, null);
keysym[0] &= 0xFFFF;
switch (keysym[0]) {
case OS.XK_space:
click(false, xEvent.state);
result = 1;
break;
case OS.XK_Down:
if ((style & SWT.DROP_DOWN) != 0) {
click(true, xEvent.state);
result = 1;
}
break;
}
/*
* Forward the key event to the parent.
* This is necessary so that key listeners
* in the parent will be called, despite the
* fact that the event did not really occur
* in X in the parent. This is done to be
* compatible with Windows.
*/
xEvent.window = OS.XtWindow(parent.handle);
// OS.memmove (callData, xEvent, XKeyEvent.sizeof);
parent.XKeyPress(w, client_data, call_data, continue_to_dispatch);
if (result == 1) {
OS.memmove(continue_to_dispatch, new int[1], 4);
}
return result;
}
int XPointerMotion(int w, int client_data, int call_data, int continue_to_dispatch) {
display.addMouseHoverTimeOut(handle);
/*
* Forward the mouse event to the parent.
* This is necessary so that mouse listeners
* in the parent will be called, despite the
* fact that the event did not really occur
* in X in the parent. This is done to be
* compatible with Windows.
*/
XMotionEvent xEvent = new XMotionEvent();
OS.memmove(xEvent, call_data, XMotionEvent.sizeof);
int[] argList = {OS.XmNx, 0, OS.XmNy, 0};
OS.XtGetValues(handle, argList, argList.length / 2);
xEvent.window = OS.XtWindow(parent.handle);
xEvent.x += argList[1];
xEvent.y += argList[3];
/*
* This code is intentionally commented.
* Currently, the implementation of the
* mouse move code in the parent interferes
* with tool tips for tool items.
*/
// OS.memmove (callData, xEvent, XButtonEvent.sizeof);
// parent.XPointerMotion (w, client_data, call_data, continue_to_dispatch);
if (!parent.sendMouseEvent(SWT.MouseMove, xEvent)) {
OS.memmove(continue_to_dispatch, new int[1], 4);
return 1;
}
return 0;
}
int XButtonRelease(int w, int client_data, int call_data, int continue_to_dispatch) {
display.hideToolTip();
XButtonEvent xEvent = new XButtonEvent();
OS.memmove(xEvent, call_data, XButtonEvent.sizeof);
/*
* Forward the mouse event to the parent.
* This is necessary so that mouse listeners
* in the parent will be called, despite the
* fact that the event did not really occur
* in X in the parent. This is done to be
* compatible with Windows.
*/
int[] argList = {OS.XmNx, 0, OS.XmNy, 0};
OS.XtGetValues(handle, argList, argList.length / 2);
xEvent.window = OS.XtWindow(parent.handle);
xEvent.x += argList[1];
xEvent.y += argList[3];
OS.memmove(call_data, xEvent, XButtonEvent.sizeof);
int result = parent.XButtonRelease(w, client_data, call_data, continue_to_dispatch);
xEvent.x -= argList[1];
xEvent.y -= argList[3];
if (result == 0 && xEvent.button == 1) {
int[] argList2 = {OS.XmNwidth, 0, OS.XmNheight, 0};
OS.XtGetValues(handle, argList2, argList2.length / 2);
int width = argList2[1], height = argList2[3];
if (0 <= xEvent.x && xEvent.x < width && 0 <= xEvent.y && xEvent.y < height) {
click(xEvent.x > width - 12, xEvent.state);
}
setDrawPressed(set);
}
return result;
}
int XButtonRelease(int w, int client_data, int call_data, int continue_to_dispatch) {
int result = super.XButtonRelease(w, client_data, call_data, continue_to_dispatch);
if (result != 0) return result;
XButtonEvent xEvent = new XButtonEvent();
OS.memmove(xEvent, call_data, XButtonEvent.sizeof);
if (xEvent.button != 1) return result;
if (!dragging) return result;
dragging = false;
int[] argList = {OS.XmNwidth, 0, OS.XmNheight, 0, OS.XmNborderWidth, 0};
OS.XtGetValues(handle, argList, argList.length / 2);
int border = argList[5];
int width = argList[1] + (border * 2), height = argList[3] + (border * 2);
Event event = new Event();
event.time = xEvent.time;
event.x = lastX;
event.y = lastY;
event.width = width;
event.height = height;
drawBand(lastX, lastY, width, height);
sendEvent(SWT.Selection, event);
if (isDisposed()) return result;
if (event.doit) {
if ((style & SWT.SMOOTH) != 0) {
setBounds(event.x, event.y, width, height);
// widget could be disposed at this point
}
}
return result;
}
int XEnterWindow(int w, int client_data, int call_data, int continue_to_dispatch) {
XCrossingEvent xEvent = new XCrossingEvent();
OS.memmove(xEvent, call_data, XCrossingEvent.sizeof);
if ((xEvent.state & OS.Button1Mask) != 0) {
setDrawPressed(!set);
} else {
if ((parent.style & SWT.FLAT) != 0) redraw();
}
return 0;
}
int XLeaveWindow(int w, int client_data, int call_data, int continue_to_dispatch) {
display.removeMouseHoverTimeOut();
display.hideToolTip();
XCrossingEvent xEvent = new XCrossingEvent();
OS.memmove(xEvent, call_data, XCrossingEvent.sizeof);
if ((xEvent.state & OS.Button1Mask) != 0) {
setDrawPressed(set);
} else {
if ((parent.style & SWT.FLAT) != 0) redraw();
}
return 0;
}
int XPointerMotion(int w, int client_data, int call_data, int continue_to_dispatch) {
int result = super.XPointerMotion(w, client_data, call_data, continue_to_dispatch);
if (result != 0) return result;
XMotionEvent xEvent = new XMotionEvent();
OS.memmove(xEvent, call_data, XMotionEvent.sizeof);
if (!dragging || (xEvent.state & OS.Button1Mask) == 0) return result;
short[] x_root = new short[1], y_root = new short[1];
OS.XtTranslateCoords(handle, (short) 0, (short) 0, x_root, y_root);
int eventX = xEvent.x_root - x_root[0], eventY = xEvent.y_root - y_root[0];
int[] argList1 = {
OS.XmNx, 0, OS.XmNy, 0, OS.XmNwidth, 0, OS.XmNheight, 0, OS.XmNborderWidth, 0
};
OS.XtGetValues(handle, argList1, argList1.length / 2);
int border = argList1[9],
x = ((short) argList1[1]) - border,
y = ((short) argList1[3]) - border;
int width = argList1[5] + (border * 2), height = argList1[7] + (border * 2);
int[] argList2 = {OS.XmNwidth, 0, OS.XmNheight, 0, OS.XmNborderWidth, 0};
OS.XtGetValues(parent.handle, argList2, argList2.length / 2);
int parentBorder = argList2[5];
int parentWidth = argList2[1] + (parentBorder * 2);
int parentHeight = argList2[3] + (parentBorder * 2);
int newX = lastX, newY = lastY;
if ((style & SWT.VERTICAL) != 0) {
newX = Math.min(Math.max(0, eventX + x - startX - parentBorder), parentWidth - width);
} else {
newY = Math.min(Math.max(0, eventY + y - startY - parentBorder), parentHeight - height);
}
if (newX == lastX && newY == lastY) return result;
drawBand(lastX, lastY, width, height);
Event event = new Event();
event.time = xEvent.time;
event.x = newX;
event.y = newY;
event.width = width;
event.height = height;
if ((style & SWT.SMOOTH) == 0) {
event.detail = SWT.DRAG;
}
sendEvent(SWT.Selection, event);
if (isDisposed()) return result;
if (event.doit) {
lastX = event.x;
lastY = event.y;
}
parent.update(true);
drawBand(lastX, lastY, width, height);
if ((style & SWT.SMOOTH) != 0) {
setBounds(lastX, lastY, width, height);
// widget could be disposed at this point
}
return result;
}
int XFocusChange(int w, int client_data, int call_data, int continue_to_dispatch) {
/*
* Forward the focus event to the parent.
* This is necessary so that focus listeners
* in the parent will be called, despite the
* fact that the event did not really occur
* in X in the parent. This is done to be
* compatible with Windows.
*/
XFocusChangeEvent xEvent = new XFocusChangeEvent();
OS.memmove(xEvent, call_data, XFocusChangeEvent.sizeof);
xEvent.window = OS.XtWindow(parent.handle);
// OS.memmove (call_data, xEvent, XFocusChangeEvent.sizeof);
parent.XFocusChange(w, client_data, call_data, continue_to_dispatch);
return 0;
}
int XButtonPress(int w, int client_data, int call_data, int continue_to_dispatch) {
int result = super.XButtonPress(w, client_data, call_data, continue_to_dispatch);
if (result != 0) return result;
XButtonEvent xEvent = new XButtonEvent();
OS.memmove(xEvent, call_data, XButtonEvent.sizeof);
if (xEvent.button != 1) return result;
short[] x_root = new short[1], y_root = new short[1];
OS.XtTranslateCoords(handle, (short) 0, (short) 0, x_root, y_root);
startX = xEvent.x_root - x_root[0];
startY = xEvent.y_root - y_root[0];
int[] argList = {OS.XmNx, 0, OS.XmNy, 0, OS.XmNwidth, 0, OS.XmNheight, 0, OS.XmNborderWidth, 0};
OS.XtGetValues(handle, argList, argList.length / 2);
int border = argList[9], width = argList[5] + (border * 2), height = argList[7] + (border * 2);
lastX = ((short) argList[1]) - border;
lastY = ((short) argList[3]) - border;
Event event = new Event();
event.time = xEvent.time;
event.x = lastX;
event.y = lastY;
event.width = width;
event.height = height;
if ((style & SWT.SMOOTH) == 0) {
event.detail = SWT.DRAG;
}
sendEvent(SWT.Selection, event);
if (isDisposed()) return result;
if (event.doit) {
dragging = true;
lastX = event.x;
lastY = event.y;
parent.update(true);
drawBand(event.x, event.y, width, height);
if ((style & SWT.SMOOTH) != 0) {
setBounds(event.x, event.y, width, height);
// widget could be disposed at this point
}
}
return result;
}
int XmNexposureCallback(int w, int client_data, int call_data) {
if ((style & SWT.SEPARATOR) != 0) return 0;
int xDisplay = OS.XtDisplay(handle);
if (xDisplay == 0) return 0;
int xWindow = OS.XtWindow(handle);
if (xWindow == 0) return 0;
int[] argList = {
OS.XmNcolormap, 0,
OS.XmNwidth, 0,
OS.XmNheight, 0,
};
OS.XtGetValues(handle, argList, argList.length / 2);
int width = argList[3], height = argList[5];
Image currentImage = image;
boolean enabled = getEnabled();
if ((parent.style & SWT.FLAT) != 0) {
boolean hasCursor = hasCursor();
/* Set the shadow thickness */
int thickness = 0;
if (set || (hasCursor && enabled)) {
thickness = Math.min(2, display.buttonShadowThickness);
}
argList = new int[] {OS.XmNshadowThickness, thickness};
OS.XtSetValues(handle, argList, argList.length / 2);
/* Determine if hot image should be used */
if (enabled && hasCursor && hotImage != null) {
currentImage = hotImage;
}
}
GCData data = new GCData();
data.device = display;
data.display = xDisplay;
data.drawable = xWindow;
data.font = parent.font;
data.colormap = argList[1];
int xGC = OS.XCreateGC(xDisplay, xWindow, 0, null);
if (xGC == 0) SWT.error(SWT.ERROR_NO_HANDLES);
GC gc = GC.motif_new(xGC, data);
XmAnyCallbackStruct cb = new XmAnyCallbackStruct();
OS.memmove(cb, call_data, XmAnyCallbackStruct.sizeof);
if (cb.event != 0) {
XExposeEvent xEvent = new XExposeEvent();
OS.memmove(xEvent, cb.event, XExposeEvent.sizeof);
Rectangle rect = new Rectangle(xEvent.x, xEvent.y, xEvent.width, xEvent.height);
gc.setClipping(rect);
}
if (!enabled) {
currentImage = disabledImage;
if (currentImage == null && image != null) {
currentImage = new Image(display, image, SWT.IMAGE_DISABLE);
}
Color disabledColor = display.getSystemColor(SWT.COLOR_WIDGET_NORMAL_SHADOW);
gc.setForeground(disabledColor);
} else {
gc.setForeground(parent.getForeground());
}
gc.setBackground(parent.getBackground());
int textX = 0, textY = 0, textWidth = 0, textHeight = 0;
if (text.length() != 0) {
int flags = SWT.DRAW_DELIMITER | SWT.DRAW_TAB | SWT.DRAW_MNEMONIC;
Point textExtent = gc.textExtent(text, flags);
textWidth = textExtent.x;
textHeight = textExtent.y;
}
int imageX = 0, imageY = 0, imageWidth = 0, imageHeight = 0;
if (currentImage != null) {
Rectangle imageBounds = currentImage.getBounds();
imageWidth = imageBounds.width;
imageHeight = imageBounds.height;
}
int spacing = 0;
if (textWidth != 0 && imageWidth != 0) spacing = 2;
if ((parent.style & SWT.RIGHT) != 0) {
imageX = (width - imageWidth - textWidth - spacing) / 2;
imageY = (height - imageHeight) / 2;
textX = spacing + imageX + imageWidth;
textY = (height - textHeight) / 2;
} else {
imageX = (width - imageWidth) / 2;
imageY = (height - imageHeight - textHeight - spacing) / 2;
textX = (width - textWidth) / 2;
textY = spacing + imageY + imageHeight;
}
if ((style & SWT.DROP_DOWN) != 0) {
textX -= 6;
imageX -= 6;
}
if (textWidth > 0) {
int flags = SWT.DRAW_DELIMITER | SWT.DRAW_TAB | SWT.DRAW_MNEMONIC | SWT.DRAW_TRANSPARENT;
gc.drawText(text, textX, textY, flags);
}
if (imageWidth > 0) gc.drawImage(currentImage, imageX, imageY);
if ((style & SWT.DROP_DOWN) != 0) {
int startX = width - 12, startY = (height - 2) / 2;
int[] arrow = {startX, startY, startX + 3, startY + 3, startX + 6, startY};
gc.setBackground(parent.getForeground());
gc.fillPolygon(arrow);
gc.drawPolygon(arrow);
}
gc.dispose();
OS.XFreeGC(xDisplay, xGC);
if (!enabled && disabledImage == null) {
if (currentImage != null) currentImage.dispose();
}
return 0;
}
int XKeyPress(int w, int client_data, int call_data, int continue_to_dispatch) {
int result = super.XKeyPress(w, client_data, call_data, continue_to_dispatch);
if (result != 0) return result;
XKeyEvent xEvent = new XKeyEvent();
OS.memmove(xEvent, call_data, XKeyEvent.sizeof);
byte[] buffer = new byte[1];
int[] keysym = new int[1];
OS.XLookupString(xEvent, buffer, buffer.length, keysym, null);
switch (keysym[0]) {
case OS.XK_Left:
case OS.XK_Right:
case OS.XK_Up:
case OS.XK_Down:
int xChange = 0, yChange = 0;
int stepSize = PAGE_INCREMENT;
if ((xEvent.state & OS.ControlMask) != 0) stepSize = INCREMENT;
if ((style & SWT.VERTICAL) != 0) {
if (keysym[0] == OS.XK_Up || keysym[0] == OS.XK_Down) break;
xChange = keysym[0] == OS.XK_Left ? -stepSize : stepSize;
} else {
if (keysym[0] == OS.XK_Left || keysym[0] == OS.XK_Right) break;
yChange = keysym[0] == OS.XK_Up ? -stepSize : stepSize;
}
int[] argList1 = {OS.XmNwidth, 0, OS.XmNheight, 0, OS.XmNborderWidth, 0};
OS.XtGetValues(handle, argList1, argList1.length / 2);
int border = argList1[5];
int width = argList1[1] + (border * 2), height = argList1[3] + (border * 2);
int[] argList2 = {OS.XmNwidth, 0, OS.XmNheight, 0, OS.XmNborderWidth, 0};
OS.XtGetValues(parent.handle, argList2, argList2.length / 2);
int parentBorder = argList2[5];
int parentWidth = argList2[1] + (parentBorder * 2);
int parentHeight = argList2[3] + (parentBorder * 2);
int newX = lastX, newY = lastY;
if ((style & SWT.VERTICAL) != 0) {
newX =
Math.min(Math.max(0, lastX + xChange - parentBorder - startX), parentWidth - width);
} else {
newY =
Math.min(Math.max(0, lastY + yChange - parentBorder - startY), parentHeight - height);
}
if (newX == lastX && newY == lastY) return result;
/* Ensure that the pointer image does not change */
int xDisplay = display.xDisplay;
int xWindow = OS.XtWindow(parent.handle);
int ptrGrabResult =
OS.XGrabPointer(
xDisplay,
xWindow,
1,
OS.None,
OS.GrabModeAsync,
OS.GrabModeAsync,
OS.None,
cursor,
OS.CurrentTime);
Event event = new Event();
event.time = xEvent.time;
event.x = newX;
event.y = newY;
event.width = width;
event.height = height;
sendEvent(SWT.Selection, event);
if (ptrGrabResult == OS.GrabSuccess) OS.XUngrabPointer(xDisplay, OS.CurrentTime);
if (isDisposed()) break;
if (event.doit) {
lastX = event.x;
lastY = event.y;
if ((style & SWT.SMOOTH) != 0) {
setBounds(event.x, event.y, width, height);
if (isDisposed()) break;
}
int cursorX = event.x, cursorY = event.y;
if ((style & SWT.VERTICAL) != 0) {
cursorY += height / 2;
} else {
cursorX += width / 2;
}
OS.XWarpPointer(xDisplay, OS.None, xWindow, 0, 0, 0, 0, cursorX, cursorY);
}
break;
}
return result;
}
int XKeyPress(int w, int client_data, int call_data, int continue_to_dispatch) {
int result = super.XKeyPress(w, client_data, call_data, continue_to_dispatch);
if (result != 0) return result;
XKeyEvent keyEvent = new XKeyEvent();
OS.memmove(keyEvent, call_data, XKeyEvent.sizeof);
if (keyEvent.keycode != 0) {
int[] keysym = new int[1];
OS.XLookupString(keyEvent, null, 0, keysym, null);
keysym[0] &= 0xFFFF;
int xChange = 0, yChange = 0;
int stepSize = ((keyEvent.state & OS.ControlMask) != 0) ? STEPSIZE_SMALL : STEPSIZE_LARGE;
switch (keysym[0]) {
case OS.XK_KP_Enter:
case OS.XK_Return:
tracking = false;
/* Eat the subsequent KeyRelease event */
OS.XtAppNextEvent(OS.XtDisplayToApplicationContext(keyEvent.display), call_data);
break;
case OS.XK_Escape:
tracking = false;
cancelled = true;
/* Eat the subsequent KeyRelease event */
OS.XtAppNextEvent(OS.XtDisplayToApplicationContext(keyEvent.display), call_data);
break;
case OS.XK_Left:
xChange = -stepSize;
break;
case OS.XK_Right:
xChange = stepSize;
break;
case OS.XK_Up:
yChange = -stepSize;
break;
case OS.XK_Down:
yChange = stepSize;
break;
}
if (xChange != 0 || yChange != 0) {
Rectangle[] oldRectangles = rectangles;
boolean oldStippled = stippled;
Rectangle[] rectsToErase = new Rectangle[rectangles.length];
for (int i = 0; i < rectangles.length; i++) {
Rectangle current = rectangles[i];
rectsToErase[i] = new Rectangle(current.x, current.y, current.width, current.height);
}
Event event = new Event();
event.x = oldX + xChange;
event.y = oldY + yChange;
Point cursorPos;
if ((style & SWT.RESIZE) != 0) {
resizeRectangles(xChange, yChange);
sendEvent(SWT.Resize, event);
/*
* It is possible (but unlikely) that application code
* could have disposed the widget in the resize event.
* If this happens then return false to indicate that
* the move failed.
*/
if (isDisposed()) {
cancelled = true;
return 1;
}
boolean draw = false;
/*
* It is possible that application code could have
* changed the rectangles in the resize event. If this
* happens then only redraw the tracker if the rectangle
* values have changed.
*/
if (rectangles != oldRectangles) {
int length = rectangles.length;
if (length != rectsToErase.length) {
draw = true;
} else {
for (int i = 0; i < length; i++) {
if (!rectangles[i].equals(rectsToErase[i])) {
draw = true;
break;
}
}
}
} else {
draw = true;
}
if (draw) {
drawRectangles(rectsToErase, oldStippled);
update();
drawRectangles(rectangles, stippled);
}
cursorPos = adjustResizeCursor();
} else {
moveRectangles(xChange, yChange);
sendEvent(SWT.Move, event);
/*
* It is possible (but unlikely) that application code
* could have disposed the widget in the move event.
* If this happens then return false to indicate that
* the move failed.
*/
if (isDisposed()) {
cancelled = true;
return 1;
}
boolean draw = false;
/*
* It is possible that application code could have
* changed the rectangles in the move event. If this
* happens then only redraw the tracker if the rectangle
* values have changed.
*/
if (rectangles != oldRectangles) {
int length = rectangles.length;
if (length != rectsToErase.length) {
draw = true;
} else {
for (int i = 0; i < length; i++) {
if (!rectangles[i].equals(rectsToErase[i])) {
draw = true;
break;
}
}
}
} else {
draw = true;
}
if (draw) {
drawRectangles(rectsToErase, oldStippled);
update();
drawRectangles(rectangles, stippled);
}
cursorPos = adjustMoveCursor();
}
if (cursorPos != null) {
oldX = cursorPos.x;
oldY = cursorPos.y;
}
}
}
return result;
}
/**
* Displays the Tracker rectangles for manipulation by the user. Returns when the user has either
* finished manipulating the rectangles or has cancelled the Tracker.
*
* @return <code>true</code> if the user did not cancel the Tracker, <code>false</code> otherwise
* @exception SWTException
* <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
* </ul>
*/
public boolean open() {
checkWidget();
int xDisplay = display.xDisplay;
window = OS.XDefaultRootWindow(xDisplay);
if (parent != null) {
window = OS.XtWindow(parent.handle);
if (window == 0) return false;
}
cancelled = false;
tracking = true;
update();
drawRectangles(rectangles, stippled);
int[] oldX = new int[1], oldY = new int[1];
int[] unused = new int[1], mask = new int[1];
OS.XQueryPointer(xDisplay, window, unused, unused, oldX, oldY, unused, unused, mask);
/*
* If exactly one of UP/DOWN is specified as a style then set the cursor
* orientation accordingly (the same is done for LEFT/RIGHT styles below).
*/
int vStyle = style & (SWT.UP | SWT.DOWN);
if (vStyle == SWT.UP || vStyle == SWT.DOWN) {
cursorOrientation |= vStyle;
}
int hStyle = style & (SWT.LEFT | SWT.RIGHT);
if (hStyle == SWT.LEFT || hStyle == SWT.RIGHT) {
cursorOrientation |= hStyle;
}
int mouseMasks = OS.Button1Mask | OS.Button2Mask | OS.Button3Mask;
boolean mouseDown = (mask[0] & mouseMasks) != 0;
if (!mouseDown) {
Point cursorPos = null;
if ((style & SWT.RESIZE) != 0) {
cursorPos = adjustResizeCursor();
} else {
cursorPos = adjustMoveCursor();
}
if (cursorPos != null) {
oldX[0] = cursorPos.x;
oldY[0] = cursorPos.y;
}
}
this.oldX = oldX[0];
this.oldY = oldY[0];
int ptrGrabResult =
OS.XGrabPointer(
xDisplay,
window,
0,
OS.ButtonPressMask | OS.ButtonReleaseMask | OS.PointerMotionMask,
OS.GrabModeAsync,
OS.GrabModeAsync,
OS.None,
OS.None,
OS.CurrentTime);
int kbdGrabResult =
OS.XGrabKeyboard(xDisplay, window, 0, OS.GrabModeAsync, OS.GrabModeAsync, OS.CurrentTime);
/* Tracker behaves like a Dialog with its own OS event loop. */
XAnyEvent anyEvent = new XAnyEvent();
int xEvent = OS.XtMalloc(XEvent.sizeof);
int dispatch = OS.XtMalloc(4);
int xtContext = OS.XtDisplayToApplicationContext(xDisplay);
while (tracking) {
if (parent != null && parent.isDisposed()) break;
OS.XtAppNextEvent(xtContext, xEvent);
OS.memmove(anyEvent, xEvent, XAnyEvent.sizeof);
int widget = OS.XtWindowToWidget(anyEvent.display, anyEvent.window);
switch (anyEvent.type) {
case OS.MotionNotify:
XPointerMotion(widget, 0, xEvent, dispatch);
break;
case OS.ButtonRelease:
XButtonRelease(widget, 0, xEvent, dispatch);
break;
case OS.KeyPress:
XKeyPress(widget, 0, xEvent, dispatch);
break;
case OS.KeyRelease:
XKeyRelease(widget, 0, xEvent, dispatch);
break;
case OS.ButtonPress:
case OS.EnterNotify:
case OS.LeaveNotify:
/* Do not dispatch these */
break;
case OS.Expose:
update();
drawRectangles(rectangles, stippled);
OS.XtDispatchEvent(xEvent);
drawRectangles(rectangles, stippled);
break;
default:
OS.XtDispatchEvent(xEvent);
}
}
if (xEvent != 0) OS.XtFree(xEvent);
if (dispatch != 0) OS.XtFree(dispatch);
if (!isDisposed()) {
update();
drawRectangles(rectangles, stippled);
}
if (ptrGrabResult == OS.GrabSuccess) OS.XUngrabPointer(xDisplay, OS.CurrentTime);
if (kbdGrabResult == OS.GrabSuccess) OS.XUngrabKeyboard(xDisplay, OS.CurrentTime);
window = 0;
return !cancelled;
}
void init(int red, int green, int blue) {
if ((red > 255) || (red < 0) || (green > 255) || (green < 0) || (blue > 255) || (blue < 0)) {
SWT.error(SWT.ERROR_INVALID_ARGUMENT);
}
XColor xColor = new XColor();
xColor.red = (short) ((red & 0xFF) | ((red & 0xFF) << 8));
xColor.green = (short) ((green & 0xFF) | ((green & 0xFF) << 8));
xColor.blue = (short) ((blue & 0xFF) | ((blue & 0xFF) << 8));
handle = xColor;
int xDisplay = device.xDisplay;
int screen = OS.XDefaultScreen(xDisplay);
int colormap = OS.XDefaultColormap(xDisplay, screen);
/* 1. Try to allocate the color */
if (OS.XAllocColor(xDisplay, colormap, xColor) != 0) {
if (device.colorRefCount != null) {
/* Make a copy of the color to put in the colors array */
XColor colorCopy = new XColor();
colorCopy.red = xColor.red;
colorCopy.green = xColor.green;
colorCopy.blue = xColor.blue;
colorCopy.pixel = xColor.pixel;
device.xcolors[colorCopy.pixel] = colorCopy;
device.colorRefCount[xColor.pixel]++;
}
return;
}
/*
* 2. Allocation failed. Query the entire colormap and
* find the closest match which can be allocated.
* This should never occur on a truecolor display.
*/
Visual visual = new Visual();
OS.memmove(visual, OS.XDefaultVisual(xDisplay, screen), Visual.sizeof);
int mapEntries = visual.map_entries;
XColor[] queried = new XColor[mapEntries];
int[] distances = new int[mapEntries];
/*
* Query all colors in the colormap and calculate the distance
* from each to the desired color.
*/
for (int i = 0; i < mapEntries; i++) {
XColor color = new XColor();
color.pixel = i;
queried[i] = color;
OS.XQueryColor(xDisplay, colormap, color);
int r = red - ((color.red >> 8) & 0xFF);
int g = green - ((color.green >> 8) & 0xFF);
int b = blue - ((color.blue >> 8) & 0xFF);
distances[i] = r * r + g * g + b * b;
}
/*
* Try to allocate closest matching queried color.
* The allocation can fail if the closest matching
* color is allocated privately, so go through them
* in order of increasing distance.
*/
for (int i = 0; i < mapEntries; i++) {
int minDist = 0x30000;
int minIndex = 0;
for (int j = 0; j < mapEntries; j++) {
if (distances[j] < minDist) {
minDist = distances[j];
minIndex = j;
}
}
XColor queriedColor = queried[minIndex];
XColor osColor = new XColor();
osColor.red = queriedColor.red;
osColor.green = queriedColor.green;
osColor.blue = queriedColor.blue;
if (OS.XAllocColor(xDisplay, colormap, osColor) != 0) {
/* Allocation succeeded. Copy the fields into the handle */
xColor.red = osColor.red;
xColor.green = osColor.green;
xColor.blue = osColor.blue;
xColor.pixel = osColor.pixel;
if (device.colorRefCount != null) {
/* Put osColor in the colors array */
device.xcolors[osColor.pixel] = osColor;
device.colorRefCount[osColor.pixel]++;
}
return;
}
/* The allocation failed; matching color is allocated privately */
distances[minIndex] = 0x30000;
}
/*
* 3. Couldn't allocate any of the colors in the colormap.
* This means all colormap entries were allocated privately
* by other applications. Give up and allocate black.
*/
XColor osColor = new XColor();
OS.XAllocColor(xDisplay, colormap, osColor);
/* Copy the fields into the handle */
xColor.red = osColor.red;
xColor.green = osColor.green;
xColor.blue = osColor.blue;
xColor.pixel = osColor.pixel;
if (device.colorRefCount != null) {
/* Put osColor in the colors array */
device.xcolors[osColor.pixel] = osColor;
device.colorRefCount[osColor.pixel]++;
}
}
