public Dimension preferredLayoutSize(Container parent) {
      JToolBar tb = (JToolBar) parent;
      Insets insets = tb.getInsets();
      Dimension dim = new Dimension();
      SeaGlassContext context = getContext(tb);

      if (tb.getOrientation() == JToolBar.HORIZONTAL) {
        dim.width = tb.isFloatable() ? SeaGlassIcon.getIconWidth(handleIcon, context) : 0;
        Dimension compDim;
        for (int i = 0; i < tb.getComponentCount(); i++) {
          Component component = tb.getComponent(i);
          if (component.isVisible()) {
            compDim = component.getPreferredSize();
            dim.width += compDim.width;
            dim.height = Math.max(dim.height, compDim.height);
          }
        }
      } else {
        dim.height = tb.isFloatable() ? SeaGlassIcon.getIconHeight(handleIcon, context) : 0;
        Dimension compDim;
        for (int i = 0; i < tb.getComponentCount(); i++) {
          Component component = tb.getComponent(i);
          if (component.isVisible()) {
            compDim = component.getPreferredSize();
            dim.width = Math.max(dim.width, compDim.width);
            dim.height += compDim.height;
          }
        }
      }
      dim.width += insets.left + insets.right;
      dim.height += insets.top + insets.bottom;

      context.dispose();
      return dim;
    }
예제 #2
0
    /**
     * This method is called when the mouse is released from the JToolBar.
     *
     * @param e The MouseEvent.
     */
    public void mouseReleased(MouseEvent e) {
      if (!isDragging || !toolBar.isFloatable()) return;

      isDragging = false;
      floatAt(e.getPoint(), origin);
      dragWindow.hide();
    }
예제 #3
0
    /**
     * This method is called when the mouse is pressed in the JToolBar. If the press doesn't occur
     * in a place where it causes the JToolBar to be dragged, it returns. Otherwise, it starts a
     * drag session.
     *
     * @param e The MouseEvent.
     */
    public void mousePressed(MouseEvent e) {
      if (!toolBar.isFloatable()) return;

      Point ssd = e.getPoint();
      Insets insets = toolBar.getInsets();

      // Verify that this click occurs in the top inset.
      if (toolBar.getOrientation() == SwingConstants.HORIZONTAL) {
        if (e.getX() > insets.left) return;
      } else {
        if (e.getY() > insets.top) return;
      }

      origin = new Point(0, 0);
      if (toolBar.isShowing()) SwingUtilities.convertPointToScreen(ssd, toolBar);

      if (!(SwingUtilities.getAncestorOfClass(Window.class, toolBar) instanceof UIResource))
        // Need to know who keeps the toolBar if it gets dragged back into it.
        origParent = toolBar.getParent();

      if (toolBar.isShowing()) SwingUtilities.convertPointToScreen(origin, toolBar);

      isDragging = true;

      if (dragWindow != null)
        dragWindow.setOffset(new Point(cachedBounds.width / 2, cachedBounds.height / 2));

      dragTo(e.getPoint(), origin);
    }
