jdk-sandbox: comparison jdk/src/java.desktop/unix/classes/sun/awt/X11/ListHelper.java

equal deleted inserted replaced

-:e9b05e933ddd
+:508779ce6619
 /*
-* Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2003, 2014, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * Class to paint a list of items, possibly with scrollbars
 * This class paints all items with the same font
 * For now, this class manages the list of items and painting thereof, but not
 * posting of Item or ActionEvents
 */
-public class ListHelper implements XScrollbarClient {
+final class ListHelper implements XScrollbarClient {
 private static final PlatformLogger log = PlatformLogger.getLogger("sun.awt.X11.ListHelper");
 private final int FOCUS_INSET = 1;
 private final int BORDER_WIDTH; // Width of border drawn around the list
 private Color[] colors; // Passed in for painting on notifyValue()
 // Holds the true if mouse is dragging outside of the area of the list
 // The flag is used at the moment of the dragging and releasing mouse
 // See 6243382 for more information
-boolean mouseDraggedOutVertically = false;
+private boolean mouseDraggedOutVertically = false;
 private volatile boolean vsbVisibilityChanged = false;
 /*
 * Comment
 */
-public ListHelper(XWindow peer,
+ListHelper(XWindow peer, Color[] colors, int initialSize,
-Color[] colors,
+boolean multiSelect, boolean scrollVert, boolean scrollHoriz,
-int initialSize,
+Font font, int maxVisItems, int SPACE, int MARGIN, int BORDER,
-boolean multiSelect,
+int SCROLLBAR) {
-boolean scrollVert,
-boolean scrollHoriz,
-Font font,
-int maxVisItems,
-int SPACE,
-int MARGIN,
-int BORDER,
-int SCROLLBAR) {
 this.peer = peer;
 this.colors = colors;
 this.multiSelect = multiSelect;
 items = new ArrayList<>(initialSize);
 selected = new ArrayList<>(1);
 ITEM_MARGIN = MARGIN;
 BORDER_WIDTH = BORDER;
 SCROLLBAR_WIDTH = SCROLLBAR;
 }
+@Override
 public Component getEventSource() {
 return peer.getEventSource();
 }
 /**********************************************************************/
 /* List management methods                                            */
 /**********************************************************************/
-public void add(String item) {
+void add(String item) {
 items.add(item);
 updateScrollbars();
 }
-public void add(String item, int index) {
+void add(String item, int index) {
 items.add(index, item);
 updateScrollbars();
 }
-public void remove(String item) {
+void remove(String item) {
 // FIXME: need to clean up select list, too?
 items.remove(item);
 updateScrollbars();
 // Is vsb visible now?
 }
-public void remove(int index) {
+void remove(int index) {
 // FIXME: need to clean up select list, too?
 items.remove(index);
 updateScrollbars();
 // Is vsb visible now?
 }
-public void removeAll() {
+void removeAll() {
 items.removeAll(items);
 updateScrollbars();
 }
-public void setMultiSelect(boolean ms) {
+void setMultiSelect(boolean ms) {
 multiSelect = ms;
 }
 /*
 * docs.....definitely docs
 * merely keeps internal track of which items are selected for painting
 * dealing with target Components happens elsewhere
 */
-public void select(int index) {
+void select(int index) {
 if (index > getItemCount() - 1) {
 index = (isEmpty() ? -1 : 0);
 }
 if (multiSelect) {
 assert false : "Implement ListHelper.select() for multiselect";
 makeVisible(index);
 }
 }
 /* docs */
-public void deselect(int index) {
+void deselect(int index) {
 assert(false);
 }
 /* docs */
 /* if called for multiselect, return -1 */
-public int getSelectedIndex() {
+int getSelectedIndex() {
 if (!multiSelect) {
 Integer val = selected.get(0);
 return val.intValue();
 }
 return -1;
 /*
 * A getter method for XChoicePeer.
 * Returns vsbVisiblityChanged value and sets it to false.
 */
-public boolean checkVsbVisibilityChangedAndReset(){
+boolean checkVsbVisibilityChangedAndReset(){
 boolean returnVal = vsbVisibilityChanged;
 vsbVisibilityChanged = false;
 return returnVal;
 }
-public boolean isEmpty() {
+boolean isEmpty() {
 return items.isEmpty();
 }
-public int getItemCount() {
+int getItemCount() {
 return items.size();
 }
-public String getItem(int index) {
+String getItem(int index) {
 return items.get(index);
 }
 /**********************************************************************/
 /* GUI-related methods                                                */
 /**********************************************************************/
-public void setFocusedIndex(int index) {
+void setFocusedIndex(int index) {
 focusedIndex = index;
 }
-public boolean isFocusedIndex(int index) {
+private boolean isFocusedIndex(int index) {
 return index == focusedIndex;
 }
-public void setFont(Font newFont) {
+void setFont(Font newFont) {
 if (newFont != font) {
 font = newFont;
 fm = Toolkit.getDefaultToolkit().getFontMetrics(font);
 // Also cache stuff like fontHeight?
 }
 }
 /*
 * Returns width of the text of the longest item
 */
-public int getMaxItemWidth() {
+int getMaxItemWidth() {
 int m = 0;
 int end = getItemCount();
 for(int i = 0 ; i < end ; i++) {
 int l = fm.stringWidth(getItem(i));
 m = Math.max(m, l);
 */
 int getItemHeight() {
 return fm.getHeight() + (2*TEXT_SPACE);
 }
-public int y2index(int y) {
+int y2index(int y) {
 if (log.isLoggable(PlatformLogger.Level.FINE)) {
 log.fine("y=" + y +", firstIdx=" + firstDisplayedIndex() +", itemHeight=" + getItemHeight()
 + ",item_margin=" + ITEM_MARGIN);
 }
 // See 6243382 for more information
 /* write these
 int index2y(int);
 public int numItemsDisplayed() {}
 */
-public int firstDisplayedIndex() {
+int firstDisplayedIndex() {
 if (vsbVis) {
 return vsb.getValue();
 }
 return 0;
 }
-public int lastDisplayedIndex() {
+int lastDisplayedIndex() {
 // FIXME: need to account for horiz scroll bar
 if (hsbVis) {
 assert false : "Implement for horiz scroll bar";
 }
 }
 /*
 * If the given index is not visible in the List, scroll so that it is.
 */
-public void makeVisible(int index) {
+private void makeVisible(int index) {
 if (vsbVis) {
 if (index < firstDisplayedIndex()) {
 vsb.setValue(index);
 }
 else if (index > lastDisplayedIndex()) {
 }
 }
 }
 // FIXME: multi-select needs separate focused index
-public void up() {
+void up() {
 int curIdx = getSelectedIndex();
 int numItems = getItemCount();
 int newIdx;
 assert curIdx >= 0;
 }
 // focus(newIdx);
 select(newIdx);
 }
-public void down() {
+void down() {
 int newIdx = (getSelectedIndex() + 1) % getItemCount();
 select(newIdx);
 }
-public void pageUp() {
+void pageUp() {
 // FIXME: for multi-select, move the focused item, not the selected item
 if (vsbVis && firstDisplayedIndex() > 0) {
 if (multiSelect) {
 assert false : "Implement pageUp() for multiSelect";
 }
 vsb.setValue(newIdx);
 select(firstDisplayedIndex() + selectionOffset);
 }
 }
 }
-public void pageDown() {
+void pageDown() {
 if (vsbVis && lastDisplayedIndex() < getItemCount() - 1) {
 if (multiSelect) {
 assert false : "Implement pageDown() for multiSelect";
 }
 else {
 vsb.setValue(newIdx);
 select(firstDisplayedIndex() + selectionOffset);
 }
 }
 }
-public void home() {}
+void home() {}
-public void end() {}
+void end() {}
-public boolean isVSBVisible() { return vsbVis; }
+boolean isVSBVisible() { return vsbVis; }
-public boolean isHSBVisible() { return hsbVis; }
+boolean isHSBVisible() { return hsbVis; }
-public XVerticalScrollbar getVSB() { return vsb; }
+XVerticalScrollbar getVSB() { return vsb; }
-public XHorizontalScrollbar getHSB() { return hsb; }
+XHorizontalScrollbar getHSB() { return hsb; }
-public boolean isInVertSB(Rectangle bounds, int x, int y) {
+boolean isInVertSB(Rectangle bounds, int x, int y) {
 if (vsbVis) {
 assert vsb != null : "Vert scrollbar is visible, yet is null?";
 int sbHeight = hsbVis ? bounds.height - SCROLLBAR_WIDTH : bounds.height;
 return (x <= bounds.width) &&
 (x >= bounds.width - SCROLLBAR_WIDTH) &&
 (y <= sbHeight);
 }
 return false;
 }
-public boolean isInHorizSB(Rectangle bounds, int x, int y) {
+boolean isInHorizSB(Rectangle bounds, int x, int y) {
 if (hsbVis) {
 assert hsb != null : "Horiz scrollbar is visible, yet is null?";
 int sbWidth = vsbVis ? bounds.width - SCROLLBAR_WIDTH : bounds.width;
 return (x <= sbWidth) &&
 (y <= bounds.height);
 }
 return false;
 }
-public void handleVSBEvent(MouseEvent e, Rectangle bounds, int x, int y) {
+void handleVSBEvent(MouseEvent e, Rectangle bounds, int x, int y) {
 int sbHeight = hsbVis ? bounds.height - SCROLLBAR_WIDTH : bounds.height;
 vsb.handleMouseEvent(e.getID(),
 e.getModifiers(),
 x - (bounds.width - SCROLLBAR_WIDTH),
 /*
 * Called when items are added/removed.
 * Update whether the scrollbar is visible or not, scrollbar values
 */
-void updateScrollbars() {
+private void updateScrollbars() {
 boolean oldVsbVis = vsbVis;
 vsbVis = vsb != null && items.size() > maxVisItems;
 if (vsbVis) {
 vsb.setValues(vsb.getValue(), getNumItemsDisplayed(),
 vsb.getMinimum(), items.size());
 // but draw3DRect doesn't clear the area inside. Instead it just paints lines as borders.
 vsbVisibilityChanged = (vsbVis != oldVsbVis);
 // FIXME: check if added item makes a hsb necessary (if supported, that of course)
 }
-public int getNumItemsDisplayed() {
+private int getNumItemsDisplayed() {
 return items.size() > maxVisItems ? maxVisItems : items.size();
 }
+@Override
 public void repaintScrollbarRequest(XScrollbar sb) {
 Graphics g = peer.getGraphics();
 Rectangle bounds = peer.getBounds();
 if ((sb == vsb) && vsbVis) {
 paintVSB(g, XComponentPeer.getSystemColors(), bounds);
 paintHSB(g, XComponentPeer.getSystemColors(), bounds);
 }
 g.dispose();
 }
+@Override
 public void notifyValue(XScrollbar obj, int type, int v, boolean isAdjusting) {
 if (obj == vsb) {
 int oldScrollValue = vsb.getValue();
 vsb.setValue(v);
 boolean needRepaint = (oldScrollValue != vsb.getValue());
 hsb.setValue(v);
 // FIXME: how are we going to paint!?
 }
 }
-public void updateColors(Color[] newColors) {
+void updateColors(Color[] newColors) {
 colors = newColors;
 }
 /*
 public void paintItems(Graphics g,
 int first,
 int last,
 XVerticalScrollbar vsb,
 XHorizontalScrollbar hsb) {
 */
-public void paintItems(Graphics g,
+void paintItems(Graphics g,
 Color[] colors,
 Rectangle bounds) {
 // paint border
 // paint items
 // paint scrollbars
 // paint focus?
 }
-public void paintAllItems(Graphics g,
+void paintAllItems(Graphics g,
 Color[] colors,
 Rectangle bounds) {
 paintItems(g, colors, bounds,
 firstDisplayedIndex(), lastDisplayedIndex());
 }
-public void paintItems(Graphics g,
+private void paintItems(Graphics g, Color[] colors, Rectangle bounds,
-Color[] colors,
+int first, int last) {
-Rectangle bounds,
-int first,
-int last) {
 peer.flush();
 int x = BORDER_WIDTH + ITEM_MARGIN;
 int width = bounds.width - 2*ITEM_MARGIN - 2*BORDER_WIDTH - (vsbVis ? SCROLLBAR_WIDTH : 0);
 int height = getItemHeight();
 int y = BORDER_WIDTH + ITEM_MARGIN;
 }
 /*
 * comment about what is painted (i.e. the focus rect
 */
-public void paintItem(Graphics g,
+private void paintItem(Graphics g, Color[] colors, String string, int x,
-Color[] colors,
+int y, int width, int height, boolean selected,
-String string,
+boolean focused) {
-int x, int y, int width, int height,
-boolean selected,
-boolean focused) {
 //System.out.println("LP.pI(): x="+x+" y="+y+" w="+width+" h="+height);
 //g.setColor(colors[BACKGROUND_COLOR]);
 // FIXME: items shouldn't draw into the scrollbar
 g.drawString(string, x + TEXT_SPACE, y + (height + fm.getMaxAscent() - fm.getMaxDescent())/2);
 //g.clipRect(clip.x, clip.y, clip.width, clip.height);
 }
-boolean isItemSelected(int index) {
+private boolean isItemSelected(int index) {
 Iterator<Integer> itr = selected.iterator();
 while (itr.hasNext()) {
 Integer val = itr.next();
 if (val.intValue() == index) {
 return true;
 }
 }
 return false;
 }
-public void paintVSB(Graphics g, Color colors[], Rectangle bounds) {
+private void paintVSB(Graphics g, Color colors[], Rectangle bounds) {
 int height = bounds.height - 2*BORDER_WIDTH - (hsbVis ? (SCROLLBAR_WIDTH-2) : 0);
 Graphics ng = g.create();
 g.setColor(colors[XComponentPeer.BACKGROUND_COLOR]);
 try {
 } finally {
 ng.dispose();
 }
 }
-public void paintHSB(Graphics g, Color colors[], Rectangle bounds) {
+private void paintHSB(Graphics g, Color colors[], Rectangle bounds) {
 }
 /*
 * Helper method for Components with integrated scrollbars.

changeset 26037	508779ce6619
parent 26007	dba8f49653ce
parent 25859	3317bb8137f4
child 28059	e576535359cc
child 28231	b608ffcaed74