Beispiel #1
0
 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;
 }
Beispiel #2
0
  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;
  }
Beispiel #3
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;
 }
Beispiel #4
0
 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;
 }
Beispiel #5
0
 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;
 }
Beispiel #6
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;
 }
Beispiel #7
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;
 }
Beispiel #8
0
 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;
 }
Beispiel #9
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;
 }
Beispiel #10
0
  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;
  }
Beispiel #11
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;
  }
Beispiel #12
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 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;
 }
Beispiel #13
0
  /**
   * 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;
  }
Beispiel #14
0
 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]++;
   }
 }