WebSVN - OpenConcerto - Diff - Rev 73 and 156 - /trunk/OpenConcerto/src/org/openconcerto/ui/state/JTableStateManager.java

 import org.openconcerto.ui.Log;
 import org.openconcerto.ui.TM;
 import org.openconcerto.ui.table.XTableColumnModel;
 import org.openconcerto.utils.ExceptionHandler;
 import org.openconcerto.utils.TableSorter;
+import org.openconcerto.utils.TableSorter.Directive;
 import java.io.File;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.logging.Level;
 import javax.swing.JTable;
 import javax.swing.event.AncestorEvent;
 import javax.swing.event.AncestorListener;
 import javax.swing.table.TableColumn;
 import javax.swing.table.TableColumnModel;
 import javax.swing.table.TableModel;
+import javax.xml.XMLConstants;
 import javax.xml.parsers.DocumentBuilder;
 import javax.xml.parsers.DocumentBuilderFactory;
 import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.transform.OutputKeys;
 import javax.xml.transform.Transformer;
 import javax.xml.transform.TransformerException;
 import javax.xml.transform.TransformerFactory;
 import javax.xml.transform.dom.DOMSource;
 import javax.xml.transform.stream.StreamResult;
  * @author Sylvain
  */
 public class JTableStateManager extends ListenerXMLStateManager<JTable, AncestorListener> {
     private static final String VERSION = "20100810";
+    private static final String IDENTIFIER_ATTR = "identifier";
+    private static final String MODEL_INDEX_ATTR = "modelIndex";
+    private static final String SORT_ATTR = "sort";
     public JTableStateManager(JTable table) {
         this(table, null);
+    }
     @Override
     protected AncestorListener createListener() {
         return new AncestorListener() {
             public void ancestorAdded(AncestorEvent event) {
+                // nothing
+            }
             public void ancestorMoved(AncestorEvent event) {
+                // nothing
+            }
             public void ancestorRemoved(AncestorEvent event) {
                 try {
                     saveState();
         final Element elem = doc.createElement("liste");
         elem.setAttribute("version", VERSION);
         doc.appendChild(elem);
         final TableColumnModel model = this.getSrc().getColumnModel();
+        final XTableColumnModel visibilityModel = model instanceof XTableColumnModel ? (XTableColumnModel) model : null;
         final TableModel tModel = this.getSrc().getModel();
-        if (model instanceof XTableColumnModel) {
+        if (visibilityModel != null) {
-            final XTableColumnModel visibilityModel = (XTableColumnModel) model;
             for (final TableColumn col : visibilityModel.getColumns(false)) {
                 writeCol(elem, col, tModel).setAttribute("visible", String.valueOf(visibilityModel.isColumnVisible(col)));
+            }
         } else {
             final int nCol = this.getSrc().getColumnCount();
                 final TableColumn col = model.getColumn(i);
                 writeCol(elem, col, tModel);
+            }
+        }
+        if (tModel instanceof TableSorter) {
+            TableSorter sorter = (TableSorter) tModel;
+            final Element sortingColsElem = doc.createElement("sortingColumns");
+            elem.appendChild(sortingColsElem);
+            for (final Directive d : sorter.getSortingColumns()) {
+                final Element colElem = doc.createElement("sortCol");
+                sortingColsElem.appendChild(colElem);
+                final TableColumn col;
+                if (visibilityModel != null) {
+                    col = visibilityModel.getColumnByModelIndex(d.getColumn());
+                } else {
+                    col = model.getColumn(getSrc().convertColumnIndexToView(d.getColumn()));
+                }
+                colElem.setAttribute(IDENTIFIER_ATTR, String.valueOf(col.getIdentifier()));
+                final int status = d.getDirection();
+                setSortAttribute(colElem, status);
+            }
+        }
         // Use a Transformer for output
         final TransformerFactory tFactory = TransformerFactory.newInstance();
         try {
+            tFactory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
             final Transformer transformer = tFactory.newTransformer();
+            transformer.setOutputProperty(OutputKeys.INDENT, "yes");
             transformer.transform(new DOMSource(elem), new StreamResult(out));
         } catch (TransformerException e) {
             throw new IOException("Couldn't output " + doc, e);
+        }
+    }
         int max = col.getMaxWidth();
         int width = col.getWidth();
         res.setAttribute("min", String.valueOf(min));
         res.setAttribute("max", String.valueOf(max));
         res.setAttribute("width", String.valueOf(width));
-        res.setAttribute("identifier", String.valueOf(col.getIdentifier()));
+        res.setAttribute(IDENTIFIER_ATTR, String.valueOf(col.getIdentifier()));
-        res.setAttribute("modelIndex", String.valueOf(col.getModelIndex()));
+        res.setAttribute(MODEL_INDEX_ATTR, String.valueOf(col.getModelIndex()));
-        if (tModel instanceof TableSorter) {
+        return res;
-            TableSorter sorter = (TableSorter) tModel;
+    }
-            int status = sorter.getSortingStatus(col.getModelIndex());
+    protected final void setSortAttribute(final Element res, final int status) {
-            if (status == TableSorter.ASCENDING) {
+        if (status == TableSorter.ASCENDING) {
-                res.setAttribute("sort", "ascending");
+            res.setAttribute(SORT_ATTR, "ascending");
-            } else if (status == TableSorter.DESCENDING) {
+        } else if (status == TableSorter.DESCENDING) {
-                res.setAttribute("sort", "descending");
+            res.setAttribute(SORT_ATTR, "descending");
+        }
+    }
+    protected final int getSortAttribute(final NamedNodeMap attrs) {
+        final Node sortNode = attrs.getNamedItem(SORT_ATTR);
+        if (sortNode != null) {
+            final String sort = sortNode.getNodeValue();
+            if (sort.equals("ascending")) {
+                return TableSorter.ASCENDING;
+            } else if (sort.equals("descending")) {
+                return TableSorter.DESCENDING;
-        return res;
+            } else {
+                Log.get().log(Level.INFO, "ignore unknown sort value : {0}", sort);
+            }
+        }
+        return TableSorter.NOT_SORTED;
+    }
     /**
      * Met les colonnes comme spécifier dans <code>file</code>. Ne fait rien si <code>file</code>
      * n'existe pas.
                 for (int i = 0; i < colsCount; i++) {
                     visibilityModel.setColumnVisible(visibilityModel.getColumn(i, false), true);
+                }
+            }
             final TableModel tModel = this.getSrc().getModel();
-            final List<TableColumn> invisibleCols = new ArrayList<TableColumn>();
+            final List<TableColumn> invisibleCols = new ArrayList<>();
             for (int i = 0; i < colsCount; i++) {
                 final NamedNodeMap attrs = listOfCol.item(i).getAttributes();
                 // index
-                final int modelIndex = Integer.parseInt(attrs.getNamedItem("modelIndex").getNodeValue());
+                final int modelIndex = Integer.parseInt(attrs.getNamedItem(MODEL_INDEX_ATTR).getNodeValue());
                 // move from the current index to the final view index
                 model.moveColumn(this.getSrc().convertColumnIndexToView(modelIndex), i);
                 final TableColumn modelCol = model.getColumn(i);
                 // don't call setColumnVisible() now since it removes the column and this offsets
                 // indexes, only deal will invisible since by now all columns are visible
                 if (visible != null && !Boolean.parseBoolean(visible.getNodeValue()))
                     invisibleCols.add(modelCol);
+                // Better not to restore sorting at all, than to restore wrong sorting. So remove
+                // the code that was here since it didn't restore the order of the sorting columns
+                // (e.g. first sort by country, then by age).
+            }
-                // Sorting
+            // Sorting
+            final NodeList listOfSortCol = doc.getElementsByTagName("sortCol");
+            final int sortColCount = listOfSortCol.getLength();
+            if (tModel instanceof TableSorter && sortColCount > 0) {
+                final List<Directive> sortingCols = new ArrayList<>();
+                for (int i = 0; i < sortColCount; i++) {
+                    final NamedNodeMap attrs = listOfSortCol.item(i).getAttributes();
-                if (tModel instanceof TableSorter) {
-                    final TableSorter sorter = (TableSorter) tModel;
+                    final String colID = attrs.getNamedItem(IDENTIFIER_ATTR).getNodeValue();
-                    final Node sortNode = attrs.getNamedItem("sort");
+                    final int colIndex;
-                    if (sortNode != null) {
+                    try {
-                        String sort = sortNode.getNodeValue();
+                        colIndex = model.getColumnIndex(colID);
-                        if (sort != null) {
+                    } catch (Exception e) {
-                            if (sort.equals("ascending")) {
+                        Log.get().log(Level.INFO, "ignore unknown identifier : " + colID, e);
-                                sorter.setSortingStatus(modelIndex, TableSorter.ASCENDING);
+                        continue;
-                            } else if (sort.equals("descending")) {
+                    }
-                                sorter.setSortingStatus(modelIndex, TableSorter.DESCENDING);
+                    final int modelIndex = model.getColumn(colIndex).getModelIndex();
-                            } else {
+                    final int direction = getSortAttribute(attrs);
-                                sorter.setSortingStatus(modelIndex, TableSorter.NOT_SORTED);
+                    if (direction == TableSorter.NOT_SORTED) {
-                            }
+                        Log.get().info("ignore sort value for column " + colID);
-                        }
+                        continue;
+                    }
+                    sortingCols.add(new Directive(modelIndex, direction));
+                }
+                ((TableSorter) tModel).setSortingColumns(sortingCols);
+            }
             if (visibilityModel != null) {
                 for (final TableColumn toRm : invisibleCols) {
                     visibilityModel.setColumnVisible(toRm, false);
+                }
     // be wrongfully restored in the first step.
     private boolean checkIdentifiers(NodeList listOfCol, List<TableColumn> uiCols) {
         final int colsCount = listOfCol.getLength();
         for (int i = 0; i < colsCount; i++) {
             final NamedNodeMap attrs = listOfCol.item(i).getAttributes();
-            final int modelIndex = Integer.parseInt(attrs.getNamedItem("modelIndex").getNodeValue());
+            final int modelIndex = Integer.parseInt(attrs.getNamedItem(MODEL_INDEX_ATTR).getNodeValue());
-            final String xmlID = attrs.getNamedItem("identifier").getNodeValue();
+            final String xmlID = attrs.getNamedItem(IDENTIFIER_ATTR).getNodeValue();
             final String uiID = String.valueOf(uiCols.get(modelIndex).getIdentifier());
             if (!uiID.equals(xmlID))
                 return false;
+        }
         return true;

Dépôt officiel du code source de l'ERP OpenConcerto

svn://code.openconcerto.org/openconcerto

(root)/trunk/OpenConcerto/src/org/openconcerto/ui/state/JTableStateManager.java - Rev 73 → 156