Changeset 23433 for main/trunk/gli/src/org/greenstone/gatherer/collection/CollectionTreeNode.java

Timestamp:

2010-12-09T22:27:33+13:00 (13 years ago)

Author:

ak19

Message:

GLI now has a gs.FilenameEncoding metadata field which appears like all the others in GLI's EnrichPane, but is unique in that this metadata (once set, changed or removed) must be applied to the affected filenames in the Collection Tree. More importantly, the changes made for this are to allow GLI's java code to interact with the recent changes to Perl where strings were made unicode-aware (for proper regex matching) but which required other changes elsewhere. To still support filenames with different encodings Perl used URL encoded versions of filenames representing characters' code point values in URL encoding. This required that GLI write out URL encoded filenames to the metadata.xml files that are associated with each folder level of a collection, so that Perl can read them. In this way, they can both speak of the same filenames. Only works on unicode 16 (such as latin-1), non-UTF8 systems. The latter is a requirement since Java uses the filesystem encoding from startup. If it is UTF8, non-recognised characters are replaced by the invalid char for UTF8. This process being destructive, we can't get the original filenames' bytecodes back. The changes made to GLI will work on Windows which is UTF-16 (windows codepage 1252), presumably also Macs (some kind of UTF-16) and also works on Native Latin 1 Linux systems. UTF-8 Linux systems need to be reconfigured to Native Latin-1, or if not installed, an administrator can install it easily.

File:

• main/trunk/gli/src/org/greenstone/gatherer/collection/CollectionTreeNode.java (modified) (3 diffs)

main/trunk/gli/src/org/greenstone/gatherer/collection/CollectionTreeNode.java

@@ -32 +32 @@
 import org.greenstone.gatherer.cdm.CollectionDesignManager;
 import org.greenstone.gatherer.file.FileNode;
+import org.greenstone.gatherer.metadata.FilenameEncoding;
 import org.greenstone.gatherer.util.JarTools;
 import java.util.Set;
 import java.util.Iterator;
-import java.nio.charset.Charset;
 
 
@@ -54 +54 @@
     {
     super(file);
+        // the super call will additionally call calcDisplayString() which will get any
+        // applicable the filename encoding and apply it to the file's name for display.
 
     this.is_explodable = CollectionDesignManager.plugin_manager.isFileExplodable(file);
@@ -81 +83 @@
     return is_srcreplaceable;
     }
