Examples with Border javax.swing.border.Border used on opensource projects

Example 46 with Border

use of javax.swing.border.Border in project intellij-community by JetBrains.

the class DarculaSpinnerUI method createArrow.

private JButton createArrow(@MagicConstant(intValues = { SwingConstants.NORTH, SwingConstants.SOUTH }) int direction) {
    final Color shadow = UIUtil.getPanelBackground();
    final Color enabledColor = new JBColor(Gray._255, UIUtil.getLabelForeground());
    final Color disabledColor = new JBColor(Gray._200, UIUtil.getLabelForeground().darker());
    BasicArrowButton b = new BasicArrowButton(direction, shadow, shadow, enabledColor, shadow) {

        @Override
        public void paint(Graphics g) {
            paintArrowButton(g, this, direction);
        }

        @Override
        public boolean isOpaque() {
            return false;
        }

        @Override
        public void paintTriangle(Graphics g, int x, int y, int size, int direction, boolean isEnabled) {
            final GraphicsConfig config = GraphicsUtil.setupAAPainting(g);
            int mid;
            final int w = 8;
            final int h = 6;
            mid = w / 2;
            g.setColor(isEnabled ? enabledColor : disabledColor);
            g.translate(x, y);
            switch(direction) {
                case SOUTH:
                    g.fillPolygon(new int[] { 0, w, mid }, new int[] { 1, 1, h }, 3);
                    break;
                case NORTH:
                    g.fillPolygon(new int[] { 0, w, mid }, new int[] { h - 1, h - 1, 0 }, 3);
                    break;
                case WEST:
                case EAST:
            }
            g.translate(-x, -y);
            config.restore();
        }
    };
    Border buttonBorder = UIManager.getBorder("Spinner.arrowButtonBorder");
    if (buttonBorder instanceof UIResource) {
        // Wrap the border to avoid having the UIResource be replaced by
        // the ButtonUI. This is the opposite of using BorderUIResource.
        b.setBorder(new CompoundBorder(buttonBorder, null));
    } else {
        b.setBorder(buttonBorder);
    }
    b.setInheritsPopupMenu(true);
    return b;
}

Example 47 with Border

use of javax.swing.border.Border in project intellij-community by JetBrains.

the class LeftHandScrollbarLayout method layoutContainer.

/**
   * Lays out the scrollpane. The positioning of components depends on
   * the following constraints:
   * <ul>
   * <li> The row header, if present and visible, gets its preferred
   * width and the viewport's height.
   * <p/>
   * <li> The column header, if present and visible, gets its preferred
   * height and the viewport's width.
   * <p/>
   * <li> If a vertical scrollbar is needed, i.e. if the viewport's extent
   * height is smaller than its view height or if the <code>displayPolicy</code>
   * is ALWAYS, it's treated like the row header with respect to its
   * dimensions and is made visible.
   * <p/>
   * <li> If a horizontal scrollbar is needed, it is treated like the
   * column header (see the paragraph above regarding the vertical scrollbar).
   * <p/>
   * <li> If the scrollpane has a non-<code>null</code>
   * <code>viewportBorder</code>, then space is allocated for that.
   * <p/>
   * <li> The viewport gets the space available after accounting for
   * the previous constraints.
   * <p/>
   * <li> The corner components, if provided, are aligned with the
   * ends of the scrollbars and headers. If there is a vertical
   * scrollbar, the right corners appear; if there is a horizontal
   * scrollbar, the lower corners appear; a row header gets left
   * corners, and a column header gets upper corners.
   * </ul>
   * 
   * @param parent the <code>Container</code> to lay out
   */
