Esempio n. 1
0
  /**
   * Translate coordinates from one window into another. Optimized for XAWT - uses cached data when
   * possible. Preferable over pure XTranslateCoordinates.
   *
   * @return coordinates relative to dst, or null if error happened
   */
  static Point toOtherWindow(long src, long dst, int x, int y) {
    Point rpt = new Point(0, 0);

    // Check if both windows belong to XAWT - then no X calls are necessary

    XBaseWindow srcPeer = XToolkit.windowToXWindow(src);
    XBaseWindow dstPeer = XToolkit.windowToXWindow(dst);

    if (srcPeer != null && dstPeer != null) {
      // (x, y) is relative to src
      rpt.x = x + srcPeer.getAbsoluteX() - dstPeer.getAbsoluteX();
      rpt.y = y + srcPeer.getAbsoluteY() - dstPeer.getAbsoluteY();
    } else if (dstPeer != null && XlibUtil.isRoot(src, dstPeer.getScreenNumber())) {
      // from root into peer
      rpt.x = x - dstPeer.getAbsoluteX();
      rpt.y = y - dstPeer.getAbsoluteY();
    } else if (srcPeer != null && XlibUtil.isRoot(dst, srcPeer.getScreenNumber())) {
      // from peer into root
      rpt.x = x + srcPeer.getAbsoluteX();
      rpt.y = y + srcPeer.getAbsoluteY();
    } else {
      rpt = XlibUtil.translateCoordinates(src, dst, new Point(x, y));
    }
    return rpt;
  }
  /** Returns the client window under the specified root subwindow. */
  private static long findClientWindow(long window) {
    if (XlibUtil.isTrueToplevelWindow(window)) {
      return window;
    }

    Set<Long> children = XlibUtil.getChildWindows(window);
    for (Long child : children) {
      long win = findClientWindow(child);
      if (win != 0) {
        return win;
      }
    }

    return 0;
  }
Esempio n. 3
0
 final void dumpParent() {
   long parent = XlibUtil.getParentWindow(getShell());
   if (parent != 0) {
     dumpWindow("Parent", parent);
   } else {
     System.err.println(">>> NO PARENT");
   }
 }
Esempio n. 4
0
 boolean processXEmbedInfo() {
   long xembed_info_data = Native.allocateLongArray(2);
   try {
     if (!XEmbedInfo.getAtomData(handle, xembed_info_data, 2)) {
       // No more XEMBED_INFO? This is not XEmbed client!
       // Unfortunately this is the initial state of the most clients
       // FIXME: add 5-state processing
       // childDestroyed();
       xembedLog.finer("Unable to get XEMBED_INFO atom data");
       return false;
     }
     version = Native.getCard32(xembed_info_data, 0);
     flags = Native.getCard32(xembed_info_data, 1);
     boolean new_mapped = (flags & XEMBED_MAPPED) != 0;
     boolean currently_mapped = XlibUtil.getWindowMapState(handle) != XConstants.IsUnmapped;
     if (new_mapped != currently_mapped) {
       if (xembedLog.isLoggable(PlatformLogger.FINER))
         xembedLog.fine(
             "Mapping state of the client has changed, old state: "
                 + currently_mapped
                 + ", new state: "
                 + new_mapped);
       if (new_mapped) {
         XToolkit.awtLock();
         try {
           XlibWrapper.XMapWindow(XToolkit.getDisplay(), handle);
         } finally {
           XToolkit.awtUnlock();
         }
       } else {
         XToolkit.awtLock();
         try {
           XlibWrapper.XUnmapWindow(XToolkit.getDisplay(), handle);
         } finally {
           XToolkit.awtUnlock();
         }
       }
     } else {
       xembedLog.finer("Mapping state didn't change, mapped: " + currently_mapped);
     }
     return true;
   } finally {
     XlibWrapper.unsafe.freeMemory(xembed_info_data);
   }
 }
