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:
|
" codeBody "
/*
* TableSorter.java
*
* Gecre�ërd op 29 Februari 2004, 10:01
*/
pakket au.com.ords.com mission.client.util.table;
/*
* Auteursrecht 2002 Sun Microsystems, Inc. Alle voorgebe*houde rechten.
*
* Herdistributie en gebruik in bron en binaire vormen, met of zonder
* de wijziging, wordt toegelaten op voorwaarde dat de volgende voorwaarden
* zijn samengekomen:
*
* - De Herdistributie van broncode moeten het bovengenoemde auteursrecht behouden
* bericht, deze lijst van voorwaarden en volgende ontkenning.
*
* - De Herdistributie in binaire vorm moet het bovengenoemde auteursrecht reproduceren
* bericht, deze lijst van voorwaarden en volgende ontkenning binnen
* de documentatie en/of andere die materialen van wordt voorzien
* distributie.
*
* Noch de naam van Sun Microsystems, Inc. of de namen van
* de medewerkers kunnen worden gebruikt om afgeleide producten te onderschrijven of te bevorderen
* van deze software zonder specifieke vroegere geschreven toestemming.
*
* Deze software wordt verstrekt „ZOALS IS,“ zonder een garantie van om het even welk
* soort. IEDEREEN DRUKT OF IMPLICEERDE VOORWAARDEN, VERTEGENWOORDIGING UIT EN
* GARANTIES, MET INBEGRIP VAN OM HET EVEN WELKE IMPLICIETE GARANTIE VAN MERCHANTABILITY,
* DE GESCHIKTHEID VOOR EEN BEPAALDE DOEL OF EEN NIET-OVERTREDING, IS HIERBIJ
* UITGESLOTEN. DE ZON EN ZIJN LICENTIEGEVERS ZULLEN NIET VOOR OM HET EVEN WELKE SCHADE AANSPRAKELIJK ZIJN
* OPGELOPEN DOOR VERGUNNINGHOUDER ALS RESULTAAT VAN GEBRUIKEN, DIE WIJZIGEN ZICH OF
* HET VERDELEN VAN DE SOFTWARE OF ZIJN DERIVATEN. IN GEEN GEBEURTENIS ZAL ZONNEN
* OF ZIJN LICENTIEGEVERS AANSPRAKELIJK ZIJN VOOR OM HET EVEN WELKE VERLOREN OPBRENGST, WINST OF GEGEVENS, OF
* VOOR DIRECT, INDIRECT, SPECIAAL, GEWICHTIG, BIJKOMEND OF
* BESTRAFFENDE DIE SCHADE, NOCHTANS EN ONGEACHT DE THEORIE WORDT VEROORZAAKT VAN
* AANSPRAKELIJKHEID, DIE UIT HET GEBRUIK VAN OF HET ONVERMOGEN VOORTKOMEN OM SOFTWARE TE GEBRUIKEN,
* ZELFS ALS DE ZON VAN DE MOGELIJKHEID VAN DERGELIJKE SCHADE IS GEADVISEERD.
*
* U erkent dat de Software niet wordt ontworpen, vergunning gegeven of bedoeld
* voor gebruik in het ontwerp, bouw, verrichting of onderhoud van
* om het even welke kernfaciliteit.
*/
/**
* Een sorteerder voor TableModels. De sorteerder heeft een model die (met TableModel in overeenstemming zijn)
* en zelf voert TableModel uit. TableSorter slaat niet op of kopi�ërt
* de gegevens in TableModel, het handhaven in plaats daarvan een serie van
* gehelen die het de zelfde grootte zoals het aantal rijen in zijn houdt
* model. Wanneer het model verandert deelt het de sorteerder mee dat iets
* is veranderd b.v. „rowsAdded“ zodat zijn interne serie van gehelen
* kan worden opnieuw toegewezen. Zoals verzoeken worden gemaakt van de sorteerder (als
* getValueAt (rij, col.) het richt hen aan zijn model via de afbeelding opnieuw
* serie. Die manier TableSorter schijnt om een ander exemplaar van de lijst te houden
* met de rijen in een verschillende orde. Gebruikt sorteren algorthm is stabiel
* welke middelen geen die het rond rijen wanneer zijn vergelijking beweegt
* de functie keert 0 terug om aan te duiden dat zij gelijkwaardig zijn.
*
* @version 1.8 04/23/99
* @author Philip Milne
*/
de invoer java.awt. Component;
de invoer java.util.*;
de invoer javax.swing.ImageIcon;
de invoer javax.swing.SwingConstants;
de invoer javax.swing.table.TableModel;
de invoer javax.swing.event.TableModelEvent;
// de Invoer voor het opnemen van muisgebeurtenissen van JTable.
de invoer java.awt.event.MouseAdapter;
de invoer java.awt.event.MouseEvent;
de invoer java.awt.event.InputEvent;
de invoer javax.swing.JLabel;
de invoer javax.swing.JTable;
de invoer javax.swing.UIManager;
de invoer javax.swing.table.JTableHeader;
de invoer javax.swing.table.TableColumn;
de invoer javax.swing.table.TableColumnModel;
de invoer javax.swing.table.TableCellRenderer;
de invoer javax.swing.table.DefaultTableCellRenderer;
de invoer au.com.ords.com mission.client.util.table.TableMap;
de openbare klasse TableSorter breidt TableMap uit
{
int. indexen [];
Vector sortingColumns = nieuwe Vector ();
stijgen het van Boole = waar;
int. sortingColumn = -1;
int. vergelijkt;
wijzigen zich het van Boole = vals;
openbare TableSorter ()
{
indexeert = nieuw int. [0]; // voor consistentie.
}
openbare TableSorter (model TableModel)
{
setModel (model);
}
openbare nietige setModel (model TableModel)
{
sortingColumn = -1;
super.setModel (model);
reallocateIndexes ();
}
openbaar int. compareRowsByColumn (int. row1, int.row2, int.kolom)
{
Het type van klasse = model.getColumnClass (kolom);
De gegevens van TableModel = model;
// de Controle voor verklaart nietig
Voorwerp o1 = data.getValueAt (row1, kolom);
Voorwerp O2 = data.getValueAt (row2, kolom);
// als beide waarden ongeldige terugkeer 0 zijn
als (o1 ongeldig == ongeldig && O2 ==)
{
terugkeer 0;
}
als anders (o1 ongeldige ==)
{// bepaalt ongeldig minder dan alles.
terugkeer -1;
}
als anders (ongeldig O2 ==)
{
terugkeer 1;
}
/* wij kopiëren alle teruggekeerde waarden van de getValuevraag voor het geval dat
een geoptimaliseerd model gebruikt één voorwerp opnieuw om vele waarden terug te keren.
De subklassen van het Aantal in JDK zijn onveranderlijk en niet binnen zo gebruikt
deze manier maar andere subklassen van Aantal zouden te bewaren dit kunnen willen doen
de ruimte en vermijdt onnodige hooptoewijzing.
*/
als (type.getSuperclass () == java.lang. Number.class)
{
Aantal n1;
N2 van het aantal;
****** komt de fout onder ********* voor
als (data.getValueAt (row1, kolom) .getClass () .getSuperclass () == java.lang. Number.class)
**************************************************
{
n1 = (Aantal) data.getValueAt (row1, kolom);
}
anders
{
probeer
{
n1 = Double.valueOf (data.getValueAt (row1, kolom) .toString ());
}
vangst (NumberFormatException nexc)
{
//n1 = nieuw Dubbel (0);
werp nieuwe ClassCastException (de „Kolom“ + model.getColumnName (kolom) + „kan niet worden gesorteerd. +“ +
„het nTrying \ om een Aantal te vergelijken wanneer de rij“ + row1 + + data.getValueAt (row1, kolom) .getClass () + „“ is
„is nand rij \“ + row2 + „“ + data.getValueAt (row2, kolom) .getClass () + „. “);
}
}
dubbele d1 = n1.doubleValue ();
************ komt de fout onder *************** voor
als (data.getValueAt (row2, kolom) .getClass () .getSuperclass () == java.lang. Number.class)
******************************************************
{
N2 = (Aantal) data.getValueAt (row2, kolom);
}
anders
{
probeer
{
N2 = Double.valueOf (data.getValueAt (row2, kolom) .toString ());
}
vangst (NumberFormatException nexc)
{
//n2 = nieuw Dubbel (0);
werp nieuwe ClassCastException (de „Kolom“ + model.getColumnName (kolom) + „kan niet worden gesorteerd. +“ +
„het nTrying \ om een Aantal te vergelijken wanneer de rij“ + row1 + + data.getValueAt (row1, kolom) .getClass () + „“ is
„is nand rij \“ + row2 + „“ + data.getValueAt (row2, kolom) .getClass () + „. “);
}
}
dubbele d2 = n2.doubleValue ();
als (d1 < d2)
terugkeer -1;
als anders (d1 > d2)
terugkeer 1;
anders
terugkeer 0;
}
als anders (type == java.util. Date.class)
{
Datum d1 = (Datum) data.getValueAt (row1, kolom);
lange n1 = d1.getTime ();
Datum d2 = (Datum) data.getValueAt (row2, kolom);
lang N2 = d2.getTime ();
als (n1 < N2)
terugkeer -1;
als anders (n1 > N2)
terugkeer 1;
anders terugkeer 0;
}
als anders (type == String.class)
{
Koord S1 = ((Koord) data.getValueAt (row1, kolom)).toLowerCase ();
Koord s2 = ((Koord) data.getValueAt (row2, kolom)).toLowerCase ();
int. resultaat = s1.com pareTo (s2);
als (resultaat < 0)
terugkeer -1;
als anders (resultaat > 0)
terugkeer 1;
anders terugkeer 0;
}
als anders (type == Boolean.class)
{
Van Boole bool1 = data.getValueAt (Van Boole) (row1, kolom);
b1 van Boole = bool1.booleanValue ();
Van Boole bool2 = data.getValueAt (Van Boole) (row2, kolom);
b2 van Boole = bool2.booleanValue ();
als (b1 == b2)
terugkeer 0;
anders als (b1) // vals < waar bepaalt
terugkeer 1;
anders
terugkeer -1;
}
anders
{
Voorwerp v1 = data.getValueAt (row1, kolom);
Koord S1 = () .toLowerCase v1.toString ();
Voorwerp v2 = data.getValueAt (row2, kolom);
Koord s2 = () .toLowerCase v2.toString ();
int. resultaat = s1.com pareTo (s2);
als (resultaat < 0)
terugkeer -1;
als anders (resultaat > 0)
terugkeer 1;
anders terugkeer 0;
}
}
openbaar int. vergelijkt (int. row1, int. row2)
{
compares++;
voor (int.niveau = 0; niveau < sortingColumns.size (); level++)
{
De kolom van het geheel = (Geheel) sortingColumns.elementAt (niveau);
int. resultaat = compareRowsByColumn (row1, row2, column.intValue ());
als (resultaat! = 0)
terugkeer het stijgen? resultaat: - resultaat;
}
terugkeer 0;
}
openbare nietige reallocateIndexes ()
{
int. rowCount = model.getRowCount ();
// Opstelling een nieuwe serie van indexen met het juiste aantal elementen
// voor het nieuwe gegevensmodel.
indexeert = nieuw int. [rowCount];
// initialiseert met de identiteitsafbeelding.
voor (int.rij = 0; rij < rowCount; row++)
indexeert [rij] = rij;
}
de openbare leegte tableChanged (TableModelEvent e)
{
als (! het modifying)
{
reallocateIndexes ();
// de gegevens van de Lijst zijn veranderd. Dwing een toevlucht.
soort (dit);
super.tableChanged (e);
}
}
openbare nietige checkModel ()
{
als (indexes.length! = model.getRowCount ())
{
System.err.println („Sorteerder niet over een verandering in model wordt geïnformeerd$ dat. “);
}
}
openbare nietige soort (de afzender van Objecten)
{
checkModel ();
vergelijkt = 0;
//n2sort ();
// qsort (0, indexes.length-1);
shuttlesort ((int. []) indexes.clone (), indexen, 0, indexes.length);
//mysort ();
}
openbare nietige n2sort ()
{
voor (int. i = 0; i < getRowCount (); i++)
{
voor (int. j = i+1; j < getRowCount (); j++)
{
als (vergelijk (indexen [I], indexen [j]) == -1)
{
ruilmiddel (I, j);
}
}
}
}
// dit is een inlandse implementatie die wij geen tijd hebben gehad
// aan onderzoek - het kan slecht in sommige omstandigheden presteren. Het
// vereist tweemaal de ruimte van een in-place algoritme en maakt
// NlogN assigments die de waarden tussen twee shuttling
// series. Het aantal van vergelijkt schijnt om tussen n-1 te variëren en
// NlogN afhankelijk van de aanvankelijke orde maar de belangrijkste reden voor
// die het hier is gebruiken dat, in tegenstelling tot qsort, het stabiel is.
openbare nietige shuttlesort (int. van [], int. aan [], laag int., hoog int.)
{
als (hoogte - lage < 2)
{
terugkeer;
}
int. midden = (laag + hoog) /2;
shuttlesort (aan, van, laag, midden);
shuttlesort (aan, van, hoog midden,);
int. p = laag;
int. q = midden;
/* dit is een facultatieve kortere weg; bij elke recursieve vraag,
controle om te zien of reeds zijn de elementen in deze ondergroep
bevolen. Als zo, zijn geen verdere vergelijkingen nodig;
de sub-serie kan enkel worden gekopi�ërd. De serie moet eerder worden gekopi�ërd
dan toegewezen anders zuster roept binnen de terugkeer zou kunnen
krijg uit sinc. Wanneer het aantal elementen drie zij is
worden verdeeld zodat de eerste [laag, medio) reeks, heeft
het element en en de tweede, [medio, hoog), hebben twee. Wij slaan over
optimalisering wanneer het aantal elementen drie of minder zoals is
de eerste vergelijken in de normale fusie zullen produceren het zelfde
opeenvolging van stappen. Deze optimalisering schijnt lonend te zijn
voor gedeeltelijk bevolen lijsten maar één of andere analyse is nodig aan
kom te weten hoe de prestaties aan Nlog (N) als initiaal dalen
de orde vermindert - het kan zeer snel dalen. */
/*
als (hoogte - lage >= 4 && vergelijkt (van [midden-1], van [midden]) <= 0)
{
voor (int. i = laag; i < hoog; i++)
{
[I] = van [I];
}
terugkeer;
}
**/
// A normale fusie.
voor (int. i = laag; i < hoog; i++)
{
als (hoog q >= || (p < vergelijkt midden&& (van [p], van [q]) <= 0))
{
[I] = van [p++];
}
anders
{
[I] = van [q++];
}
}
}
openbare nietige mysort ()
{
voor (int. i = 0; i < indexes.length - 1; i++)
{
voor (int. j = I + 1; j < indexes.length; j++)
{
als (stijgend)
{
als (vergelijk (indexen [I], indexen [j]) < 0)
{
ruilmiddel (I, j);
}
}
anders
{
als (vergelijk (indexen [I], indexen [j]) > 0)
{
ruilmiddel (I, j);
}
}
}
}
}
openbaar nietig ruilmiddel (int. i, int. j)
{
int. tmp = indexen [I];
indexeert [I] = indexen [j];
indexeert [j] = tmp;
}
openbaar int. [] getIndex ()
{
terugkeer indexen;
}
// de afbeelding beïnvloedt slechts de inhoud van de gegevensrijen.
// Pas alle verzoeken aan deze rijen door de afbeeldingsserie: „indexen“.
openbaar Voorwerp getValueAt (int. aRow, int. aColumn)
{
checkModel ();
terugkeer model.getValueAt (indexen [aRow], aColumn);
}
openbare nietige setValueAt (Voorwerp aValue, int. aRow, int. aColumn)
{
checkModel ();
model.setValueAt (aValue, indexen [aRow], aColumn);
}
openbare nietige sortByColumn (int.kolom)
{
sortByColumn (ware kolom,);
}
openbare nietige sortByColumn (int.kolom, stijgen het van Boole)
{
sortingColumn = kolom;
this.ascending = stijgend;
sortingColumns.removeAllElements ();
sortingColumns.addElement (nieuw Geheel (kolom));
soort (dit);
super.tableChanged (nieuwe TableModelEvent (dit));
}
// is daar nergens anders om dit te zetten.
// voegt een muisluisteraar aan de Lijst toe om een lijstsoort teweeg te brengen
// wanneer een kolomrubriek in JTable wordt geklikt.
openbare nietige addMouseListenerToHeaderInTable (lijst JTable)
{
definitieve sorteerder TableSorter = dit;
definitieve JTable tableView = lijst;
(vals) tableView.setColumnSelectionAllowed;
MouseAdapter listMouseListener = nieuwe MouseAdapter ()
{
de openbare leegte mouseClicked (MouseEvent e)
{
tableView.setCursor (nieuwe java.awt. Curseur (java.awt. Cursor.WAIT_CURSOR));
tableView.getTableHeader () .setCursor (nieuwe java.awt. Curseur (java.awt. Cursor.WAIT_CURSOR));
TableColumnModel columnModel = tableView.getColumnModel ();
int. viewColumn = columnModel.getColumnIndexAtX (e.getX ());
int. kolom = tableView.convertColumnIndexToModel (viewColumn);
//if (e.getClickCount () == 1 kolom &&! = -1)
als (e.getClickCount () >= 1 kolom &&! = -1)
{
int. shiftPressed = e.getModifiers () &InputEvent.SHIFT_MASK;
//boolean die = stijgen (shiftPressed == 0);
stijgen het van Boole = (e.getClickCount () == 1);
editable van Boole = waar;
het wijzigen zich = waar;
als (tableView.getModel () instanceof DataTableModel)
{
editable = ((DataTableModel) tableView.getModel ()).getCellEditable ();
((DataTableModel) tableView.getModel ())(waar) .setCellEditable;
}
// wint gegevens van model terug
rowData van objecten [] [] = nieuw Voorwerp [tableView.getModel () .getRowCount ()][tableView.getModel () .getColumnCount ()];
voor (int. i = 0; i < tableView.getModel () .getRowCount (); i++)
{
voor (int. j = 0; j < tableView.getModel () .getColumnCount (); j++)
{
rowData [I] [j] = tableView.getModel () .getValueAt (I, j);
//System.out.print (rowData [I] [j] + „„);
}
System.out.println ();
}
reallocateIndexes ();
int. selectedRow = tableView.getSelectedRow ();
sorter.sortByColumn (kolom, het stijgen);
// plaatst nu gegevens in model door index
voor (int. i = 0; i < tableView.getModel () .getRowCount (); i++)
{
voor (int. j = 0; j < tableView.getModel () .getColumnCount (); j++)
{
tableView.getModel () .setValueAt (rowData [indexen [I]] [j], I, j);
}
als (indexen [I] == selectedRow)
{
probeer
{
tableView.setRowSelectionInterval (I, I);
}
vangst (IllegalArgumentException uitz.)
{
// doet niets
}
}
}
als (tableView.getModel () instanceof DataTableModel)
{
((DataTableModel) tableView.getModel ())(editable) .setCellEditable;
}
het wijzigen zich = vals;
tableView.validate ();
}
tableView.getTableHeader () .repaint ();
tableView.setCursor (java.awt. Cursor.getPredefinedCursor (java.awt. Cursor.DEFAULT_CURSOR));
tableView.getTableHeader () .setCursor (java.awt. Cursor.getPredefinedCursor (java.awt. Cursor.DEFAULT_CURSOR));
}
};
JTableHeader Th = tableView.getTableHeader ();
th.addMouseListener (listMouseListener);
th.setDefaultRenderer (createDefaultRenderer ());
}
beschermde createDefaultRenderer TableCellRenderer ()
{
Het etiket van DefaultTableCellRenderer =
nieuwe DefaultTableCellRenderer ()
{
openbare getTableCellRendererComponent Component (lijst JTable,
Waarde van objecten, van Boole isSelected, hasFocus van Boole,
int. rij, int.kolom)
{
als (lijst! = verklaar) nietig
{
De kopbal van JTableHeader = table.getTableHeader ();
als (kopbal! = verklaar) nietig
{
setForeground (header.getForeground ());
setBackground (header.getBackground ());
setFont (header.getFont ());
als (kolom == sortingColumn)
{
als (stijgend)
{
probeer
{
//setIcon (nieuwe ImageIcon (getClass () .getResource (
// " /resources/arrowDown.gif ")));
setIcon (TableHeaderIcon.getArrowDown ());
}
vangst (Uitzondering uitz.)
{
}
} anders
{
probeer
{
//setIcon (nieuwe ImageIcon (getClass () .getResource (
// " /resources/arrowUp.gif ")));
setIcon (TableHeaderIcon.getArrowUp ());
}
vangst (Uitzondering uitz.)
{
}
}
} anders
{
setIcon (ongeldig);
}
}
}
setText ((ongeldige waarde ==)? "": value.toString ());
setBorder (UIManager.getBorder („TableHeader.cellBorder“));
keer dit terug;
}
};
label.setHorizontalAlignment (JLabel.CENTER);
label.setHorizontalTextPosition (SwingConstants.LEFT);
keer etiket terug;
}
}
|