@Override
public void layoutContainer(Container parent) {
    /* Sync the (now obsolete) policy fields with the
     * JScrollPane.
     */
    JScrollPane scrollPane = (JScrollPane) parent;
    vsbPolicy = scrollPane.getVerticalScrollBarPolicy();
    hsbPolicy = scrollPane.getHorizontalScrollBarPolicy();
    Rectangle availR = scrollPane.getBounds();
    availR.x = availR.y = 0;
    Insets insets = parent.getInsets();
    availR.x = insets.left;
    availR.y = insets.top;
    availR.width -= insets.left + insets.right;
    availR.height -= insets.top + insets.bottom;
    /* Get the scrollPane's orientation.
     */
    boolean leftToRight = false;
    /* If there's a visible column header remove the space it
     * needs from the top of availR.  The column header is treated
     * as if it were fixed height, arbitrary width.
     */
    Rectangle colHeadR = new Rectangle(0, availR.y, 0, 0);
    if ((colHead != null) && (colHead.isVisible())) {
        int colHeadHeight = Math.min(availR.height, colHead.getPreferredSize().height);
        colHeadR.height = colHeadHeight;
        availR.y += colHeadHeight;
        availR.height -= colHeadHeight;
    }
    /* If there's a visible row header remove the space it needs
     * from the left or right of availR.  The row header is treated
     * as if it were fixed width, arbitrary height.
     */
    Rectangle rowHeadR = new Rectangle(0, 0, 0, 0);
    if ((rowHead != null) && (rowHead.isVisible())) {
        int rowHeadWidth = Math.min(availR.width, rowHead.getPreferredSize().width);
        rowHeadR.width = rowHeadWidth;
        availR.width -= rowHeadWidth;
        if (leftToRight) {
            rowHeadR.x = availR.x;
            availR.x += rowHeadWidth;
        } else {
            rowHeadR.x = availR.x + availR.width;
        }
    }
    /* If there's a JScrollPane.viewportBorder, remove the
     * space it occupies for availR.
     */
    Border viewportBorder = scrollPane.getViewportBorder();
    Insets vpbInsets;
    if (viewportBorder != null) {
        vpbInsets = viewportBorder.getBorderInsets(parent);
        availR.x += vpbInsets.left;
        availR.y += vpbInsets.top;
        availR.width -= vpbInsets.left + vpbInsets.right;
        availR.height -= vpbInsets.top + vpbInsets.bottom;
    } else {
        vpbInsets = new Insets(0, 0, 0, 0);
    }
    /* At this point availR is the space available for the viewport
     * and scrollbars. rowHeadR is correct except for its height and y
     * and colHeadR is correct except for its width and x.  Once we're
     * through computing the dimensions  of these three parts we can
     * go back and set the dimensions of rowHeadR.height, rowHeadR.y,
     * colHeadR.width, colHeadR.x and the bounds for the corners.
     *
     * We'll decide about putting up scrollbars by comparing the
     * viewport views preferred size with the viewports extent
     * size (generally just its size).  Using the preferredSize is
     * reasonable because layout proceeds top down - so we expect
     * the viewport to be laid out next.  And we assume that the
     * viewports layout manager will give the view it's preferred
     * size.  One exception to this is when the view implements
     * Scrollable and Scrollable.getViewTracksViewport{Width,Height}
     * methods return true.  If the view is tracking the viewports
     * width we don't bother with a horizontal scrollbar, similarly
     * if view.getViewTracksViewport(Height) is true we don't bother
     * with a vertical scrollbar.
     */
    Component view = (viewport != null) ? viewport.getView() : null;
    Dimension viewPrefSize = (view != null) ? view.getPreferredSize() : JBUI.emptySize();
    Dimension extentSize = (viewport != null) ? viewport.toViewCoordinates(availR.getSize()) : JBUI.emptySize();
    boolean viewTracksViewportWidth = false;
    boolean viewTracksViewportHeight = false;
    boolean isEmpty = (availR.width < 0 || availR.height < 0);
    Scrollable sv;
    // case anyway.
    if (!isEmpty && view instanceof Scrollable) {
        sv = (Scrollable) view;
        viewTracksViewportWidth = sv.getScrollableTracksViewportWidth();
        viewTracksViewportHeight = sv.getScrollableTracksViewportHeight();
    } else {
        sv = null;
    }
    /* If there's a vertical scrollbar and we need one, allocate
     * space for it (we'll make it visible later). A vertical
     * scrollbar is considered to be fixed width, arbitrary height.
     */
    Rectangle vsbR = new Rectangle(0, availR.y - vpbInsets.top, 0, 0);
    boolean vsbNeeded;
    if (isEmpty) {
        vsbNeeded = false;
    } else if (vsbPolicy == VERTICAL_SCROLLBAR_ALWAYS) {
        vsbNeeded = true;
    } else if (vsbPolicy == VERTICAL_SCROLLBAR_NEVER) {
        vsbNeeded = false;
    } else {
        // vsbPolicy == VERTICAL_SCROLLBAR_AS_NEEDED
        vsbNeeded = !viewTracksViewportHeight && (viewPrefSize.height > extentSize.height);
    }
    if ((vsb != null) && vsbNeeded) {
        adjustForVSB(true, availR, vsbR, vpbInsets, leftToRight);
        extentSize = viewport.toViewCoordinates(availR.getSize());
    }
    /* If there's a horizontal scrollbar and we need one, allocate
     * space for it (we'll make it visible later). A horizontal
     * scrollbar is considered to be fixed height, arbitrary width.
     */
    Rectangle hsbR = new Rectangle(availR.x - vpbInsets.left, 0, 0, 0);
    boolean hsbNeeded;
    if (isEmpty) {
        hsbNeeded = false;
    } else if (hsbPolicy == HORIZONTAL_SCROLLBAR_ALWAYS) {
        hsbNeeded = true;
    } else if (hsbPolicy == HORIZONTAL_SCROLLBAR_NEVER) {
        hsbNeeded = false;
    } else {
        // hsbPolicy == HORIZONTAL_SCROLLBAR_AS_NEEDED
        hsbNeeded = !viewTracksViewportWidth && (viewPrefSize.width > extentSize.width);
    }
    if ((hsb != null) && hsbNeeded) {
        adjustForHSB(true, availR, hsbR, vpbInsets);
        /* If we added the horizontal scrollbar then we've implicitly
       * reduced  the vertical space available to the viewport.
       * As a consequence we may have to add the vertical scrollbar,
       * if that hasn't been done so already.  Of course we
       * don't bother with any of this if the vsbPolicy is NEVER.
       */
        if ((vsb != null) && !vsbNeeded && (vsbPolicy != VERTICAL_SCROLLBAR_NEVER)) {
            extentSize = viewport.toViewCoordinates(availR.getSize());
            vsbNeeded = viewPrefSize.height > extentSize.height;
            if (vsbNeeded) {
                adjustForVSB(true, availR, vsbR, vpbInsets, leftToRight);
            }
        }
    }
    if (viewport != null) {
        viewport.setBounds(availR);
        if (sv != null) {
            extentSize = viewport.toViewCoordinates(availR.getSize());
            boolean oldHSBNeeded = hsbNeeded;
            boolean oldVSBNeeded = vsbNeeded;
            viewTracksViewportWidth = sv.getScrollableTracksViewportWidth();
            viewTracksViewportHeight = sv.getScrollableTracksViewportHeight();
            if (vsb != null && vsbPolicy == VERTICAL_SCROLLBAR_AS_NEEDED) {
                boolean newVSBNeeded = !viewTracksViewportHeight && (viewPrefSize.height > extentSize.height);
                if (newVSBNeeded != vsbNeeded) {
                    vsbNeeded = newVSBNeeded;
                    adjustForVSB(vsbNeeded, availR, vsbR, vpbInsets, leftToRight);
                    extentSize = viewport.toViewCoordinates(availR.getSize());
                }
            }
            if (hsb != null && hsbPolicy == HORIZONTAL_SCROLLBAR_AS_NEEDED) {
                boolean newHSBbNeeded = !viewTracksViewportWidth && (viewPrefSize.width > extentSize.width);
                if (newHSBbNeeded != hsbNeeded) {
                    hsbNeeded = newHSBbNeeded;
                    adjustForHSB(hsbNeeded, availR, hsbR, vpbInsets);
                    if ((vsb != null) && !vsbNeeded && (vsbPolicy != VERTICAL_SCROLLBAR_NEVER)) {
                        extentSize = viewport.toViewCoordinates(availR.getSize());
                        vsbNeeded = viewPrefSize.height > extentSize.height;
                        if (vsbNeeded) {
                            adjustForVSB(true, availR, vsbR, vpbInsets, leftToRight);
                        }
                    }
                }
            }
            if (oldHSBNeeded != hsbNeeded || oldVSBNeeded != vsbNeeded) {
                viewport.setBounds(availR);
            // You could argue that we should recheck the
            // Scrollable methods again until they stop changing,
            // but they might never stop changing, so we stop here
            // and don't do any additional checks.
            }
        }
    }
    /* We now have the final size of the viewport: availR.
     * Now fixup the header and scrollbar widths/heights.
     */
    vsbR.height = availR.height + vpbInsets.top + vpbInsets.bottom;
    hsbR.width = availR.width + vpbInsets.left + vpbInsets.right;
    rowHeadR.height = availR.height + vpbInsets.top + vpbInsets.bottom;
    rowHeadR.y = availR.y - vpbInsets.top;
    colHeadR.width = availR.width + vpbInsets.left + vpbInsets.right;
    colHeadR.x = availR.x - vpbInsets.left;
    if (rowHead != null) {
        rowHead.setBounds(rowHeadR);
    }
    if (colHead != null) {
        colHead.setBounds(colHeadR);
    }
    if (vsb != null) {
        if (vsbNeeded) {
            vsb.setVisible(true);
            vsb.setBounds(vsbR);
        } else {
            vsb.setVisible(false);
        }
    }
    if (hsb != null) {
        if (hsbNeeded) {
            hsb.setVisible(true);
            hsb.setBounds(hsbR);
        } else {
            hsb.setVisible(false);
        }
    }
    if (lowerLeft != null) {
        lowerLeft.setBounds(leftToRight ? rowHeadR.x : vsbR.x, hsbR.y, leftToRight ? rowHeadR.width : vsbR.width, hsbR.height);
    }
    if (lowerRight != null) {
        lowerRight.setBounds(leftToRight ? vsbR.x : rowHeadR.x, hsbR.y, leftToRight ? vsbR.width : rowHeadR.width, hsbR.height);
    }
    if (upperLeft != null) {
        upperLeft.setBounds(leftToRight ? rowHeadR.x : vsbR.x, colHeadR.y, leftToRight ? rowHeadR.width : vsbR.width, colHeadR.height);
    }
    if (upperRight != null) {
        upperRight.setBounds(leftToRight ? vsbR.x : rowHeadR.x, colHeadR.y, leftToRight ? vsbR.width : rowHeadR.width, colHeadR.height);
    }
}

