diff options
Diffstat (limited to 'client/CalendarTableModel.java')
| -rw-r--r-- | client/CalendarTableModel.java | 434 |
1 files changed, 434 insertions, 0 deletions
diff --git a/client/CalendarTableModel.java b/client/CalendarTableModel.java new file mode 100644 index 0000000..146c20b --- /dev/null +++ b/client/CalendarTableModel.java @@ -0,0 +1,434 @@ +package client; + +import javax.swing.table.*; +import javax.swing.*; +import java.util.*; +import shared.*; +import shared.remotecall.*; + +/** + * This class defined the table model of the JTable of the main calendar client window. All table + * data and most of the table actions, like sorting or updating the content, go trough this class. + * @author buetow + * + */ +public final class CalendarTableModel extends AbstractTableModel { + public static final String NUM_HEADER = "#"; + public static final String DATE_HEADER = "Date"; + public static final String CATEGORY_HEADER = "Category"; + public static final String DESCRIPTION_HEADER = "Description"; + public static final String PLACE_HEADER = "Place"; + + private static final int iEnumLength = Config.getStringValue("client_max_events").length(); + private static final long serialVersionUID = 1L; + private static final int iCols = 5; // Num of columns never changes! + private int iRows = 0; + private Vector vecEvents; + private Comparator lastSortComparator = null; + private JTable jTable; + + /** + * Simple constructor, creates a calendar table model to be used with the JTable of the netcalendar client main window. + * @param jTable Specifies the JTable object of this table model. + */ + public CalendarTableModel(JTable jTable) { + this.jTable = jTable; + } + + /** + * This method returns the number of columns of the JTable. + * @return Returns the number of columns of the JTable. + */ + public int getColumnCount() { + return iCols; + } + + /** + * This method retuns the number of rows of the JTable. + * @return Returns the number of rows of the JTable. + */ + public int getRowCount() { + return iRows; + } + + /** + * This method sets the number of rows of the JTable. + * @param iRows Specifies the number of rows of the JTable. + */ + public void setRowCount(int iRows) { + this.iRows = iRows; + } + + /** + * This method checks if a cell is editable or not. + * @param iRow Specifies the tables row. + * @param iCol Specifies the tables column. + * @return Returns true if the cell is editable. Else, false will be returned. + */ + public boolean isCellEditable(int iRow, int iCol) { + if (iCol > 1) + return true; + + return false; + } + + /** + * Gets a specific table value + * @param iRow Specifies the tables row + * @param iCol Specifies the tables column + * @return Returns the object at (row,column) + */ + public Object getValueAt(int iRow, int iCol) { + CalendarEvent calendarEvent = (CalendarEvent) vecEvents.get(iRow); + + switch (iCol) { + case 0: String sEnum = "" + (iRow + 1); + while (sEnum.length() < iEnumLength) + sEnum = "0" + sEnum; + return sEnum; + case 1: return calendarEvent.getDate(); + case 2: return calendarEvent.getDescription(); + case 3: return calendarEvent.getCategoryName(); + case 4: return calendarEvent.getPlace(); + } + + return "N/A"; + } + + /** + * This function updates the data of the JTable. + * @param object Specifies the new value. + * @param iRow Specifies the row of the cell to be updated. + * @param iCol Specifies the column of the cell to be updated. + */ + public void setValueAt(Object object, int iRow, int iCol) { + CalendarEvent calendarEvent = (CalendarEvent) vecEvents.get(iRow); + + switch (iCol) { + case 2: calendarEvent.setDescription((String) object); + break; + case 3: calendarEvent.setCategoryName((String) object); + break; + case 4: calendarEvent.setPlace((String) object); + break; + default: return; + } + + runLastSorter(); + jTable.updateUI(); + + ClientRequest clientRequest = new ClientRequest(ClientRequest.MODIFY_EVENT); + clientRequest.setEvent(calendarEvent); + ServerRequester.sendClientRequest(clientRequest); + } + + /** + * This method returns the class types of a specific table column. + * @param iCol Specifies the column index to get the class type for. + * @return Returns the class type of the specified column. + */ + public Class getColumnClass(int iCol) { + switch (iCol) { + case 0: return String.class; + case 1: return MyDate.class; + case 2: return String.class; + case 3: return String.class; + case 4: return String.class; + } + + return String.class; + } + + /** + * This method returns the column header of a specific table column. + * @param iCol Specifies the column index to get the column header for. + * @return Returns the header string of the specified column. + */ + public String getColumnName(int iCol) { + switch (iCol) { + case 0: return NUM_HEADER; + case 1: return DATE_HEADER; + case 2: return DESCRIPTION_HEADER; + case 3: return CATEGORY_HEADER; + case 4: return PLACE_HEADER; + } + + return "N/A"; + } + + /** + * This method returns the calendar event which belongs to a specific table row + * @param iRow Specifies the table row index + * @return Returns the calendar event + */ + public CalendarEvent getEvent(int iRow) { + return (CalendarEvent) vecEvents.get(iRow); + } + + /** + * This method updates all the value objects (calendar events) of the table. + * @param vecEvents Specifies the vector of the events to be used. + */ + public void setEvents(Vector vecEvents) { + if (vecEvents == null) + return; + + this.vecEvents = vecEvents; + setRowCount(vecEvents.size()); + + runLastSorter(); + } + + /** + * This method sorts the data again using the last sorting method being used. + */ + private void runLastSorter() { + if (lastSortComparator == null) { + sortByDate(); + + } else { + Collections.sort(vecEvents, lastSortComparator); + jTable.updateUI(); + } + } + + /** + * Sorts the table content by a specified table column. + * @param iCol Specifies the table column to sort against. + */ + public void sortByCol(int iCol) { + switch (iCol) { + case 0: + case 1: sortByDate(); + break; + case 2: sortByDescription(); + break; + case 3: sortByCategory(); + break; + case 4: sortByPlace(); + break; + } + } + + /** + * Reverse sorts the table content by a specified table column. + * @param iCol Specifies the table column to reverse sort against. + */ + public void reverseSortByCol(int iCol) { + switch (iCol) { + case 0: + case 1: reverseSortByDate(); + break; + case 2: reverseSortByDescription(); + break; + case 3: reverseSortByCategory(); + break; + case 4: reverseSortByPlace(); + break; + } + } + + /** + * Sorts the table content by their IDs. + */ + public void sortByID() { + Main.statusMessage("Sorting by ID..."); + + lastSortComparator = new Comparator() { + public int compare(Object objectA, Object objectB) { + int i = ((CalendarEvent) objectA).getID(); + int j = ((CalendarEvent) objectB).getID(); + if (i == j) + return 0; + else if (i < j) + return -1; + else + return 1; + } + public boolean equals(Object object) { return false; } + }; + Collections.sort(vecEvents, lastSortComparator); + jTable.updateUI(); + + Main.statusMessage("Sorting by date done"); + } + + /** + * Sorts the table content by their dates. + */ + public void sortByDate() { + Main.statusMessage("Sorting by date..."); + + lastSortComparator = new Comparator() { + public int compare(Object objectA, Object objectB) { + long l = ((CalendarEvent) objectA).getDate().getTime(); + long m = ((CalendarEvent) objectB).getDate().getTime(); + if (l == m) + return 0; + else if (l < m) + return -1; + else + return 1; + } + public boolean equals(Object object) { return false; } + }; + Collections.sort(vecEvents, lastSortComparator); + jTable.updateUI(); + + Main.statusMessage("Sorting by date done"); + } + + /** + * Sorts the table content by their category names. + */ + public void sortByCategory() { + Main.statusMessage("Sorting by category..."); + lastSortComparator = new Comparator() { + public int compare(Object objectA, Object objectB) { + CalendarEvent eventA = (CalendarEvent) objectA; + CalendarEvent eventB = (CalendarEvent) objectB; + return eventA.getCategoryName().compareTo(eventB.getCategoryName()); + } + public boolean equals(Object object) { return false; } + }; + Collections.sort(vecEvents, lastSortComparator); + jTable.updateUI(); + Main.statusMessage("Sorting by category done"); + } + + /** + * Sorts the table content by their description texts. + */ + public void sortByDescription() { + Main.statusMessage("Sorting by description..."); + lastSortComparator = new Comparator() { + public int compare(Object objectA, Object objectB) { + CalendarEvent eventA = (CalendarEvent) objectA; + CalendarEvent eventB = (CalendarEvent) objectB; + return eventA.getDescription().compareTo(eventB.getDescription()); + } + public boolean equals(Object object) { return false; } + }; + Collections.sort(vecEvents, lastSortComparator); + jTable.updateUI(); + Main.statusMessage("Sorting by description done"); + } + + /** + * Sorts the table content by their places. + */ + public void sortByPlace() { + Main.statusMessage("Sorting by place..."); + lastSortComparator = new Comparator() { + public int compare(Object objectA, Object objectB) { + CalendarEvent eventA = (CalendarEvent) objectA; + CalendarEvent eventB = (CalendarEvent) objectB; + return eventA.getPlace().compareTo(eventB.getPlace()); + } + public boolean equals(Object object) { return false; } + }; + Collections.sort(vecEvents, lastSortComparator); + jTable.updateUI(); + Main.statusMessage("Sorting by place done"); + } + + /** + * Reverse sorts the table content by their IDs. + */ + public void reverseSortByID() { + Main.statusMessage("Reverse sorting by date..."); + lastSortComparator = new Comparator() { + public int compare(Object objectA, Object objectB) { + long i = ((CalendarEvent) objectA).getID(); + long j = ((CalendarEvent) objectB).getID(); + if (i == j) + return 0; + else if (i > j) + return -1; + else + return 1; + } + public boolean equals(Object object) { return false; } + }; + Collections.sort(vecEvents, lastSortComparator); + jTable.updateUI(); + Main.statusMessage("Reverse sorting by date done"); + } + + /** + * Reverse sorts the table content by their dates. + */ + public void reverseSortByDate() { + Main.statusMessage("Reverse sorting by date..."); + lastSortComparator = new Comparator() { + public int compare(Object objectA, Object objectB) { + long l = ((CalendarEvent) objectA).getDate().getTime(); + long m = ((CalendarEvent) objectB).getDate().getTime(); + if (l == m) + return 0; + else if (l > m) + return -1; + else + return 1; + } + public boolean equals(Object object) { return false; } + }; + Collections.sort(vecEvents, lastSortComparator); + jTable.updateUI(); + Main.statusMessage("Reverse sorting by date done"); + } + + /** + * Reverse sorts the table content by their category names. + */ + public void reverseSortByCategory() { + Main.statusMessage("Reverse sorting by category..."); + lastSortComparator = new Comparator() { + public int compare(Object objectA, Object objectB) { + CalendarEvent eventA = (CalendarEvent) objectA; + CalendarEvent eventB = (CalendarEvent) objectB; + return eventB.getCategoryName().compareTo(eventA.getCategoryName()); + } + public boolean equals(Object object) { return false; } + }; + Collections.sort(vecEvents, lastSortComparator); + jTable.updateUI(); + Main.statusMessage("Reverse sorting by category done"); + } + + /** + * Reverse sorts the table content by their description texts. + */ + public void reverseSortByDescription() { + Main.statusMessage("Reverse sorting by description..."); + lastSortComparator = new Comparator() { + public int compare(Object objectA, Object objectB) { + CalendarEvent eventA = (CalendarEvent) objectA; + CalendarEvent eventB = (CalendarEvent) objectB; + return eventB.getDescription().compareTo(eventA.getDescription()); + } + public boolean equals(Object object) { return false; } + }; + Collections.sort(vecEvents, lastSortComparator); + jTable.updateUI(); + Main.statusMessage("Reverse sorting by description done!"); + } + + /** + * Reverse sorts the table content by their places. + */ + public void reverseSortByPlace() { + Main.statusMessage("Reverse sorting by place..."); + lastSortComparator = new Comparator() { + public int compare(Object objectA, Object objectB) { + CalendarEvent eventA = (CalendarEvent) objectA; + CalendarEvent eventB = (CalendarEvent) objectB; + return eventB.getPlace().compareTo(eventA.getPlace()); + } + public boolean equals(Object object) { return false; } + }; + Collections.sort(vecEvents, lastSortComparator); + jTable.updateUI(); + Main.statusMessage("Reverse sorting by place done"); + } +} |