aboutsummaryrefslogtreecommitdiff
path: root/libjava/java/util/BitSet.java
blob: c56c0d18c7ffc4493bf6c8a6e5ede68026a6f9fe (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
/* BitSet.java -- A vector of bits.
   Copyright (C) 1998, 1999, 2000, 2001  Free Software Foundation, Inc.

This file is part of GNU Classpath.

GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.

Linking this library statically or dynamically with other modules is
making a combined work based on this library.  Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.

As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module.  An independent module is a module which is not derived from
or based on this library.  If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so.  If you do not wish to do so, delete this
exception statement from your version. */

package java.util;
import java.io.Serializable;

/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
 * hashCode algorithm taken from JDK 1.2 docs.
 */

/**
 * This class can be thought of in two ways.  You can see it as a
 * vector of bits or as a set of non-negative integers.  The name
 * <code>BitSet</code> is a bit misleading.
 *
 * It is implemented by a bit vector, but its equally possible to see
 * it as set of non-negative integer; each integer in the set is
 * represented by a set bit at the corresponding index.  The size of
 * this structure is determined by the highest integer in the set.
 *
 * You can union, intersect and build (symmetric) remainders, by
 * invoking the logical operations and, or, andNot, resp. xor.
 *
 * This implementation is NOT synchronized against concurrent access from
 * multiple threads. Specifically, if one thread is reading from a bitset
 * while another thread is simultaneously modifying it, the results are
 * undefined.
 *
 * @author Jochen Hoenicke
 * @author Tom Tromey <tromey@cygnus.com>
 * @author Eric Blake <ebb9@email.byu.edu>
 * @status updated to 1.4
 */
public class BitSet implements Cloneable, Serializable
{
  /**
   * Compatible with JDK 1.0.
   */
  private static final long serialVersionUID = 7997698588986878753L;

  /**
   * A common mask.
   */
  private static final int LONG_MASK = 0x3f;

  /**
   * The actual bits.
   * @serial the i'th bit is in bits[i/64] at position i%64 (where position
   *         0 is the least significant).
   */
  private long[] bits;

  /**
   * Create a new empty bit set. All bits are initially false.
   */
  public BitSet()
  {
    this(64);
  }

  /**
   * Create a new empty bit set, with a given size.  This
   * constructor reserves enough space to represent the integers
   * from <code>0</code> to <code>nbits-1</code>.
   *
   * @param nbits the initial size of the bit set
   * @throws NegativeArraySizeException if nbits &lt; 0
   */
  public BitSet(int nbits)
  {
    if (nbits < 0)
      throw new NegativeArraySizeException();
    
    int length = nbits >>> 6;
    if ((nbits & LONG_MASK) != 0)
      ++length;
    bits = new long[length];
  }

  /**
   * Performs the logical AND operation on this bit set and the
   * given <code>set</code>.  This means it builds the intersection
   * of the two sets.  The result is stored into this bit set.
   *
   * @param set the second bit set
   * @throws NullPointerException if set is null
   */
  public void and(BitSet bs)
  {
    int max = Math.min(bits.length, bs.bits.length);
    int i;
    for (i = 0; i < max; ++i)
      bits[i] &= bs.bits[i];
    while (i < bits.length)
      bits[i++] = 0;
  }

  /**
   * Performs the logical AND operation on this bit set and the
   * complement of the given <code>set</code>.  This means it
   * selects every element in the first set, that isn't in the
   * second set.  The result is stored into this bit set.
   *
   * @param set the second bit set
   * @throws NullPointerException if set is null
   * @since 1.2
   */
  public void andNot(BitSet bs)
  {
    int i = Math.min(bits.length, bs.bits.length);
    while (--i >= 0)
      bits[i] &= ~bs.bits[i];
  }

  /**
   * Returns the number of bits set to true.
   *
   * @return the number of true bits
   * @since 1.4
   */
  public int cardinality()
  {
    int card = 0;
    for (int i = bits.length - 1; i >= 0; i--)
      {
        long a = bits[i];
        // Take care of common cases.
        if (a == 0)
          continue;
        if (a == -1)
          {
            card += 64;
            continue;
          }

        // Successively collapse alternating bit groups into a sum.
        a = ((a >> 1) & 0x5555555555555555L) + (a & 0x5555555555555555L);
        a = ((a >> 2) & 0x3333333333333333L) + (a & 0x3333333333333333L);
        int b = (int) ((a >>> 32) + a);
        b = ((b >> 4) & 0x0f0f0f0f) + (b & 0x0f0f0f0f);
        b = ((b >> 8) & 0x00ff00ff) + (b & 0x00ff00ff);
        card += ((b >> 16) & 0x0000ffff) + (b & 0x0000ffff);
      }
    return card;
  }

  /**
   * Sets all bits in the set to false.
   *
   * @since 1.4
   */
  public void clear()
  {
    Arrays.fill(bits, 0);
  }

  /**
   * Removes the integer <code>bitIndex</code> from this set. That is
   * the corresponding bit is cleared.  If the index is not in the set,
   * this method does nothing.
   *
   * @param bitIndex a non-negative integer
   * @throws IndexOutOfBoundsException if bitIndex &lt; 0
   */
  public void clear(int pos)
  {
    int offset = pos >> 6;
    ensure(offset);
    // ArrayIndexOutOfBoundsException subclasses IndexOutOfBoundsException,
    // so we'll just let that be our exception.
    bits[offset] &= ~(1L << pos);
  }

  /**
   * Sets the bits between from (inclusive) and to (exclusive) to false.
   *
   * @param from the start range (inclusive)
   * @param to the end range (exclusive)
   * @throws IndexOutOfBoundsException if from &lt; 0 || from &gt; to
   * @since 1.4
   */
  public void clear(int from, int to)
  {
    if (from < 0 || from > to)
      throw new IndexOutOfBoundsException();
    if (from == to)
      return;
    int lo_offset = from >>> 6;
    int hi_offset = to >>> 6;
    ensure(hi_offset);
    if (lo_offset == hi_offset)
      {
        bits[hi_offset] &= ((1L << from) - 1) | (-1L << to);
        return;
      }

    bits[lo_offset] &= (1L << from) - 1;
    bits[hi_offset] &= -1L << to;
    for (int i = lo_offset + 1; i < hi_offset; i++)
      bits[i] = 0;
  }

  /**
   * Create a clone of this bit set, that is an instance of the same
   * class and contains the same elements.  But it doesn't change when
   * this bit set changes.
   *
   * @return the clone of this object.
   */
  public Object clone()
  {
    try
      {
        BitSet bs = (BitSet) super.clone();
        bs.bits = (long[]) bits.clone();
        return bs;
      }
    catch (CloneNotSupportedException e)
      {
        // Impossible to get here.
        return null;
      }
  }

  /**
   * Returns true if the <code>obj</code> is a bit set that contains
   * exactly the same elements as this bit set, otherwise false.
   *
   * @param obj the object to compare to
   * @return true if obj equals this bit set
   */
  public boolean equals(Object obj)
  {
    if (!(obj instanceof BitSet))
      return false;
    BitSet bs = (BitSet) obj;
    int max = Math.min(bits.length, bs.bits.length);
    int i;
    for (i = 0; i < max; ++i)
      if (bits[i] != bs.bits[i])
        return false;
    // If one is larger, check to make sure all extra bits are 0.
    for (int j = i; j < bits.length; ++j)
      if (bits[j] != 0)
        return false;
    for (int j = i; j < bs.bits.length; ++j)
      if (bs.bits[j] != 0)
        return false;
    return true;
  }

  /**
   * Sets the bit at the index to the opposite value.
   *
   * @param index the index of the bit
   * @throws IndexOutOfBoundsException if index is negative
   * @since 1.4
   */
  public void flip(int index)
  {
    int offset = index >> 6;
    ensure(offset);
    // ArrayIndexOutOfBoundsException subclasses IndexOutOfBoundsException,
    // so we'll just let that be our exception.
    bits[offset] ^= 1L << index;
  }

  /**
   * Sets a range of bits to the opposite value.
   *
   * @param from the low index (inclusive)
   * @param to the high index (exclusive)
   * @throws IndexOutOfBoundsException if from &gt; to || from &lt; 0
   * @since 1.4
   */
  public void flip(int from, int to)
  {
    if (from < 0 || from > to)
      throw new IndexOutOfBoundsException();
    if (from == to)
      return;
    int lo_offset = from >>> 6;
    int hi_offset = to >>> 6;
    ensure(hi_offset);
    if (lo_offset == hi_offset)
      {
        bits[hi_offset] ^= (-1L << from) & ((1L << to) - 1);
        return;
      }

    bits[lo_offset] ^= -1L << from;
    bits[hi_offset] ^= (1L << to) - 1;
    for (int i = lo_offset + 1; i < hi_offset; i++)
      bits[i] ^= -1;
  }

  /**
   * Returns true if the integer <code>bitIndex</code> is in this bit
   * set, otherwise false.
   *
   * @param pos a non-negative integer
   * @return the value of the bit at the specified index
   * @throws IndexOutOfBoundsException if the index is negative
   */
  public boolean get(int pos)
  {
    int offset = pos >> 6;
    if (offset >= bits.length)
      return false;
    // ArrayIndexOutOfBoundsException subclasses IndexOutOfBoundsException,
    // so we'll just let that be our exception.
    return (bits[offset] & (1L << pos)) != 0;
  }

  /**
   * Returns a new <code>BitSet</code> composed of a range of bits from
   * this one.
   *
   * @param from the low index (inclusive)
   * @param to the high index (exclusive)
   * @throws IndexOutOfBoundsException if from &gt; to || from &lt; 0
   * @since 1.4
   */
  public BitSet get(int from, int to)
  {
    if (from < 0 || from > to)
      throw new IndexOutOfBoundsException();
    BitSet bs = new BitSet(to - from);
    int lo_offset = from >>> 6;
    if (lo_offset >= bits.length)
      return bs;

    int lo_bit = from & LONG_MASK;
    int hi_offset = to >>> 6;
    if (lo_bit == 0)
      {
        int len = Math.min(hi_offset - lo_offset + 1, bits.length - lo_offset);
        System.arraycopy(bits, lo_offset, bs.bits, 0, len);
        if (hi_offset < bits.length)
          bs.bits[hi_offset - lo_offset] &= (1L << to) - 1;
        return bs;
      }

    int len = Math.min(hi_offset, bits.length - 1);
    int reverse = ~lo_bit;
    int i;
    for (i = 0; lo_offset < len; lo_offset++, i++)
      bs.bits[i] = ((bits[lo_offset] >>> lo_bit)
                    | (bits[lo_offset + 1] << reverse));
    if ((to & LONG_MASK) > lo_bit)
      bs.bits[i++] = bits[lo_offset] >>> lo_bit;
    if (hi_offset < bits.length)
      bs.bits[i - 1] &= (1L << (to - from)) - 1;
    return bs;
  }

  /**
   * Returns a hash code value for this bit set.  The hash code of
   * two bit sets containing the same integers is identical.  The algorithm
   * used to compute it is as follows:
   *
   * Suppose the bits in the BitSet were to be stored in an array of
   * long integers called <code>bits</code>, in such a manner that
   * bit <code>k</code> is set in the BitSet (for non-negative values
   * of <code>k</code>) if and only if
   *
   * <code>((k/64) &lt; bits.length)
   * && ((bits[k/64] & (1L &lt;&lt; (bit % 64))) != 0)
   * </code>
   *
   * Then the following definition of the hashCode method
   * would be a correct implementation of the actual algorithm:
   *
   * 
<pre>public int hashCode()
{
  long h = 1234;
  for (int i = bits.length-1; i &gt;= 0; i--)
  {
    h ^= bits[i] * (i + 1);
  }

  return (int)((h >> 32) ^ h);
}</pre>
   *
   * Note that the hash code values changes, if the set is changed.
   *
   * @return the hash code value for this bit set.
   */
  public int hashCode()
  {
    long h = 1234;
    for (int i = bits.length; i > 0; )
      h ^= i * bits[--i];
    return (int) ((h >> 32) ^ h);
  }

  /**
   * Returns true if the specified BitSet and this one share at least one
   * common true bit.
   *
   * @param set the set to check for intersection
   * @return true if the sets intersect
   * @throws NullPointerException if set is null
   * @since 1.4
   */
  public boolean intersects(BitSet set)
  {
    int i = Math.min(bits.length, set.bits.length);
    while (--i >= 0)
      if ((bits[i] & set.bits[i]) != 0)
        return true;
    return false;
  }

  /**
   * Returns true if this set contains no true bits.
   *
   * @return true if all bits are false
   * @since 1.4
   */
  public boolean isEmpty()
  {
    for (int i = bits.length - 1; i >= 0; i--)
      if (bits[i] != 0)
        return false;
    return true;
  }

  /**
   * Returns the logical number of bits actually used by this bit
   * set.  It returns the index of the highest set bit plus one.
   * Note that this method doesn't return the number of set bits.
   *
   * @return the index of the highest set bit plus one.
   */
  public int length()
  {
    // Set i to highest index that contains a non-zero value.
    int i;
    for (i = bits.length - 1; i >= 0 && bits[i] == 0; --i)
      ;

    // if i < 0 all bits are cleared.
    if (i < 0)
      return 0;

    // Now determine the exact length.
    long b = bits[i];
    int len = (i + 1) * 64;
    // b >= 0 checks if the highest bit is zero.
    while (b >= 0)
      {
        --len;
        b <<= 1;
      }

    return len;
  }

  /**
   * Returns the index of the next false bit, from the specified bit
   * (inclusive).
   *
   * @param from the start location
   * @return the first false bit
   * @throws IndexOutOfBoundsException if from is negative
   * @since 1.4
   */
  public int nextClearBit(int from)
  {
    int offset = from >> 6;
    long mask = 1L << from;
    while (offset < bits.length)
      {
        // ArrayIndexOutOfBoundsException subclasses IndexOutOfBoundsException,
        // so we'll just let that be our exception.
        long h = bits[offset];
        do
          {
            if ((h & mask) == 0)
              return from;
            mask <<= 1;
            from++;
          }
        while (mask != 0);
        mask = 1;
        offset++;
      }
    return from;
  }

  /**
   * Returns the index of the next true bit, from the specified bit
   * (inclusive). If there is none, -1 is returned. You can iterate over
   * all true bits with this loop:<br>
   * 
<pre>for (int i = bs.nextSetBit(0); i &gt;= 0; i = bs.nextSetBit(i + 1))
{
  // operate on i here
}</pre>
   *
   * @param from the start location
   * @return the first true bit, or -1
   * @throws IndexOutOfBoundsException if from is negative
   * @since 1.4
   */
  public int nextSetBit(int from)
  {
    int offset = from >> 6;
    long mask = 1L << from;
    while (offset < bits.length)
      {
        // ArrayIndexOutOfBoundsException subclasses IndexOutOfBoundsException,
        // so we'll just let that be our exception.
        long h = bits[offset];
        do
          {
            if ((h & mask) != 0)
              return from;
            mask <<= 1;
            from++;
          }
        while (mask != 0);
        mask = 1;
        offset++;
      }
    return -1;
  }

  /**
   * Performs the logical OR operation on this bit set and the
   * given <code>set</code>.  This means it builds the union
   * of the two sets.  The result is stored into this bit set, which
   * grows as necessary.
   *
   * @param bs the second bit set
   * @throws NullPointerException if bs is null
   */
  public void or(BitSet bs)
  {
    ensure(bs.bits.length - 1);
    for (int i = bs.bits.length - 1; i >= 0; i--)
      bits[i] |= bs.bits[i];
  }

  /**
   * Add the integer <code>bitIndex</code> to this set.  That is
   * the corresponding bit is set to true.  If the index was already in
   * the set, this method does nothing.  The size of this structure
   * is automatically increased as necessary.
   *
   * @param pos a non-negative integer.
   * @throws IndexOutOfBoundsException if pos is negative
   */
  public void set(int pos)
  {
    int offset = pos >> 6;
    ensure(offset);
    // ArrayIndexOutOfBoundsException subclasses IndexOutOfBoundsException,
    // so we'll just let that be our exception.
    bits[offset] |= 1L << pos;
  }

  /**
   * Sets the bit at the given index to the specified value. The size of
   * this structure is automatically increased as necessary.
   *
   * @param index the position to set
   * @param value the value to set it to
   * @throws IndexOutOfBoundsException if index is negative
   * @since 1.4
   */
  public void set(int index, boolean value)
  {
    if (value)
      set(index);
    else
      clear(index);
  }

  /**
   * Sets the bits between from (inclusive) and to (exclusive) to true.
   *
   * @param from the start range (inclusive)
   * @param to the end range (exclusive)
   * @throws IndexOutOfBoundsException if from &lt; 0 || from &gt; to
   * @since 1.4
   */
  public void set(int from, int to)
  {
    if (from < 0 || from > to)
      throw new IndexOutOfBoundsException();
    if (from == to)
      return;
    int lo_offset = from >>> 6;
    int hi_offset = to >>> 6;
    ensure(hi_offset);
    if (lo_offset == hi_offset)
      {
        bits[hi_offset] |= (-1L << from) & ((1L << to) - 1);
        return;
      }

    bits[lo_offset] |= -1L << from;
    bits[hi_offset] |= (1L << to) - 1;
    for (int i = lo_offset + 1; i < hi_offset; i++)
      bits[i] = -1;
  }

  /**
   * Sets the bits between from (inclusive) and to (exclusive) to the
   * specified value.
   *
   * @param from the start range (inclusive)
   * @param to the end range (exclusive)
   * @param value the value to set it to
   * @throws IndexOutOfBoundsException if from &lt; 0 || from &gt; to
   * @since 1.4
   */
  public void set(int from, int to, boolean value)
  {
    if (value)
      set(from, to);
    else
      clear(from, to);
  }

  /**
   * Returns the number of bits actually used by this bit set.  Note
   * that this method doesn't return the number of set bits, and that
   * future requests for larger bits will make this automatically grow.
   *
   * @return the number of bits currently used.
   */
  public int size()
  {
    return bits.length * 64;
  }

  /**
   * Returns the string representation of this bit set.  This
   * consists of a comma separated list of the integers in this set
   * surrounded by curly braces.  There is a space after each comma.
   * A sample string is thus "{1, 3, 53}".
   * @return the string representation.
   */
  public String toString()
  {
    StringBuffer r = new StringBuffer("{");
    boolean first = true;
    for (int i = 0; i < bits.length; ++i)
      {
        long bit = 1;
        long word = bits[i];
        if (word == 0)
          continue;
        for (int j = 0; j < 64; ++j)
          {
            if ((word & bit) != 0)
              {
                if (! first)
                  r.append(", ");
                r.append(64 * i + j);
                first = false;
              }
            bit <<= 1;
          }
      }
    return r.append("}").toString();
  }

  /**
   * Performs the logical XOR operation on this bit set and the
   * given <code>set</code>.  This means it builds the symmetric
   * remainder of the two sets (the elements that are in one set,
   * but not in the other).  The result is stored into this bit set,
   * which grows as necessary.
   *
   * @param bs the second bit set
   * @throws NullPointerException if bs is null
   */
  public void xor(BitSet bs)
  {
    ensure(bs.bits.length - 1);
    for (int i = bs.bits.length - 1; i >= 0; i--)
      bits[i] ^= bs.bits[i];
  }

  /**
   * Make sure the vector is big enough.
   *
   * @param lastElt the size needed for the bits array
   */
  private final void ensure(int lastElt)
  {
    if (lastElt >= bits.length)
      {
        long[] nd = new long[lastElt + 1];
        System.arraycopy(bits, 0, nd, 0, bits.length);
        bits = nd;
      }
  }
}
elected, disabled, etc. * <br /> * <br /> * As this class tells us virtually nothing about the component, * except for its name and font, no state information can be * provided. This implementation thus returns an empty * state set, and it is left to concrete subclasses to provide * a more acceptable and relevant state set. Changes to these * properties also need to be handled using * <code>PropertyChangeListener</code>s. * * @return an empty <code>AccessibleStateSet</code>. */ public AccessibleStateSet getAccessibleStateSet() { return new AccessibleStateSet(); } /** * Returns the background color of the component, or null * if this property is unsupported. * <br /> * <br /> * This abstract class knows nothing about how the component * is drawn on screen, so this method simply returns the * default system background color used for rendering menus. * Concrete subclasses which handle the drawing of an onscreen * menu component should override this method and provide * the appropriate information. * * @return the default system background color for menus. * @see #setBackground(java.awt.Color) */ public Color getBackground() { return SystemColor.menu; } /** * Returns a <code>Rectangle</code> which represents the * bounds of this component. The returned rectangle has the * height and width of the component's bounds, and is positioned * at a location relative to this component's parent, the * <code>MenuContainer</code>. null is returned if bounds * are not supported by the component. * <br /> * <br /> * This abstract class knows nothing about how the component * is drawn on screen, so this method simply returns null. * Concrete subclasses which handle the drawing of an onscreen * menu component should override this method and provide * the appropriate information. * * @return null. * @see #setBounds(java.awt.Rectangle) */ public Rectangle getBounds() { return null; } /** * Returns the <code>Cursor</code> displayed when the pointer * is positioned over this component. Alternatively, null * is returned if the component doesn't support the cursor * property. * <br /> * <br /> * This abstract class knows nothing about how the component * is drawn on screen, so this method simply returns the default * system cursor. Concrete subclasses which handle the drawing * of an onscreen menu component may override this method and provide * the appropriate information. * * @return the default system cursor. * @see #setCursor(java.awt.Cursor) */ public Cursor getCursor() { return Cursor.getDefaultCursor(); } /** * Returns the <code>Font</code> used for text created by this component. * * @return the current font. * @see #setFont(java.awt.Font) */ public Font getFont() { return MenuComponent.this.getFont(); } /** * Retrieves information on the rendering and metrics of the supplied * font. If font metrics are not supported by this component, null * is returned. * <br /> * <br /> * The abstract implementation of this method simply uses the toolkit * to obtain the <code>FontMetrics</code>. Concrete subclasses may * find it more efficient to invoke their peer class directly, if one * is available. * * @param font the font about which to retrieve rendering and metric * information. * @return the metrics of the given font, as provided by the system * toolkit. * @throws NullPointerException if the supplied font was null. */ public FontMetrics getFontMetrics(Font font) { return MenuComponent.this.getToolkit().getFontMetrics(font); } /** * Returns the foreground color of the component, or null * if this property is unsupported. * <br /> * <br /> * This abstract class knows nothing about how the component * is drawn on screen, so this method simply returns the * default system text color used for rendering menus. * Concrete subclasses which handle the drawing of an onscreen * menu component should override this method and provide * the appropriate information. * * @return the default system text color for menus. * @see #setForeground(java.awt.Color) */ public Color getForeground() { return SystemColor.menuText; } /** * Returns the locale currently in use by this component. * <br /> * <br /> * This abstract class has no property relating to the * locale used by the component, so this method simply * returns the default locale for the current instance * of the Java Virtual Machine (JVM). Concrete subclasses * which maintain such a property should override this method * and provide the locale information more accurately. * * @return the default locale for this JVM instance. */ public Locale getLocale() { return Locale.getDefault(); } /** * Returns the location of the component, with co-ordinates * relative to the parent component and using the co-ordinate * space of the screen. Thus, the point (0,0) is the upper * left corner of the parent component. * <br /> * <br /> * Please note that this method depends on a correctly implemented * version of the <code>getBounds()</code> method. Subclasses * must provide the bounding rectangle via <code>getBounds()</code> * in order for this method to work. * * @return the location of the component, relative to its parent. * @see #setLocation(java.awt.Point) */ public Point getLocation() { /* Simply return the location of the bounding rectangle */ return getBounds().getLocation(); } /** * Returns the location of the component, with co-ordinates * relative to the screen. Thus, the point (0,0) is the upper * left corner of the screen. null is returned if the component * is either not on screen or if this property is unsupported. * <br /> * <br /> * This abstract class knows nothing about how the component * is drawn on screen, so this method simply returns null. * Concrete subclasses which handle the drawing of an onscreen * menu component should override this method and provide * the appropriate information. * * @return the location of the component, relative to the screen. */ public Point getLocationOnScreen() { return null; } /** * Returns the size of the component. * <br /> * <br /> * Please note that this method depends on a correctly implemented * version of the <code>getBounds()</code> method. Subclasses * must provide the bounding rectangle via <code>getBounds()</code> * in order for this method to work. * * @return the size of the component. * @see #setSize(java.awt.Dimension) */ public Dimension getSize() { /* Simply return the size of the bounding rectangle */ return getBounds().getSize(); } /** * Returns true if the accessible child specified by the supplied index * is currently selected. * <br /> * <br /> * As the existence of children can not be determined from * this abstract class, the implementation of this method * is left to subclasses. * * @param index the index of the accessible child to check for selection. * @return false. */ public boolean isAccessibleChildSelected(int index) { return false; } /** * Returns true if this component is currently enabled. * <br /> * <br /> * As this abstract component has no properties related to * its enabled or disabled state, the implementation of this * method is left to subclasses. * * @return false. * @see #setEnabled(boolean) */ public boolean isEnabled() { return false; } /** * Returns true if this component is included in the traversal * of the current focus from one component to the other. * <br /> * <br /> * As this abstract component has no properties related to * its ability to accept the focus, the implementation of this * method is left to subclasses. * * @return false. */ public boolean isFocusTraversable() { return false; } /** * Returns true if the component is being shown on screen. * A component is determined to be shown if it is visible, * and each parent component is also visible. Please note * that, even when a component is showing, it may still be * obscured by other components in front. This method only * determines if the component is being drawn on the screen. * <br /> * <br /> * As this abstract component and its parent have no properties * relating to visibility, the implementation of this method is * left to subclasses. * * @return false. * @see #isVisible() */ public boolean isShowing() { return false; } /** * Returns true if the component is visible. A component may * be visible but not drawn on the screen if one of its parent * components is not visible. To determine if the component is * actually drawn on screen, <code>isShowing()</code> should be * used. * <br /> * <br /> * As this abstract component has no properties relating to its * visibility, the implementation of this method is left to subclasses. * * @return false. * @see #isShowing() * @see #setVisible(boolean) */ public boolean isVisible() { return false; } /** * Removes the accessible child specified by the supplied index from * the list of currently selected children. If the child specified * is not selected, nothing happens. * <br /> * <br /> * As the existence of children can not be determined from * this abstract class, the implementation of this method * is left to subclasses. * * @param index the index of the <code>Accessible</code> child. */ public void removeAccessibleSelection(int index) { /* Subclasses with children should implement this */ } /** * Removes the specified focus listener from the list of registered * focus listeners for this component. * * @param listener the listener to remove. */ public void removeFocusListener(FocusListener listener) { /* Remove the focus listener from the chain */ focusListener = AWTEventMulticaster.remove(focusListener, listener); } /** * Requests that this component gains focus. This depends on the * component being focus traversable. * <br /> * <br /> * As this abstract component has no properties relating to its * focus traversability, or access to a peer with request focusing * abilities, the implementation of this method is left to subclasses. */ public void requestFocus() { /* Ignored */ } /** * Selects all <code>Accessible</code> children of this component which * it is possible to select. The component needs to support multiple * selections. * <br /> * <br /> * This abstract component provides a simplistic implementation of this * method, which ignores the ability of the component to support multiple * selections and simply uses <code>addAccessibleSelection</code> to * add each <code>Accessible</code> child to the selection. The last * <code>Accessible</code> component is thus selected for components * which don't support multiple selections. Concrete implementations should * override this with a more appopriate and efficient implementation, which * properly takes into account the ability of the component to support multiple * selections. */ public void selectAllAccessibleSelection() { /* Simply call addAccessibleSelection() on all accessible children */ for (int a = 0; a < getAccessibleChildrenCount(); ++a) { addAccessibleSelection(a); } } /** * Sets the background color of the component to that specified. * Unspecified behaviour occurs when null is given as the new * background color. * <br /> * <br /> * This abstract class knows nothing about how the component * is drawn on screen, so this method simply ignores the supplied * color and continues to use the default system color. * Concrete subclasses which handle the drawing of an onscreen * menu component should override this method and provide * the appropriate information. * * @param color the new color to use for the background. * @see getBackground() */ public void setBackground(Color color) { /* Ignored */ } /** * Sets the height and width of the component, and its position * relative to this component's parent, to the values specified * by the supplied rectangle. Unspecified behaviour occurs when * null is given as the new bounds. * <br /> * <br /> * This abstract class knows nothing about how the component * is drawn on screen, so this method simply ignores the new * rectangle and continues to return null from <code>getBounds()</code>. * Concrete subclasses which handle the drawing of an onscreen * menu component should override this method and provide * the appropriate information. * * @param rectangle a rectangle which specifies the new bounds of * the component. * @see #getBounds() */ public void setBounds(Rectangle rectangle) { /* Ignored */ } /** * Sets the <code>Cursor</code> used when the pointer is positioned over the * component. Unspecified behaviour occurs when null is given as the new * cursor. * <br /> * <br /> * This abstract class knows nothing about how the component * is drawn on screen, so this method simply ignores the new cursor * and continues to return the default system cursor. Concrete * subclasses which handle the drawing of an onscreen menu component * may override this method and provide the appropriate information. * * @param cursor the new cursor to use. * @see #getCursor() */ public void setCursor(Cursor cursor) { /* Ignored */ } /** * Sets the enabled/disabled state of this component. * <br /> * <br /> * As this abstract component has no properties related to * its enabled or disabled state, the implementation of this * method is left to subclasses. * * @param enabled true if the component should be enabled, * false otherwise. * @see #getEnabled() */ public void setEnabled(boolean enabled) { /* Ignored */ } /** * Sets the <code>Font</code> used for text created by this component. * Unspecified behaviour occurs when null is given as the new * font. * * @param font the new font to use for text. * @see #getFont() */ public void setFont(Font font) { /* Call the method of the enclosing component */ MenuComponent.this.setFont(font); } /** * Sets the foreground color of the component to that specified. * Unspecified behaviour occurs when null is given as the new * background color. * <br /> * <br /> * This abstract class knows nothing about how the component * is drawn on screen, so this method simply ignores the supplied * color and continues to return the default system text color used * for rendering menus. * Concrete subclasses which handle the drawing of an onscreen * menu component should override this method and provide * the appropriate information. * * @param color the new foreground color. * @see #getForeground() */ public void setForeground(Color color) { /* Ignored */ } /** * Sets the location of the component, with co-ordinates * relative to the parent component and using the co-ordinate * space of the screen. Thus, the point (0,0) is the upper * left corner of the parent component. * <br /> * <br /> * Please note that this method depends on a correctly implemented * version of the <code>getBounds()</code> method. Subclasses * must provide the bounding rectangle via <code>getBounds()</code> * in order for this method to work. * * @param point the location of the component, relative to its parent. * @see #getLocation() */ public void setLocation(Point point) { getBounds().setLocation(point); } /** * Sets the size of the component. * <br /> * <br /> * Please note that this method depends on a correctly implemented * version of the <code>getBounds()</code> method. Subclasses * must provide the bounding rectangle via <code>getBounds()</code> * in order for this method to work. * * @param size the new size of the component. * @see #getSize() */ public void setSize(Dimension size) { getBounds().setSize(size); } /** * Sets the visibility state of the component. A component may * be visible but not drawn on the screen if one of its parent * components is not visible. To determine if the component is * actually drawn on screen, <code>isShowing()</code> should be * used. * <br /> * <br /> * As this abstract component has no properties relating to its * visibility, the implementation of this method is left to subclasses. * * @param visibility the new visibility of the component -- true if * the component is visible, false if not. * @see #isShowing() * @see #isVisible() */ public void setVisible(boolean visibility) { /* Ignored */ } } /* class AccessibleAWTMenuComponent */ } // class MenuComponent