Example 48 with Border

use of javax.swing.border.Border in project intellij-community by JetBrains.

the class LeftHandScrollbarLayout method preferredLayoutSize.

/**
   * The preferred size of a <code>ScrollPane</code> is the size of the insets,
   * plus the preferred size of the viewport, plus the preferred size of
   * the visible headers, plus the preferred size of the scrollbars
   * that will appear given the current view and the current
   * scrollbar displayPolicies.
   * <p>Note that the rowHeader is calculated as part of the preferred width
   * and the colHeader is calculated as part of the preferred size.
   * 
   * @param parent the <code>Container</code> that will be laid out
   * @return a <code>Dimension</code> object specifying the preferred size of the
   *         viewport and any scrollbars
   * @see ViewportLayout
   * @see LayoutManager
   */
@Override
public Dimension preferredLayoutSize(Container parent) {
    /* Sync the (now obsolete) policy fields with the
     * JScrollPane.
     */
    JScrollPane scrollPane = (JScrollPane) parent;
    vsbPolicy = scrollPane.getVerticalScrollBarPolicy();
    hsbPolicy = scrollPane.getHorizontalScrollBarPolicy();
    Insets insets = parent.getInsets();
    int prefWidth = insets.left + insets.right;
    int prefHeight = insets.top + insets.bottom;
    /* Note that viewport.getViewSize() is equivalent to
     * viewport.getView().getPreferredSize() modulo a null
     * view or a view whose size was explicitly set.
     */
    Dimension extentSize = null;
    Dimension viewSize = null;
    Component view = null;
    if (viewport != null) {
        extentSize = viewport.getPreferredSize();
        viewSize = viewport.getViewSize();
        view = viewport.getView();
    }
    if (extentSize != null) {
        prefWidth += extentSize.width;
        prefHeight += extentSize.height;
    }
    /* If there's a JScrollPane.viewportBorder, add its insets.
     */
    Border viewportBorder = scrollPane.getViewportBorder();
    if (viewportBorder != null) {
        Insets vpbInsets = viewportBorder.getBorderInsets(parent);
        prefWidth += vpbInsets.left + vpbInsets.right;
        prefHeight += vpbInsets.top + vpbInsets.bottom;
    }
    if ((rowHead != null) && rowHead.isVisible()) {
        prefWidth += rowHead.getPreferredSize().width;
    }
    if ((colHead != null) && colHead.isVisible()) {
        prefHeight += colHead.getPreferredSize().height;
    }
    if ((vsb != null) && (vsbPolicy != VERTICAL_SCROLLBAR_NEVER)) {
        if (vsbPolicy == VERTICAL_SCROLLBAR_ALWAYS) {
            prefWidth += vsb.getPreferredSize().width;
        } else if ((viewSize != null) && (extentSize != null)) {
            boolean canScroll = true;
            if (view instanceof Scrollable) {
                canScroll = !((Scrollable) view).getScrollableTracksViewportHeight();
            }
            if (canScroll && (viewSize.height > extentSize.height)) {
                prefWidth += vsb.getPreferredSize().width;
            }
        }
    }
    if ((hsb != null) && (hsbPolicy != HORIZONTAL_SCROLLBAR_NEVER)) {
        if (hsbPolicy == HORIZONTAL_SCROLLBAR_ALWAYS) {
            prefHeight += hsb.getPreferredSize().height;
        } else if ((viewSize != null) && (extentSize != null)) {
            boolean canScroll = true;
            if (view instanceof Scrollable) {
                canScroll = !((Scrollable) view).getScrollableTracksViewportWidth();
            }
            if (canScroll && (viewSize.width > extentSize.width)) {
                prefHeight += hsb.getPreferredSize().height;
            }
        }
    }
    return new Dimension(prefWidth, prefHeight);
}