+
+    /** This method returns a string representation of the filenodes in the 
+    * <i>Collection</i> Tree, that can then be displayed in the tree. If the 
+    * filename encoding is specified as metadata with the file, then this
+    * method will apply that to the filename's bytes to get the displayName.
+    */
+    protected String calcDisplayString() {      
+        // metadata.xml files in collections don't get displayed anyway
+        if(file.getName().equals("metadata.xml")) { 
+            return super.calcDisplayString();
+        }
+        
+        if(!FilenameEncoding.MULTIPLE_FILENAME_ENCODINGS_SUPPORTED) {
+            return super.calcDisplayString();
+        }
+
+        // Else: try to encode the display string from the 
+        // file_to_encoding map. If that fails, just use the locale 
+        String displayName = null;
+        String urlEncodedPath = getURLEncodedFilePath();
+        String encoding = FilenameEncoding.findFilenameEncoding(file, urlEncodedPath, false);
+
+        // if it isn't the same as the current encoding already applied, reapply
+        // it which will set the filenameEncoding again as well
+        if(!encoding.equals(getFilenameEncoding())) {
+            displayName = reencodeDisplayName(encoding); // may return null
+        }
+        
+        if(displayName == null) {
+            if(FilenameEncoding.DEBUGGING) {
+                displayName = getURLEncodedFileName(); 
+            } else {
+                displayName = super.calcDisplayString();
+            }
+        }
+        
+        return displayName;
+    }
+
+    /** Call this if the filename encoding has changed and needs to be 
+    * recalculated and re-applied to the filename. This is only for display,
+    * so it only gets applied to the urlEncodedFileName (not urlEncodedFilePath). 
+    * Note that the filenameEncoding may not be the same as the given encoding
+    * at the end of this method (in case it was a charset alias of the encoding). 
+    * This method both sets and returns the displayFileName member variable. 
+    * @return the reencoded display name, if the encoding was a recognised alias
+    * in which case the filenameEncoding will store the canonical name.  */
+    public String reencodeDisplayName(String encoding) {
+        if(!FilenameEncoding.MULTIPLE_FILENAME_ENCODINGS_SUPPORTED) {
+            return displayFileName; // may still be null
+        }
+
+        filenameEncoding = encoding; // clear previous value
+
+        if(filenameEncoding.equals("")) {
+            displayFileName = super.calcDisplayString(); // *FileNode* calcDisplayString
+            return displayFileName;
+        }
+
+        try{
+            displayFileName = new String(file.getName().getBytes(), filenameEncoding);
+        } catch(Exception e) { 
+            // IllegalCharsetName-, UnsupportedCharset- or UnsupportedEncoding-Exception
+            // Store the unsupported encoding, but display with filesystem (or URL) encoding
+            filenameEncoding = encoding;
+            
+            if(FilenameEncoding.DEBUGGING) {
+                displayFileName = getURLEncodedFileName();
+            } else {
+                displayFileName = super.calcDisplayString(); 
+            }
+        } 
+        return displayFileName;
+    }
+        
+    /** Can call this upon refreshing a FileNode (this CollectionTreeNode). It makes
+    * sure the display names of the visible nodes in the CollectionTree aren't stale */
+    public void refreshDescendantEncodings() {
+        // now recalculate encodings for all visible children
+        
+        // Don't bother with the encoding stuff when multiple filename encodings 
+        // are not supported because the system is UTF-8 (not Native-Latin-1) and 
+        // Java interprets all filename bytes as UTF-8, which destructively 
+        // converts unrecognised characters (for UTF-8) into the invalid character. 
+
+        if(!FilenameEncoding.MULTIPLE_FILENAME_ENCODINGS_SUPPORTED 
+                || child_nodes == null) 
+        {
+            return;
+        }       
+        
+        // get and apply the filename encoding, if any
+        for(int i = 0; i < child_nodes.size(); i++) {
+            CollectionTreeNode child_node = (CollectionTreeNode) child_nodes.get(i);            
+            String urlEncodedPath = child_node.getURLEncodedFilePath();     
+            
+            String encoding = FilenameEncoding.findFilenameEncoding(
+                    child_node.getFile(), urlEncodedPath, false);
+            
+            // if current encoding is different from the existing one, re-apply encoding
+            if(!child_node.getFilenameEncoding().equals(encoding)) {
+            child_node.reencodeDisplayName(encoding);
+            }
+        }
+    }
+    
+    // Unused at present
+    /** Call when the filename encoding of this folder level fileNode has changed
+    * and therefore the filename encodings of the descendant fileNodes have to be
+    * reset (their entries in the file_to_encoding hashmap cleared), so that we know
+    * to recalculate these later.  Call when deleting, moving or renaming col nodes */
+    public void resetDescendantEncodings() {
+        if(FilenameEncoding.MULTIPLE_FILENAME_ENCODINGS_SUPPORTED) {
+            resetDescendantEncodings(this.file, this.getURLEncodedFilePath());
+            
+            // for an actual file/folder delete, want to remove all corresponding 
+            // entries from the hashtable without recalculating any encodings 
+            // (files have been deleted, so no there will be no filenames to display).
+            // So don't do this here: refreshDescendantEncodings();
+            // It's done near the end of FileNode.map().
+        }
+    }
+    
+    // Together with the above, unused at present
+    private static void resetDescendantEncodings(File f, String urlEncodedPath) 
+    {
+        // remove this file f's urlencoded path name from the file_to_encoding Map
+        FilenameEncoding.map.remove(urlEncodedPath);
+            
+        if(f.isDirectory()) {
+            File[] children = f.listFiles();        
+            for(int i = 0; i < children.length; i++) {
+                urlEncodedPath = FilenameEncoding.fileToURLEncoding(children[i]);
+                resetDescendantEncodings(children[i], urlEncodedPath); 
+                        // sets filenameEncoding var
+            }
+        }
+    }
+
 }