예제 #4
0
    /**
     * This method returns the border insets for the JToolBar.
     *
     * @param c The Component to find insets for.
     * @return The border insets.
     */
    public Insets getBorderInsets(Component c) {
      if (c instanceof JToolBar) {
        JToolBar tb = (JToolBar) c;
        int orientation = tb.getOrientation();

        if (!tb.isFloatable()) return new Insets(regular, regular, regular, regular);
        else if (orientation == SwingConstants.HORIZONTAL)
          return new Insets(regular, offset, regular, regular);
        else return new Insets(offset, regular, regular, regular);
      }

      return new Insets(0, 0, 0, 0);
    }
    public void layoutContainer(Container parent) {
      JToolBar tb = (JToolBar) parent;
      Insets insets = tb.getInsets();
      boolean ltr = tb.getComponentOrientation().isLeftToRight();
      SeaGlassContext context = getContext(tb);

      Component c;
      Dimension d;

      // JToolBar by default uses a somewhat modified BoxLayout as
      // its layout manager. For compatibility reasons, we want to
      // support Box "glue" as a way to move things around on the
      // toolbar. "glue" is represented in BoxLayout as a Box.Filler
      // with a minimum and preferred size of (0,0).
      // So what we do here is find the number of such glue fillers
      // and figure out how much space should be allocated to them.
      int glueCount = 0;
      for (int i = 0; i < tb.getComponentCount(); i++) {
        if (isGlue(tb.getComponent(i))) glueCount++;
      }

      if (tb.getOrientation() == JToolBar.HORIZONTAL) {
        int handleWidth = tb.isFloatable() ? SeaGlassIcon.getIconWidth(handleIcon, context) : 0;

        // Note: contentRect does not take insets into account
        // since it is used for determining the bounds that are
        // passed to paintToolBarContentBackground().
        contentRect.x = ltr ? handleWidth : 0;
        contentRect.y = 0;
        contentRect.width = tb.getWidth() - handleWidth;
        contentRect.height = tb.getHeight();

        // However, we do take the insets into account here for
        // the purposes of laying out the toolbar child components.
        int x = ltr ? handleWidth + insets.left : tb.getWidth() - handleWidth - insets.right;
        int baseY = insets.top;
        int baseH = tb.getHeight() - insets.top - insets.bottom;

        // we need to get the minimum width for laying things out
        // so that we can calculate how much empty space needs to
        // be distributed among the "glue", if any
        int extraSpacePerGlue = 0;
        if (glueCount > 0) {
          int minWidth = minimumLayoutSize(parent).width;
          extraSpacePerGlue = (tb.getWidth() - minWidth) / glueCount;
          if (extraSpacePerGlue < 0) extraSpacePerGlue = 0;
        }

        for (int i = 0; i < tb.getComponentCount(); i++) {
          c = tb.getComponent(i);
          if (c.isVisible()) {
            d = c.getPreferredSize();
            int y, h;
            if (d.height >= baseH || c instanceof JSeparator) {
              // Fill available height
              y = baseY;
              h = baseH;
            } else {
              // Center component vertically in the available
              // space
              y = baseY + (baseH / 2) - (d.height / 2);
              h = d.height;
            }
            // if the component is a "glue" component then add to
            // its
            // width the extraSpacePerGlue it is due
            if (isGlue(c)) d.width += extraSpacePerGlue;
            c.setBounds(ltr ? x : x - d.width, y, d.width, h);
            x = ltr ? x + d.width : x - d.width;
          }
        }
      } else {
        int handleHeight = tb.isFloatable() ? SeaGlassIcon.getIconHeight(handleIcon, context) : 0;

        // See notes above regarding the use of insets
        contentRect.x = 0;
        contentRect.y = handleHeight;
        contentRect.width = tb.getWidth();
        contentRect.height = tb.getHeight() - handleHeight;

        int baseX = insets.left;
        int baseW = tb.getWidth() - insets.left - insets.right;
        int y = handleHeight + insets.top;

        // we need to get the minimum height for laying things out
        // so that we can calculate how much empty space needs to
        // be distributed among the "glue", if any
        int extraSpacePerGlue = 0;
        if (glueCount > 0) {
          int minHeight = minimumLayoutSize(parent).height;
          extraSpacePerGlue = (tb.getHeight() - minHeight) / glueCount;
          if (extraSpacePerGlue < 0) extraSpacePerGlue = 0;
        }

        for (int i = 0; i < tb.getComponentCount(); i++) {
          c = tb.getComponent(i);
          if (c.isVisible()) {
            d = c.getPreferredSize();
            int x, w;
            if (d.width >= baseW || c instanceof JSeparator) {
              // Fill available width
              x = baseX;
              w = baseW;
            } else {
              // Center component horizontally in the available
              // space
              x = baseX + (baseW / 2) - (d.width / 2);
              w = d.width;
            }
            // if the component is a "glue" component then add to
            // its
            // height the extraSpacePerGlue it is due
            if (isGlue(c)) d.height += extraSpacePerGlue;
            c.setBounds(x, y, w, d.height);
            y += d.height;
          }
        }
      }
      context.dispose();
    }