Example 49 with Border

use of javax.swing.border.Border in project intellij-community by JetBrains.

the class TextFieldAction method createCustomComponent.

@Override
public JComponent createCustomComponent(Presentation presentation) {
    // honestly borrowed from SearchTextField
    final JPanel panel = new JPanel(new BorderLayout());
    final JLabel label = new JLabel(myIcon);
    label.setOpaque(true);
    label.setBackground(myField.getBackground());
    myField.setOpaque(true);
    panel.add(myField, BorderLayout.WEST);
    panel.add(label, BorderLayout.EAST);
    myField.setToolTipText(myDescription);
    label.setToolTipText(myDescription);
    final Border originalBorder;
    if (SystemInfo.isMac) {
        originalBorder = BorderFactory.createLoweredBevelBorder();
    } else {
        originalBorder = myField.getBorder();
    }
    panel.setBorder(new CompoundBorder(IdeBorderFactory.createEmptyBorder(4, 0, 4, 0), originalBorder));
    myField.setOpaque(true);
    myField.setBorder(IdeBorderFactory.createEmptyBorder(0, 5, 0, 5));
    new ClickListener() {

        @Override
        public boolean onClick(@NotNull MouseEvent e, int clickCount) {
            actionPerformed(null);
            return true;
        }
    }.installOn(label);
    return panel;
}

