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:
6:
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:
|
/*
* TableSorter.java
*
* Am 29. Februar 2004 verursacht, 10:01
*
Paket au.com.ords.com mission.client.util.table;
/*
* Copyright 2002 Sun Microsystems, Inc. alle Rechte vorbehalten.
*
* Wiederverteilung und Gebrauch in der Quelle und in den binären Formen, mit oder ohne
* Änderung, werden vorausgesetzt dass die folgenden Bedingungen die Erlaubnis gehabt
* werden getroffen:
*
* - Wiederverteilungen des Quellencodes müssen das oben genannte copyright behalten
* Nachricht, diese Liste von Bedingungen und der folgende Verzicht.
*
* - Wiederverteilung in der binären Form muss das oben genannte copyright reproduzieren
* Nachricht, diese Liste von Bedingungen und der folgende Verzicht innen
* die Unterlagen und/oder andere Materialien versahen mit
* Verteilung.
*
* Keine der Name von Sun Microsystems, Inc. oder die Namen von
* Mitwirkende können gewohnt sein, die abgeleiteten Produkte zu indossieren oder zu fördern
* von dieser Software ohne spezifische vorherige schriftliche Erlaubnis.
*
* Diese Software wird „zur Verfügung gestellt, WIE IST,“ ohne eine Garantie von irgendwelchen
* Art. ALLE DRÜCKEN AUS ODER DEUTETEN BEDINGUNGEN, DARSTELLUNGEN AN UND
* GARANTIEN, EINSCHLIESSLICH IRGENDEINE IMPLIZIERTE GARANTIE DER MARKTGÄNGIGKEIT,
* EIGNUNG ZU EINEM BESTIMMTEN ZWECK ODER ZU EINEM NON-INFRINGEMENT, SIND HIERMIT
* AUSGESCHLOSSEN. SONNE UND SEINE LIZENZGEBER SIND NICHT FÜR IRGENDWELCHE SCHÄDEN VERANTWORTLICH
* GELITTEN DURCH LICENSEE RESULTIEREND AUS DER ANWENDUNG, ABÄNDERUNG ODER
* VERTEILEN DER SOFTWARE ODER SEINER ABLEITUNGEN. AUF KEINEN FALL SONNT SICH
* ODER SEINE LIZENZGEBER SIND FÜR ALLES VERLORENE EINKOMMEN, PROFIT ODER DATEN VERANTWORTLICH ODER
* FÜR DIREKTES, INDIREKTES, SPEZIELLES, LOGISCH FOLGENDES, NEBENSÄCHLICHKEIT ODER
* STRAFZUSCHLÄGE ZU DEM SCHADENERSATZ, JEDOCH VERURSACHT UND UNABHÄNGIG DAVON DIE THEORIE VON
* HAFTUNG, ENTSTEHEND AUS DEM GEBRAUCH ODER DER UNFÄHIGKEIT HERAUS, SOFTWARE ZU BENUTZEN,
* SELBST WENN SONNE VON DER MÖGLICHKEIT SOLCHER SCHÄDEN BENACHRICHTIGT WORDEN IST.
*
* Sie bestätigen, dass Software nicht entworfen, genehmigt oder beabsichtigt ist
* für Gebrauch im Entwurf, im Aufbau, im Betrieb oder in der Wartung von
* irgendein Atomkraftwerk.
*
/**
* Ein Sorter für TableModels. Der Sorter hat ein vorbildliches (in Übereinstimmung mit TableModel)
* und selbst führt TableModel ein. TableSorter speichert nicht oder kopiert
* die Daten im TableModel, stattdessen behält es eine Reihe von bei
* ganze Zahlen, denen es die selbe Größe als die Zahl Reihen in seinem hält
* Modell. Wenn die vorbildlichen Änderungen es den Sorter der etwas meldet
* hat „z.B. rowsAdded“ damit seine interne Reihe ganze Zahlen geändert
* kann neu zugeteilt werden. Als Anträge werden vom Sorter gebildet (wie
* getValueAt (Reihe, Spalte) adressiert er sie zu seinem Modell über das Diagramm um
* Reihe. So das TableSorter scheint, eine andere Kopie der Tabelle zu halten
* mit den Reihen in einem anderen Auftrag. Das sortierende algorthm, das benutzt wird, ist beständig
* das bedeutet, dass es sich nicht um Reihen wenn sein Vergleich bewegt
* Funktion bringt 0 zurück, um zu bezeichnen, dass sie gleichwertig sind.
*
* @version 1.8 04/23/99
* @author Philip Milne
*
Import java.awt. Bestandteil;
Import java.util.*;
Import javax.swing.ImageIcon;
Import javax.swing.SwingConstants;
Import javax.swing.table.TableModel;
Import javax.swing.event.TableModelEvent;
//-Importe für Mäuseereignisse vom JTable aufheben.
Import java.awt.event.MouseAdapter;
Import java.awt.event.MouseEvent;
Import java.awt.event.InputEvent;
Import javax.swing.JLabel;
Import javax.swing.JTable;
Import javax.swing.UIManager;
Import javax.swing.table.JTableHeader;
Import javax.swing.table.TableColumn;
Import javax.swing.table.TableColumnModel;
Import javax.swing.table.TableCellRenderer;
Import javax.swing.table.DefaultTableCellRenderer;
Import au.com.ords.com mission.client.util.table.TableMap;
allgemeine Kategorie TableSorter verlängert TableMap
{
int-Indizes [];
VektorsortingColumns = neuer Vektor ();
das Boolesche Steigen = richten aus;
int sortingColumn = -1;
int vergleicht;
Boolesche Abänderung = falsch;
allgemeines TableSorter ()
{
Indizes = neuer int [0]; // für Übereinstimmung.
}
allgemeines TableSorter (TableModel Modell)
{
setModel (Modell);
}
Öffentlichkeit leeres setModel (TableModel Modell)
{
sortingColumn = -1;
super.setModel (Modell);
reallocateIndexes ();
}
allgemeines int compareRowsByColumn (int row1, int-row2, int Spalte)
{
Kategorienart = model.getColumnClass (Spalte);
TableModel Daten = Modell;
//-Überprüfung auf nulls
Gegenstand o1 = data.getValueAt (row1, Spalte);
Gegenstand O2 = data.getValueAt (row2, Spalte);
//, wenn beide Werte Nullrückkehr 0 sind
wenn (== o1 Null && O2 == Null)
{
Rückkehr 0;
}
sonst, wenn (== o1 Null)
{// definieren Null weniger als alles.
-1 zurückbringen;
}
sonst, wenn (== O2 Null)
{
Rückkehr 1;
}
/* kopieren wir alle zurückgebrachten Werte vom getValue Anruf falls
ein optimiertes Modell verwendet einen Gegenstand wieder, um viele Werte zurückzubringen.
Die Zahlunterklassen im JDK sind unabänderlich und also werden nicht innen verwendet werden
auf diese Weise aber andere Unterklassen der Zahl konnten dies tun wünschen, um zu speichern
nicht notwendige Haufenverteilung sperren und vermeiden.
*
wenn (type.getSuperclass () == java.lang. Number.class)
{
Zahl n1;
Zahln2;
****** Störung tritt unterhalb des ********* auf
wenn (data.getValueAt (row1, Spalte) .getClass () .getSuperclass () == java.lang. Number.class)
**************************************************
{
n1 = (Zahl) data.getValueAt (row1, Spalte);
}
sonst
{
Versuch
{
n1 = Double.valueOf (data.getValueAt (row1, Spalte) .toString ());
}
Fang (NumberFormatException nexc)
{
//n1 = neues Doppeltes (0);
Wurf neues ClassCastException („Spalte“ + model.getColumnName (Spalte) + „kann nicht sortiert werden. +“ +
„\ nTrying, um eine Zahl zu vergleichen, wenn Reihe“ + row1 + „“ + data.getValueAt (row1, Spalte) .getClass () + ist
„\ NAND Reihe“ + row2 + „ist“ + data.getValueAt (row2, Spalte) .getClass () + „.");
}
}
doppelt d1 = n1.doubleValue ();
************ Störung tritt unterhalb des *************** auf
wenn (data.getValueAt (row2, Spalte) .getClass () .getSuperclass () == java.lang. Number.class)
******************************************************
{
N2 = (Zahl) data.getValueAt (row2, Spalte);
}
sonst
{
Versuch
{
N2 = Double.valueOf (data.getValueAt (row2, Spalte) .toString ());
}
Fang (NumberFormatException nexc)
{
//n2 = neues Doppeltes (0);
Wurf neues ClassCastException („Spalte“ + model.getColumnName (Spalte) + „kann nicht sortiert werden. +“ +
„\ nTrying, um eine Zahl zu vergleichen, wenn Reihe“ + row1 + „“ + data.getValueAt (row1, Spalte) .getClass () + ist
„\ NAND Reihe“ + row2 + „ist“ + data.getValueAt (row2, Spalte) .getClass () + „.");
}
}
doppelt d2 = n2.doubleValue ();
wenn (d1 < d2)
-1 zurückbringen;
sonst, wenn (d1 > d2)
Rückkehr 1;
sonst
Rückkehr 0;
}
sonst wenn (Art == java.util. Date.class)
{
Datum d1 = (Datum) data.getValueAt (row1, Spalte);
lang n1 = d1.getTime ();
Datieren d2 = (Datum) data.getValueAt (row2, Spalte);
langes N2 = d2.getTime ();
wenn (n1 < N2)
-1 zurückbringen;
sonst, wenn (n1 > N2)
Rückkehr 1;
sonst Rückkehr 0;
}
sonst, wenn (Art == String.class)
{
Aufreihen s1 = ((Schnur) data.getValueAt (row1, Spalte)).toLowerCase ();
Reiht s2 = auf ((Schnur) data.getValueAt (row2, Spalte)).toLowerCase ();
int-Resultat = s1.com pareTo (s2);
wenn (Resultat < 0)
-1 zurückbringen;
sonst, wenn (Resultat > 0)
Rückkehr 1;
sonst Rückkehr 0;
}
sonst, wenn (Art == Boolean.class)
{
Boolesch bool1 = (Boolesches) data.getValueAt (row1, Spalte);
Boolesch b1 = bool1.booleanValue ();
Boolesch bool2 = (Boolesches) data.getValueAt (row2, Spalte);
Boolesch b2 = bool2.booleanValue ();
wenn (b1 == b2)
Rückkehr 0;
sonst, wenn (b1) // falsches < definieren, ausrichten
Rückkehr 1;
sonst
-1 zurückbringen;
}
sonst
{
Gegenstand v1 = data.getValueAt (row1, Spalte);
Aufreihen s1 = v1.toString () .toLowerCase ();
Einwenden v2 = data.getValueAt (row2, Spalte);
Aufreihen s2 = v2.toString () .toLowerCase ();
int-Resultat = s1.com pareTo (s2);
wenn (Resultat < 0)
-1 zurückbringen;
sonst, wenn (Resultat > 0)
Rückkehr 1;
sonst Rückkehr 0;
}
}
Öffentlichkeit int vergleichen (int row1, int row2)
{
compares++;
für (int-Niveau = 0; Niveau < sortingColumns.size (); level++)
{
Zahlspalte = (ganze Zahl) sortingColumns.elementAt (waagerecht ausgerichtet);
int-Resultat = compareRowsByColumn (row1, row2, column.intValue ());
wenn (Resultat! = 0)
Rückholsteigen? Resultat: - Resultat;
}
Rückkehr 0;
}
Öffentlichkeit leere reallocateIndexes ()
{
int rowCount = model.getRowCount ();
// gründete eine neue Reihe Indizes mit der rechten Zahl Elementen
// für das neue Datenmodell.
Indizes = neuer int [rowCount];
// initialisieren mit dem Identitätsdiagramm.
für (int-Reihe = 0; Reihe < rowCount; row++)
Indizes [Reihe] = Reihe;
}
Öffentlichkeitslücke tableChanged (TableModelEvent e)
{
wenn (! Abänderung)
{
reallocateIndexes ();
//-Tabellendaten haben geändert. Einen Erholungsort zwingen.
Art (diese);
super.tableChanged (e);
}
}
Öffentlichkeit leeres checkModel ()
{
wenn (indexes.length! = model.getRowCount ())
{
System.err.println („Sorter informiert nicht über eine Änderung in model.");
}
}
leere Art der Öffentlichkeit (Gegenstandabsender)
{
checkModel ();
vergleicht = 0;
//n2sort ();
// qsort (0, indexes.length-1);
shuttlesort ((int []) indexes.clone (), Indizes, 0, indexes.length);
//mysort ();
}
Öffentlichkeit leere n2sort ()
{
für (int I = 0; I < getRowCount (); i++)
{
für (int J = i+1; J < getRowCount (); j++)
{
wenn (vergleichen (Indizes [i], Indizes [J]) == -1)
{
austauschen (i, j);
}
}
}
}
// dieses ist eine selbst erzeugte Implementierung, der wir nicht Zeit gehabt haben
// zur Forschung - sie kann in einigen Umständen schlecht durchführen. Es
// erfordert zweimal den Raum eines am Ort Algorithmus und bildet
// NlogN assigments, welche die Werte zwischen die zwei überqueren
//-Reihen. Die Zahl von vergleicht scheint, zwischen N-1 zu schwanken und
// NlogN abhängig von dem Anfangsauftrag aber dem Hauptgrund für
// using es ist hier, dass, anders als qsort, es beständig ist.
Öffentlichkeit leeres shuttlesort (int von [], int zu [], int niedrig, int hoch)
{
wenn (Höhe - niedriges < 2)
{
Rückkehr;
}
int-Mitte = (Tief + hoch) /2;
shuttlesort (zu, von, niedrig, mittlere);
shuttlesort (zu, von, Mitte, hoch);
int p = niedrig;
int q = Mitte;
/* dieses ist eine wahlweise freigestellte Abkürzung; an jedem rekursiven Anruf,
überprüfen, um zu sehen, wenn die Elemente in dieser Teilmenge bereits sind
bestellt. Wenn ja sind keine weiteren Vergleiche erforderlich;
Vor-kleiden kann gerade kopiert werden. Die Reihe muss eher kopiert werden
als zugewiesene anders Schwesteranrufe in der Rekursion konnte
ein sinc verlassen. Wenn die Zahl Elementen drei sie ist
werden verteilt, damit der erste Satz, [niedrig, mittler), ein hat
Element und und die Sekunde, [mittler, hoch), hat zwei. Wir überspringen
Optimierung, wenn die Zahl Elementen drei oder kleiner wie ist
die ersten vergleichen im normalen Mischen produzieren die selben
Reihenfolge von Schritten. Diese Optimierung scheint, lohnend zu sein
für teilweise bestellte Listen aber etwas Analyse ist erforderlich
herausfinden, wie die Leistung auf Nlog abfällt (N) als die Initiale
Auftrag vermindert - er kann sehr schnell fallen. *
/*
wenn (Höhe - niedriges >= 4 && vergleichen (von [middle-1], von [Mitte]) <= 0)
{
für (int I = niedrig; I < hoch; i++)
{
zu [i] = von [i];
}
Rückkehr;
}
**/
Normales Mischen //-A.
für (int I = niedrig; I < hoch; i++)
{
wenn (q >= hoch || (p < mittleres && vergleichen (von [p], von [q]) <= 0))
{
zu [i] = von [p++];
}
sonst
{
zu [i] = von [q++];
}
}
}
Öffentlichkeit leeres mysort ()
{
für (int I = 0; I < indexes.length - 1; i++)
{
für (int J = i + 1; J < indexes.length; j++)
{
wenn (steigend)
{
wenn (vergleichen (Indizes [i], Indizes [J]) < 0)
{
austauschen (i, j);
}
}
sonst
{
wenn (vergleichen (Indizes [i], Indizes [J]) > 0)
{
austauschen (i, j);
}
}
}
}
}
Öffentlichkeitslückentauschen (int I, int j)
{
int tmp = Indizes [i];
Indizes [i] = Indizes [J];
Indizes [J] = tmp;
}
Öffentlichkeit int [] getIndex ()
{
Rückholindizes;
}
// das Diagramm beeinflußt nur den Inhalt der Datenfolgen.
//-Durchlauf alle Anträge zu diesen Reihen durch die abbildenreihe: „registriert“.
allgemeines Gegenstand getValueAt (int aRow, int aColumn)
{
checkModel ();
Rückholmodel.getValueAt (Indizes [aRow], aColumn);
}
Öffentlichkeit leeres setValueAt (Gegenstand aValue, int aRow, int aColumn)
{
checkModel ();
model.setValueAt (aValue, Indizes [aRow], aColumn);
}
Öffentlichkeit leeres sortByColumn (int-Spalte)
{
sortByColumn (Spalte, richten aus);
}
Öffentlichkeit leeres sortByColumn (int-Spalte, Boolesches Steigen)
{
sortingColumn = Spalte;
this.ascending = steigend;
sortingColumns.removeAllElements ();
sortingColumns.addElement (neue ganze Zahl (Spalte));
Art (diese);
super.tableChanged (neues TableModelEvent (dieses));
}
// dort ist nirgendwo sonst, dieses zu setzen.
// fügen einen Mäusezuhörer dem Tabelle hinzu, um eine Tabellenart auszulösen
//, wenn eine Spaltenüberschrift im JTable geklickt wird.
Öffentlichkeit leeres addMouseListenerToHeaderInTable (JTable Tabelle)
{
abschließender TableSorter Sorter = dieses;
abschließendes JTable tableView = Tabelle;
tableView.setColumnSelectionAllowed (falsch);
MouseAdapter listMouseListener = neues MouseAdapter ()
{
Öffentlichkeitslücke mouseClicked (MouseEvent e)
{
tableView.setCursor (neues java.awt. Cursor (java.awt. Cursor.WAIT_CURSOR));
tableView.getTableHeader () .setCursor (neues java.awt. Cursor (java.awt. Cursor.WAIT_CURSOR));
TableColumnModel columnModel = tableView.getColumnModel ();
int viewColumn = columnModel.getColumnIndexAtX (e.getX ());
int-Spalte = tableView.convertColumnIndexToModel (viewColumn);
//if (e.getClickCount () == 1 && Spalte! = -1)
wenn (e.getClickCount () >= 1 && Spalte! = -1)
{
int shiftPressed = e.getModifiers () &InputEvent.SHIFT_MASK;
steigendes //boolean = (shiftPressed == 0);
Boolesches Steigen = (e.getClickCount () == 1);
Boolesche editable = richten aus;
die Abänderung = richten aus;
wenn (tableView.getModel () instanceof DataTableModel)
{
editable = ((DataTableModel) tableView.getModel ()).getCellEditable ();
((DataTableModel) tableView.getModel ()).setCellEditable (zutreffend);
}
// holen Daten vom Modell zurück
Einwenden [] [] rowData = neuer Gegenstand [tableView.getModel () .getRowCount ()][tableView.getModel () .getColumnCount ()];
für (int I = 0; I < tableView.getModel () .getRowCount (); i++)
{
für (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 (Spalte, steigend);
// stellen jetzt Daten im Modell durch Index ein
für (int I = 0; I < tableView.getModel () .getRowCount (); i++)
{
für (int J = 0; J < tableView.getModel () .getColumnCount (); j++)
{
tableView.getModel () .setValueAt (rowData [Indizes [i]] [J], i, j);
}
wenn (Indizes [i] == selectedRow)
{
Versuch
{
tableView.setRowSelectionInterval (i, i);
}
Fang (IllegalArgumentException Ausn.)
{
// tun nichts
}
}
}
wenn (tableView.getModel () instanceof DataTableModel)
{
((DataTableModel) tableView.getModel ()).setCellEditable (editable);
}
Abänderung = falsch;
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 ());
}
geschütztes TableCellRenderer createDefaultRenderer ()
{
DefaultTableCellRenderer Aufkleber =
neues DefaultTableCellRenderer ()
{
allgemeines TeilgetTableCellRendererComponent (JTable Tabelle,
Wert, Boolesches isSelected, Boolesches hasFocus einwenden,
int-Reihe, int-Spalte)
{
wenn (Tabelle! = Null)
{
JTableHeader Überschrift = table.getTableHeader ();
wenn (Überschrift! = Null)
{
setForeground (header.getForeground ());
setBackground (header.getBackground ());
setFont (header.getFont ());
wenn (Spalte == sortingColumn)
{
wenn (steigend)
{
Versuch
{
//setIcon (neues ImageIcon (getClass () .getResource (
// " /resources/arrowDown.gif ")));
setIcon (TableHeaderIcon.getArrowDown ());
}
Fang (Ausnahme Ausn.)
{
}
} sonst
{
Versuch
{
//setIcon (neues ImageIcon (getClass () .getResource (
// " /resources/arrowUp.gif ")));
setIcon (TableHeaderIcon.getArrowUp ());
}
Fang (Ausnahme Ausn.)
{
}
}
} sonst
{
setIcon (Null);
}
}
}
setText ((Wert == Null)? "": value.toString ());
setBorder (UIManager.getBorder („TableHeader.cellBorder“));
dieses zurückbringen;
}
};
label.setHorizontalAlignment (JLabel.CENTER);
label.setHorizontalTextPosition (SwingConstants.LEFT);
Rückholaufkleber;
}
}
|