Esempio n. 5
0
  public void handleConfigureNotifyEvent(XEvent xev) {
    assert (SunToolkit.isAWTLockHeldByCurrentThread());
    XConfigureEvent xe = xev.get_xconfigure();
    if (insLog.isLoggable(Level.FINE)) {
      insLog.log(Level.FINE, "Configure notify {0}", new Object[] {String.valueOf(xe)});
    }

    // XXX: should really only consider synthetic events, but
    if (isReparented()) {
      configure_seen = true;
    }

    if (!isMaximized()
        && (xe.get_serial() == reparent_serial || xe.get_window() != getShell())
        && !no_reparent_artifacts) {
      insLog.fine("- reparent artifact, skipping");
      return;
    }
    no_reparent_artifacts = false;

    /**
     * When there is a WM we receive some CN before being visible and after. We should skip all CN
     * which are before being visible, because we assume the gravity is in action while it is not
     * yet.
     *
     * <p>When there is no WM we receive CN only _before_ being visible. We should process these
     * CNs.
     */
    if (!isVisible() && XWM.getWMID() != XWM.NO_WM) {
      insLog.fine(" - not visible, skipping");
      return;
    }

    /*
     * Some window managers configure before we are reparented and
     * the send event flag is set! ugh... (Enlighetenment for one,
     * possibly MWM as well).  If we haven't been reparented yet
     * this is just the WM shuffling us into position.  Ignore
     * it!!!! or we wind up in a bogus location.
     */
    int runningWM = XWM.getWMID();
    if (insLog.isLoggable(Level.FINE)) {
      insLog.log(
          Level.FINE,
          "reparented={0}, visible={1}, WM={2}, decorations={3}",
          new Object[] {isReparented(), isVisible(), runningWM, getDecorations()});
    }
    if (!isReparented()
        && isVisible()
        && runningWM != XWM.NO_WM
        && !XWM.isNonReparentingWM()
        && getDecorations() != winAttr.AWT_DECOR_NONE) {
      insLog.fine("- visible but not reparented, skipping");
      return;
    }
    // Last chance to correct insets
    if (!insets_corrected && getDecorations() != winAttr.AWT_DECOR_NONE) {
      long parent = XlibUtil.getParentWindow(window);
      Insets correctWM = (parent != -1) ? XWM.getWM().getInsets(this, window, parent) : null;
      if (insLog.isLoggable(Level.FINER)) {
        if (correctWM != null) {
          insLog.finer("Configure notify - insets : " + correctWM);
        } else {
          insLog.finer("Configure notify - insets are still not available");
        }
      }
      if (correctWM != null) {
        handleCorrectInsets(correctWM);
      } else {
        // Only one attempt to correct insets is made (to lower risk)
        // if insets are still not available we simply set the flag
        insets_corrected = true;
      }
    }

    updateChildrenSizes();

    // Bounds of the window
    Rectangle targetBounds =
        new Rectangle(
            ComponentAccessor.getX((Component) target),
            ComponentAccessor.getY((Component) target),
            ComponentAccessor.getWidth((Component) target),
            ComponentAccessor.getHeight((Component) target));

    Point newLocation = targetBounds.getLocation();
    if (xe.get_send_event() || runningWM == XWM.NO_WM || XWM.isNonReparentingWM()) {
      // Location, Client size + insets
      newLocation = new Point(xe.get_x() - currentInsets.left, xe.get_y() - currentInsets.top);
    } else {
      // CDE/MWM/Metacity/Sawfish bug: if shell is resized using
      // top or left border, we don't receive synthetic
      // ConfigureNotify, only the one from X with zero
      // coordinates.  This is the workaround to get real
      // location, 6261336
      switch (XWM.getWMID()) {
        case XWM.CDE_WM:
        case XWM.MOTIF_WM:
        case XWM.METACITY_WM:
        case XWM.SAWFISH_WM:
          {
            Point xlocation = queryXLocation();
            if (log.isLoggable(Level.FINE)) {
              log.log(Level.FINE, "New X location: {0}", new Object[] {String.valueOf(xlocation)});
            }
            if (xlocation != null) {
              newLocation = xlocation;
            }
            break;
          }
        default:
          break;
      }
    }

    WindowDimensions newDimensions =
        new WindowDimensions(
            newLocation, new Dimension(xe.get_width(), xe.get_height()), copy(currentInsets), true);

    if (insLog.isLoggable(Level.FINER)) {
      insLog.log(
          Level.FINER,
          "Insets are {0}, new dimensions {1}",
          new Object[] {String.valueOf(currentInsets), String.valueOf(newDimensions)});
    }

    checkIfOnNewScreen(newDimensions.getBounds());

    Point oldLocation = getLocation();
    dimensions = newDimensions;
    if (!newLocation.equals(oldLocation)) {
      handleMoved(newDimensions);
    }
    reconfigureContentWindow(newDimensions);
    updateChildrenSizes();
  }
Esempio n. 6
0
 private Point queryXLocation() {
   return XlibUtil.translateCoordinates(
       getContentWindow(),
       XlibWrapper.RootWindow(XToolkit.getDisplay(), getScreenNumber()),
       new Point(0, 0));
 }
 public int getAbsoluteY() {
   Point absoluteLoc =
       XlibUtil.translateCoordinates(
           getWindow(), XToolkit.getDefaultRootWindow(), new Point(0, 0));
   return absoluteLoc != null ? absoluteLoc.y : 0;
 }