Example 50 with Border

use of javax.swing.border.Border in project android by JetBrains.

the class VariantsComboBox method createPopupMenu.

@NotNull
protected JPopupMenu createPopupMenu() {
    JPopupMenu menu = new JBPopupMenu();
    Border existingBorder = menu.getBorder();
    if (existingBorder != null) {
        menu.setBorder(BorderFactory.createCompoundBorder(existingBorder, VARIANT_MENU_BORDER));
    } else {
        menu.setBorder(VARIANT_MENU_BORDER);
    }
    menu.setBackground(VARIANT_MENU_BACKGROUND_COLOR);
    int nElements = myModel.getSize();
    for (int i = 0; i < nElements; i++) {
        final Object element = myModel.getElementAt(i);
        JMenuItem item = new JBMenuItem(element.toString());
        item.setFont(ThemeEditorUtils.scaleFontForAttribute(item.getFont()));
        item.setBorder(VARIANT_ITEM_BORDER);
        if (i == 0) {
            // Pre-select the first element
            item.setArmed(true);
        }
        item.setBackground(VARIANT_MENU_BACKGROUND_COLOR);
        item.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
                Object selectedItem = myModel.getSelectedItem();
                if (selectedItem != null) {
                    fireItemSelectionChanged(new ItemEvent(VariantsComboBox.this, ItemEvent.ITEM_STATE_CHANGED, selectedItem, ItemEvent.DESELECTED));
                }
                myModel.setSelectedItem(element);
                fireModelUpdated();
                fireItemSelectionChanged(new ItemEvent(VariantsComboBox.this, ItemEvent.ITEM_STATE_CHANGED, element, ItemEvent.SELECTED));
            }
        });
        menu.add(item);
    }
    if (!myActions.isEmpty()) {
        if (nElements > 0) {
            menu.addSeparator();
        }
        for (Action action : myActions) {
            JMenuItem newMenuItem = new JBMenuItem(action);
            newMenuItem.setFont(ThemeEditorUtils.scaleFontForAttribute(newMenuItem.getFont()));
            newMenuItem.setBackground(VARIANT_MENU_BACKGROUND_COLOR);
            newMenuItem.setBorder(VARIANT_ITEM_BORDER);
            menu.add(newMenuItem);
        }
    }
    return menu;
}