Пример #1
0
 XContentWindow createContent(WindowDimensions dims) {
   Rectangle rec = dims.getBounds();
   // Fix for  - set the location of the content window to the (-left inset, -top inset)
   Insets ins = dims.getInsets();
   if (ins != null) {
     rec.x = -ins.left;
     rec.y = -ins.top;
   } else {
     rec.x = 0;
     rec.y = 0;
   }
   return new XContentWindow(this, rec);
 }
Пример #2
0
 public Rectangle getBounds() {
   return dimensions.getBounds();
 }
Пример #3
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();
  }
Пример #4
0
  // Coordinates are that of the target
  // Called only on Toolkit thread
  public void reshape(WindowDimensions newDimensions, int op, boolean userReshape) {
    if (insLog.isLoggable(Level.FINE)) {
      insLog.fine(
          "Reshaping "
              + this
              + " to "
              + newDimensions
              + " op "
              + op
              + " user reshape "
              + userReshape);
    }
    if (userReshape) {
      // We handle only userReshape == true cases. It means that
      // if the window manager or any other part of the windowing
      // system sets inappropriate size for this window, we can
      // do nothing but accept it.
      Rectangle reqBounds = newDimensions.getBounds();
      Rectangle newBounds =
          constrainBounds(reqBounds.x, reqBounds.y, reqBounds.width, reqBounds.height);
      Insets insets = newDimensions.getInsets();
      Rectangle clientBounds =
          new Rectangle(
              newBounds.x,
              newBounds.y,
              newBounds.width - insets.left - insets.right,
              newBounds.height - insets.top - insets.bottom);
      newDimensions =
          new WindowDimensions(
              newDimensions.isClientSizeSet() ? clientBounds : newBounds,
              insets,
              newDimensions.isClientSizeSet());
    }
    XToolkit.awtLock();
    try {
      if (!isReparented() || !isVisible()) {
        insLog.log(
            Level.FINE,
            "- not reparented({0}) or not visible({1}), default reshape",
            new Object[] {Boolean.valueOf(isReparented()), Boolean.valueOf(visible)});

        // Fix for 6323293.
        // This actually is needed to preserve compatibility with previous releases -
        // some of licensees are expecting componentMoved event on invisible one while
        // its location changes.
        Point oldLocation = getLocation();

        Point newLocation =
            new Point(
                ComponentAccessor.getX((Component) target),
                ComponentAccessor.getY((Component) target));

        if (!newLocation.equals(oldLocation)) {
          handleMoved(newDimensions);
        }

        dimensions = new WindowDimensions(newDimensions);
        updateSizeHints(dimensions);
        Rectangle client = dimensions.getClientRect();
        checkShellRect(client);
        setShellBounds(client);
        if (content != null && !content.getSize().equals(newDimensions.getSize())) {
          reconfigureContentWindow(newDimensions);
        }
        return;
      }

      int wm = XWM.getWMID();
      updateChildrenSizes();
      applyGuessedInsets();

      Rectangle shellRect = newDimensions.getClientRect();

      if (gravityBug()) {
        Insets in = newDimensions.getInsets();
        shellRect.translate(in.left, in.top);
      }

      if ((op & NO_EMBEDDED_CHECK) == 0 && isEmbedded()) {
        shellRect.setLocation(0, 0);
      }

      checkShellRectSize(shellRect);
      if (!isEmbedded()) {
        checkShellRectPos(shellRect);
      }

      op = op & ~NO_EMBEDDED_CHECK;

      if (op == SET_LOCATION) {
        setShellPosition(shellRect);
      } else if (isResizable()) {
        if (op == SET_BOUNDS) {
          setShellBounds(shellRect);
        } else {
          setShellSize(shellRect);
        }
      } else {
        XWM.setShellNotResizable(this, newDimensions, shellRect, true);
        if (op == SET_BOUNDS) {
          setShellPosition(shellRect);
        }
      }

      reconfigureContentWindow(newDimensions);
    } finally {
      XToolkit.awtUnlock();
    }
  }