< prev index next >

src/java.desktop/share/classes/javax/swing/plaf/basic/BasicListUI.java

Print this page




2117                     // this is done to restore the anchor and lead
2118                     SwingUtilities2.setLeadAnchorWithoutSelection(lsm, anchor, lead);
2119 
2120                     list.setValueIsAdjusting(false);
2121                 }
2122             }
2123         }
2124 
2125         private int getNextPageIndex(JList<?> list, int direction) {
2126             if (list.getModel().getSize() == 0) {
2127                 return -1;
2128             }
2129 
2130             int index = -1;
2131             Rectangle visRect = list.getVisibleRect();
2132             ListSelectionModel lsm = list.getSelectionModel();
2133             int lead = adjustIndex(lsm.getLeadSelectionIndex(), list);
2134             Rectangle leadRect =
2135                 (lead==-1) ? new Rectangle() : list.getCellBounds(lead, lead);
2136 

2137             if (list.getLayoutOrientation() == JList.VERTICAL_WRAP &&
2138                 list.getVisibleRowCount() <= 0) {
2139                 if (!list.getComponentOrientation().isLeftToRight()) {
2140                     direction = -direction;
2141                 }
2142                 // apply for horizontal scrolling: the step for next
2143                 // page index is number of visible columns
2144                 if (direction < 0) {
2145                     // left
2146                     visRect.x = leadRect.x + leadRect.width - visRect.width;
2147                     Point p = new Point(visRect.x - 1, leadRect.y);
2148                     index = list.locationToIndex(p);
2149                     Rectangle cellBounds = list.getCellBounds(index, index);
2150                     if (visRect.intersects(cellBounds)) {
2151                         p.x = cellBounds.x - 1;
2152                         index = list.locationToIndex(p);
2153                         cellBounds = list.getCellBounds(index, index);
2154                     }
2155                     // this is necessary for right-to-left orientation only
2156                     if (cellBounds.y != leadRect.y) {
2157                         p.x = cellBounds.x + cellBounds.width;
2158                         index = list.locationToIndex(p);
2159                     }
2160                 }
2161                 else {
2162                     // right
2163                     visRect.x = leadRect.x;
2164                     Point p = new Point(visRect.x + visRect.width, leadRect.y);
2165                     index = list.locationToIndex(p);
2166                     Rectangle cellBounds = list.getCellBounds(index, index);
2167                     if (visRect.intersects(cellBounds)) {
2168                         p.x = cellBounds.x + cellBounds.width;
2169                         index = list.locationToIndex(p);
2170                         cellBounds = list.getCellBounds(index, index);
2171                     }
2172                     if (cellBounds.y != leadRect.y) {
2173                         p.x = cellBounds.x - 1;
2174                         index = list.locationToIndex(p);
2175                     }
2176                 }
2177             }
2178             else {
2179                 if (direction < 0) {
2180                     // up
2181                     // go to the first visible cell
2182                     Point p = new Point(leadRect.x, visRect.y);
2183                     index = list.locationToIndex(p);
2184                     if (lead <= index) {
2185                         // if lead is the first visible cell (or above it)
2186                         // adjust the visible rect up
2187                         visRect.y = leadRect.y + leadRect.height - visRect.height;
2188                         p.y = visRect.y;
2189                         index = list.locationToIndex(p);
2190                         Rectangle cellBounds = list.getCellBounds(index, index);
2191                         // go one cell down if first visible cell doesn't fit
2192                         // into adjasted visible rectangle
2193                         if (cellBounds.y < visRect.y) {
2194                             p.y = cellBounds.y + cellBounds.height;
2195                             index = list.locationToIndex(p);
2196                             cellBounds = list.getCellBounds(index, index);
2197                         }
2198                         // if index isn't less then lead
2199                         // try to go to cell previous to lead
2200                         if (cellBounds.y >= leadRect.y) {
2201                             p.y = leadRect.y - 1;
2202                             index = list.locationToIndex(p);
2203                         }
2204                     }
2205                 }
2206                 else {
2207                     // down
2208                     // go to the last completely visible cell
2209                     Point p = new Point(leadRect.x,
2210                                         visRect.y + visRect.height - 1);
2211                     index = list.locationToIndex(p);
2212                     Rectangle cellBounds = list.getCellBounds(index, index);
2213                     // go up one cell if last visible cell doesn't fit
2214                     // into visible rectangle
2215                     if (cellBounds.y + cellBounds.height >
2216                         visRect.y + visRect.height) {


2217                         p.y = cellBounds.y - 1;
2218                         index = list.locationToIndex(p);
2219                         cellBounds = list.getCellBounds(index, index);
2220                         index = Math.max(index, lead);
2221                     }
2222 
2223                     if (lead >= index) {
2224                         // if lead is the last completely visible index
2225                         // (or below it) adjust the visible rect down
2226                         visRect.y = leadRect.y;
2227                         p.y = visRect.y + visRect.height - 1;
2228                         index = list.locationToIndex(p);
2229                         cellBounds = list.getCellBounds(index, index);
2230                         // go one cell up if last visible cell doesn't fit
2231                         // into adjasted visible rectangle
2232                         if (cellBounds.y + cellBounds.height >
2233                             visRect.y + visRect.height) {


2234                             p.y = cellBounds.y - 1;
2235                             index = list.locationToIndex(p);
2236                             cellBounds = list.getCellBounds(index, index);
2237                         }
2238                         // if index isn't greater then lead
2239                         // try to go to cell next after lead
2240                         if (cellBounds.y <= leadRect.y) {
2241                             p.y = leadRect.y + leadRect.height;
2242                             index = list.locationToIndex(p);
2243                         }
2244                     }
2245                 }
2246             }

2247             return index;
2248         }
2249 
2250         private void changeSelection(JList<?> list, int type,
2251                                      int index, int direction) {
2252             if (index >= 0 && index < list.getModel().getSize()) {
2253                 ListSelectionModel lsm = list.getSelectionModel();
2254 
2255                 // CHANGE_LEAD is only valid with multiple interval selection
2256                 if (type == CHANGE_LEAD &&
2257                         list.getSelectionMode()
2258                             != ListSelectionModel.MULTIPLE_INTERVAL_SELECTION) {
2259 
2260                     type = CHANGE_SELECTION;
2261                 }
2262 
2263                 // IMPORTANT - This needs to happen before the index is changed.
2264                 // This is because JFileChooser, which uses JList, also scrolls
2265                 // the selected item into view. If that happens first, then
2266                 // this method becomes a no-op.


2293         private void adjustScrollPositionIfNecessary(JList<?> list, int index,
2294                                                      int direction) {
2295             if (direction == 0) {
2296                 return;
2297             }
2298             Rectangle cellBounds = list.getCellBounds(index, index);
2299             Rectangle visRect = list.getVisibleRect();
2300             if (cellBounds != null && !visRect.contains(cellBounds)) {
2301                 if (list.getLayoutOrientation() == JList.VERTICAL_WRAP &&
2302                     list.getVisibleRowCount() <= 0) {
2303                     // horizontal
2304                     if (list.getComponentOrientation().isLeftToRight()) {
2305                         if (direction > 0) {
2306                             // right for left-to-right
2307                             int x =Math.max(0,
2308                                 cellBounds.x + cellBounds.width - visRect.width);
2309                             int startIndex =
2310                                 list.locationToIndex(new Point(x, cellBounds.y));
2311                             Rectangle startRect = list.getCellBounds(startIndex,
2312                                                                      startIndex);
2313                             if (startRect.x < x && startRect.x < cellBounds.x) {

2314                                 startRect.x += startRect.width;
2315                                 startIndex =
2316                                     list.locationToIndex(startRect.getLocation());
2317                                 startRect = list.getCellBounds(startIndex,
2318                                                                startIndex);
2319                             }
2320                             cellBounds = startRect;
2321                         }

2322                         cellBounds.width = visRect.width;
2323                     }

2324                     else {
2325                         if (direction > 0) {
2326                             // left for right-to-left
2327                             int x = cellBounds.x + visRect.width;
2328                             int rightIndex =
2329                                 list.locationToIndex(new Point(x, cellBounds.y));
2330                             Rectangle rightRect = list.getCellBounds(rightIndex,
2331                                                                      rightIndex);

2332                             if (rightRect.x + rightRect.width > x &&
2333                                 rightRect.x > cellBounds.x) {
2334                                 rightRect.width = 0;
2335                             }
2336                             cellBounds.x = Math.max(0,
2337                                 rightRect.x + rightRect.width - visRect.width);
2338                             cellBounds.width = visRect.width;
2339                         }

2340                         else {
2341                             cellBounds.x += Math.max(0,
2342                                 cellBounds.width - visRect.width);
2343                             // adjust width to fit into visible rectangle
2344                             cellBounds.width = Math.min(cellBounds.width,
2345                                                         visRect.width);
2346                         }
2347                     }
2348                 }
2349                 else {
2350                     // vertical
2351                     if (direction > 0 &&
2352                             (cellBounds.y < visRect.y ||
2353                                     cellBounds.y + cellBounds.height
2354                                             > visRect.y + visRect.height)) {
2355                         //down
2356                         int y = Math.max(0,
2357                             cellBounds.y + cellBounds.height - visRect.height);
2358                         int startIndex =
2359                             list.locationToIndex(new Point(cellBounds.x, y));
2360                         Rectangle startRect = list.getCellBounds(startIndex,
2361                                                                  startIndex);
2362                         if (startRect.y < y && startRect.y < cellBounds.y) {

2363                             startRect.y += startRect.height;
2364                             startIndex =
2365                                 list.locationToIndex(startRect.getLocation());
2366                             startRect =
2367                                 list.getCellBounds(startIndex, startIndex);
2368                         }
2369                         cellBounds = startRect;

2370                         cellBounds.height = visRect.height;

2371                     }
2372                     else {
2373                         // adjust height to fit into visible rectangle
2374                         cellBounds.height = Math.min(cellBounds.height, visRect.height);
2375                     }
2376                 }
2377                 list.scrollRectToVisible(cellBounds);
2378             }
2379         }
2380 
2381         private int getNextColumnIndex(JList<?> list, BasicListUI ui,
2382                                        int amount) {
2383             if (list.getLayoutOrientation() != JList.VERTICAL) {
2384                 int index = adjustIndex(list.getLeadSelectionIndex(), list);
2385                 int size = list.getModel().getSize();
2386 
2387                 if (index == -1) {
2388                     return 0;
2389                 } else if (size == 1) {
2390                     // there's only one item so we should select it




2117                     // this is done to restore the anchor and lead
2118                     SwingUtilities2.setLeadAnchorWithoutSelection(lsm, anchor, lead);
2119 
2120                     list.setValueIsAdjusting(false);
2121                 }
2122             }
2123         }
2124 
2125         private int getNextPageIndex(JList<?> list, int direction) {
2126             if (list.getModel().getSize() == 0) {
2127                 return -1;
2128             }
2129 
2130             int index = -1;
2131             Rectangle visRect = list.getVisibleRect();
2132             ListSelectionModel lsm = list.getSelectionModel();
2133             int lead = adjustIndex(lsm.getLeadSelectionIndex(), list);
2134             Rectangle leadRect =
2135                 (lead==-1) ? new Rectangle() : list.getCellBounds(lead, lead);
2136 
2137             if (leadRect != null) {
2138                 if (list.getLayoutOrientation() == JList.VERTICAL_WRAP &&
2139                         list.getVisibleRowCount() <= 0) {
2140                     if (!list.getComponentOrientation().isLeftToRight()) {
2141                         direction = -direction;
2142                     }
2143                     // apply for horizontal scrolling: the step for next
2144                     // page index is number of visible columns
2145                     if (direction < 0) {
2146                         // left
2147                         visRect.x = leadRect.x + leadRect.width - visRect.width;
2148                         Point p = new Point(visRect.x - 1, leadRect.y);
2149                         index = list.locationToIndex(p);
2150                         Rectangle cellBounds = list.getCellBounds(index, index);
2151                         if (cellBounds != null && visRect.intersects(cellBounds)) {
2152                             p.x = cellBounds.x - 1;
2153                             index = list.locationToIndex(p);
2154                             cellBounds = list.getCellBounds(index, index);
2155                         }
2156                         // this is necessary for right-to-left orientation only
2157                         if (cellBounds != null && cellBounds.y != leadRect.y) {
2158                             p.x = cellBounds.x + cellBounds.width;
2159                             index = list.locationToIndex(p);
2160                         }
2161                     }
2162                     else {
2163                         // right
2164                         visRect.x = leadRect.x;
2165                         Point p = new Point(visRect.x + visRect.width, leadRect.y);
2166                         index = list.locationToIndex(p);
2167                         Rectangle cellBounds = list.getCellBounds(index, index);
2168                         if (cellBounds != null && visRect.intersects(cellBounds)) {
2169                             p.x = cellBounds.x + cellBounds.width;
2170                             index = list.locationToIndex(p);
2171                             cellBounds = list.getCellBounds(index, index);
2172                         }
2173                         if (cellBounds != null && cellBounds.y != leadRect.y) {
2174                             p.x = cellBounds.x - 1;
2175                             index = list.locationToIndex(p);
2176                         }
2177                     }
2178                 }
2179                 else {
2180                     if (direction < 0) {
2181                         // up
2182                         // go to the first visible cell
2183                         Point p = new Point(leadRect.x, visRect.y);
2184                         index = list.locationToIndex(p);
2185                         if (lead <= index) {
2186                             // if lead is the first visible cell (or above it)
2187                             // adjust the visible rect up
2188                             visRect.y = leadRect.y + leadRect.height - visRect.height;
2189                             p.y = visRect.y;
2190                             index = list.locationToIndex(p);
2191                             Rectangle cellBounds = list.getCellBounds(index, index);
2192                             // go one cell down if first visible cell doesn't fit
2193                             // into adjasted visible rectangle
2194                             if (cellBounds != null && cellBounds.y < visRect.y) {
2195                                 p.y = cellBounds.y + cellBounds.height;
2196                                 index = list.locationToIndex(p);
2197                                 cellBounds = list.getCellBounds(index, index);
2198                             }
2199                             // if index isn't less then lead
2200                             // try to go to cell previous to lead
2201                             if (cellBounds != null && cellBounds.y >= leadRect.y) {
2202                                 p.y = leadRect.y - 1;
2203                                 index = list.locationToIndex(p);
2204                             }
2205                         }
2206                     }
2207                     else {
2208                         // down
2209                         // go to the last completely visible cell
2210                         Point p = new Point(leadRect.x,
2211                                 visRect.y + visRect.height - 1);
2212                         index = list.locationToIndex(p);
2213                         Rectangle cellBounds = list.getCellBounds(index, index);
2214                         // go up one cell if last visible cell doesn't fit
2215                         // into visible rectangle
2216                         if (cellBounds != null &&
2217                                 cellBounds.y + cellBounds.height >
2218                                 visRect.y + visRect.height)
2219                         {
2220                             p.y = cellBounds.y - 1;
2221                             index = list.locationToIndex(p);
2222                             cellBounds = list.getCellBounds(index, index);
2223                             index = Math.max(index, lead);
2224                         }
2225                         
2226                         if (lead >= index) {
2227                             // if lead is the last completely visible index
2228                             // (or below it) adjust the visible rect down
2229                             visRect.y = leadRect.y;
2230                             p.y = visRect.y + visRect.height - 1;
2231                             index = list.locationToIndex(p);
2232                             cellBounds = list.getCellBounds(index, index);
2233                             // go one cell up if last visible cell doesn't fit
2234                             // into adjasted visible rectangle
2235                             if (cellBounds != null &&
2236                                     cellBounds.y + cellBounds.height >
2237                                     visRect.y + visRect.height)
2238                             {
2239                                 p.y = cellBounds.y - 1;
2240                                 index = list.locationToIndex(p);
2241                                 cellBounds = list.getCellBounds(index, index);
2242                             }
2243                             // if index isn't greater then lead
2244                             // try to go to cell next after lead
2245                             if (cellBounds != null && cellBounds.y <= leadRect.y) {
2246                                 p.y = leadRect.y + leadRect.height;
2247                                 index = list.locationToIndex(p);
2248                             }
2249                         }
2250                     }
2251                 }
2252             }
2253             return index;
2254         }
2255 
2256         private void changeSelection(JList<?> list, int type,
2257                                      int index, int direction) {
2258             if (index >= 0 && index < list.getModel().getSize()) {
2259                 ListSelectionModel lsm = list.getSelectionModel();
2260 
2261                 // CHANGE_LEAD is only valid with multiple interval selection
2262                 if (type == CHANGE_LEAD &&
2263                         list.getSelectionMode()
2264                             != ListSelectionModel.MULTIPLE_INTERVAL_SELECTION) {
2265 
2266                     type = CHANGE_SELECTION;
2267                 }
2268 
2269                 // IMPORTANT - This needs to happen before the index is changed.
2270                 // This is because JFileChooser, which uses JList, also scrolls
2271                 // the selected item into view. If that happens first, then
2272                 // this method becomes a no-op.


2299         private void adjustScrollPositionIfNecessary(JList<?> list, int index,
2300                                                      int direction) {
2301             if (direction == 0) {
2302                 return;
2303             }
2304             Rectangle cellBounds = list.getCellBounds(index, index);
2305             Rectangle visRect = list.getVisibleRect();
2306             if (cellBounds != null && !visRect.contains(cellBounds)) {
2307                 if (list.getLayoutOrientation() == JList.VERTICAL_WRAP &&
2308                     list.getVisibleRowCount() <= 0) {
2309                     // horizontal
2310                     if (list.getComponentOrientation().isLeftToRight()) {
2311                         if (direction > 0) {
2312                             // right for left-to-right
2313                             int x =Math.max(0,
2314                                 cellBounds.x + cellBounds.width - visRect.width);
2315                             int startIndex =
2316                                 list.locationToIndex(new Point(x, cellBounds.y));
2317                             Rectangle startRect = list.getCellBounds(startIndex,
2318                                                                      startIndex);
2319                             if (startRect != null && 
2320                                 startRect.x < x && startRect.x < cellBounds.x) {
2321                                 startRect.x += startRect.width;
2322                                 startIndex =
2323                                     list.locationToIndex(startRect.getLocation());
2324                                 startRect = list.getCellBounds(startIndex,
2325                                                                startIndex);
2326                             }
2327                             cellBounds = startRect != null ? startRect : null;
2328                         }
2329                         if (cellBounds != null) {
2330                             cellBounds.width = visRect.width;
2331                         }
2332                     }
2333                     else {
2334                         if (direction > 0) {
2335                             // left for right-to-left
2336                             int x = cellBounds.x + visRect.width;
2337                             int rightIndex =
2338                                 list.locationToIndex(new Point(x, cellBounds.y));
2339                             Rectangle rightRect = list.getCellBounds(rightIndex,
2340                                                                      rightIndex);
2341                             if (rightRect != null) {
2342                                 if (rightRect.x + rightRect.width > x &&
2343                                         rightRect.x > cellBounds.x) {
2344                                     rightRect.width = 0;
2345                                 }
2346                                 cellBounds.x = Math.max(0,
2347                                         rightRect.x + rightRect.width - visRect.width);
2348                                 cellBounds.width = visRect.width;
2349                             }
2350                         }
2351                         else {
2352                             cellBounds.x += Math.max(0,
2353                                 cellBounds.width - visRect.width);
2354                             // adjust width to fit into visible rectangle
2355                             cellBounds.width = Math.min(cellBounds.width,
2356                                                         visRect.width);
2357                         }
2358                     }
2359                 }
2360                 else {
2361                     // vertical
2362                     if (direction > 0 &&
2363                             (cellBounds.y < visRect.y ||
2364                                     cellBounds.y + cellBounds.height
2365                                             > visRect.y + visRect.height)) {
2366                         //down
2367                         int y = Math.max(0,
2368                             cellBounds.y + cellBounds.height - visRect.height);
2369                         int startIndex =
2370                             list.locationToIndex(new Point(cellBounds.x, y));
2371                         Rectangle startRect = list.getCellBounds(startIndex,
2372                                                                  startIndex);
2373                         if (startRect != null &&
2374                                 startRect.y < y && startRect.y < cellBounds.y) {
2375                             startRect.y += startRect.height;
2376                             startIndex =
2377                                 list.locationToIndex(startRect.getLocation());
2378                             startRect =
2379                                 list.getCellBounds(startIndex, startIndex);
2380                         }
2381                         cellBounds = startRect != null ? startRect : null;
2382                         if (cellBounds != null) {
2383                             cellBounds.height = visRect.height;
2384                         }
2385                     }
2386                     else {
2387                         // adjust height to fit into visible rectangle
2388                         cellBounds.height = Math.min(cellBounds.height, visRect.height);
2389                     }
2390                 }
2391                 list.scrollRectToVisible(cellBounds);
2392             }
2393         }
2394 
2395         private int getNextColumnIndex(JList<?> list, BasicListUI ui,
2396                                        int amount) {
2397             if (list.getLayoutOrientation() != JList.VERTICAL) {
2398                 int index = adjustIndex(list.getLeadSelectionIndex(), list);
2399                 int size = list.getModel().getSize();
2400 
2401                 if (index == -1) {
2402                     return 0;
2403                 } else if (size == 1) {
2404                     // there's only one item so we should select it


< prev index next >