| /* |
| ***************************************************************************** |
| * Copyright (C) 2000-2007, International Business Machines Corporation and * |
| * others. All Rights Reserved. * |
| ***************************************************************************** |
| */ |
| package com.ibm.rbm; |
| |
| import java.util.*; |
| import java.io.*; |
| import javax.swing.UIManager; |
| import javax.swing.JOptionPane; |
| |
| import com.ibm.rbm.gui.RBManagerGUI; |
| |
| /** |
| * A utility class to aid in the process of updating the Natural Language Support of Tempus Fugit. |
| * This class scans the directory containing NLS files and checks the various languages found there |
| * for completeness, duplication of entry, and status of translation. The class can be instantiated |
| * through a constructor, or it can be run from the command line. For additional information on the |
| * command line results, see the <CODE>main</CODE> method. |
| * |
| * @author Jared Jackson |
| * @see com.ibm.rbm.RBManager |
| */ |
| public class RBManager { |
| |
| // *** DATA *** |
| private Vector allBundleKeys; // A Vector of Strings with all defined NLS properties |
| private Vector bundles; // A Vector of NLSbundles, one for each language |
| private String currentUser; // The name of the person currently using the editor |
| private String baseClass; // The name of the base class of the active resource bundle |
| private File currentDirectory; |
| |
| // *** CONSTRUCTORS *** |
| |
| // The default constructor is not publicly available |
| private RBManager() { |
| try { |
| // Look and Feel check |
| try { |
| String laf = Preferences.getPreference("lookandfeel"); |
| if (!laf.equals("")) UIManager.setLookAndFeel(laf); |
| } catch (Exception e) { |
| // Ignored |
| } |
| |
| Resources.initBundle(); |
| RBManagerGUI guiFrame = new RBManagerGUI(); |
| if (!Preferences.getPreference("username").equals("")) |
| guiFrame.setUser(Preferences.getPreference("username")); |
| if (!Preferences.getPreference("locale").equals("")) { |
| String localeStr = Preferences.getPreference("locale"); |
| String language = Resources.getLanguage(localeStr); |
| String country = Resources.getCountry(localeStr); |
| String variant = Resources.getVariant(localeStr); |
| if (language == null || language.equals("") || language.length() > 3) language = "en"; |
| if (country == null) country = new String(); |
| if (variant == null) Resources.setLocale(new Locale(language, country)); |
| else Resources.setLocale(new Locale(language, country, variant)); |
| } |
| Resources.initBundle(); |
| guiFrame.initComponents(); |
| guiFrame.setVisible(true); |
| } catch (Exception e) { |
| e.printStackTrace(); |
| } |
| } |
| |
| /** |
| * This constructor creates an entirely blank RBManager and base Bundle. Only the base class name is defined. |
| * All other properties need to be defined. |
| */ |
| |
| public RBManager(String baseClassName) { |
| allBundleKeys = new Vector(); |
| bundles = new Vector(); |
| currentUser = "Unknown"; |
| baseClass = baseClassName; |
| currentDirectory = new File(""); |
| |
| Bundle mainBundle = new Bundle(""); |
| // Create a default group |
| mainBundle.addBundleGroup("Ungrouped Items", "These are resource items that have not been assigned a group"); |
| bundles.addElement(mainBundle); |
| } |
| |
| /** |
| * This is the standard constructor for RBManager. It is constructed from the root of a resource bundle. |
| * In the current implementation, each file is parsed separately starting with the base class file (root). |
| * In this implementation, the lookup keys are represented to the user as they appear in the files. The |
| * translation values however are translated according to the basic rules defined in java.util.Properties. |
| * Thus in the key, the user may see '\"' when in the value it would have been converted to '"'. This |
| * translation is reversed when saving the resource bundle. |
| * @param mainFile The base class file of the resource bundle to be read |
| */ |
| |
| public RBManager(File mainFile) throws FileNotFoundException, IOException { |
| init(); |
| |
| currentDirectory = new File(mainFile.getParent()); |
| |
| String[] encodings; |
| |
| // Initiailize the readers to the main NLS file |
| FileReader fr = new FileReader(mainFile); |
| BufferedReader br = new BufferedReader(fr); |
| |
| // Load the java readable values from the main NLS file; |
| Properties p = new Properties(); |
| p.load(new FileInputStream(mainFile)); |
| |
| // Count the number of language files and set up the encoding and dictionary data |
| int numLanguages = 1; |
| String NLSbaseClass = null; |
| String NLSpostfix = null; |
| |
| if (mainFile.getName().indexOf(".") >= 0) { |
| NLSbaseClass = mainFile.getName().substring(0,mainFile.getName().indexOf(".")); |
| NLSpostfix = ".properties"; |
| } else { |
| NLSbaseClass = mainFile.getName(); |
| NLSpostfix = ""; |
| } |
| |
| baseClass = NLSbaseClass; |
| |
| String filePrefix = mainFile.getName().substring(0,mainFile.getName().lastIndexOf(".")); |
| String filePostfix = mainFile.getName().substring(mainFile.getName().lastIndexOf("."),mainFile.getName().length()); |
| File resDir = currentDirectory; |
| if (resDir != null && resDir.isDirectory()) { |
| String[] temp = resDir.list(); |
| numLanguages = 0; |
| // Count the number of language files |
| for (int i = 0; i < temp.length; i++) { |
| if (temp[i].startsWith(NLSbaseClass) && (temp[i].endsWith(NLSpostfix) |
| || temp[i].endsWith(NLSpostfix.toUpperCase()) || NLSpostfix.equals(""))) { |
| // Starts with the base class name and ends in proper suffix (above) |
| // Base name is followed by . or _ (below) |
| RBManagerGUI.debugMsg("Character is: " + temp[i].charAt(NLSbaseClass.length())); |
| if (temp[i].charAt(NLSbaseClass.length()) == '.' || temp[i].charAt(NLSbaseClass.length()) == '_') |
| numLanguages++; |
| } |
| } |
| // Initialize the bundles and encodings |
| encodings = new String[numLanguages]; |
| |
| int count = 1; |
| for (int i = 0; i < temp.length; i++) { |
| if (temp[i].equals(mainFile.getName())) { |
| encodings[0] = ""; |
| } else if (temp[i].startsWith(NLSbaseClass) && (temp[i].endsWith(NLSpostfix) |
| || temp[i].endsWith(NLSpostfix.toUpperCase()) || NLSpostfix.equals(""))) { |
| if (temp[i].charAt(NLSbaseClass.length()) == '.' || temp[i].charAt(NLSbaseClass.length()) == '_') { |
| encodings[count] = new String(temp[i].substring(filePrefix.length()+1,temp[i].indexOf(filePostfix))); count++; |
| } |
| } |
| } |
| } else { |
| // Initialize the bundles and encodings in case the directory information is not available |
| // In this case, only the main NLS file will be handled |
| encodings = new String[numLanguages]; |
| encodings[0] = new String(""); |
| } // end the count and initialization |
| |
| // Read in the entries from the main file |
| String line; |
| // Set the dictionary for the main file |
| Bundle dict = new Bundle(encodings[0]); |
| bundles.addElement(dict); |
| // Set up the first group in case there are NLS items which were not assigned to a group |
| BundleGroup group = new BundleGroup(dict, "Ungrouped Items"); |
| group.setComment("NLS Items which were not initially assigned to a group"); |
| dict.addBundleGroup(group); |
| BundleItem item = new BundleItem(group,null,null); |
| int count = 0; |
| while ((line = br.readLine()) != null) { |
| // Test to make sure this is a file that was generated by RBManager |
| if (!line.trim().equals("")) count++; |
| if (count == 1 && !line.startsWith("# @file")) { |
| // Not generated by RBManager |
| JOptionPane.showMessageDialog(null, |
| Resources.getTranslation("error_not_rbmanager_format") + "\n" + Resources.getTranslation("error_suggest_import_properties"), |
| Resources.getTranslation("dialog_title_error_not_rbmanager_format"), JOptionPane.ERROR_MESSAGE); |
| throw new FileNotFoundException("Improper format for file: " + mainFile.getName()); |
| } |
| String commentLine = null; |
| // Grab text following the # sign |
| if (line.indexOf("#") >= 0) { |
| commentLine = line.substring(line.indexOf("#")+1,line.length()); |
| line = line.substring(0,line.indexOf("#")); |
| } |
| if (commentLine != null && commentLine.trim().length() > 0) { |
| // Process any information made available in comment '@' information |
| Hashtable descriptors = getDescriptors(null,commentLine); |
| if (descriptors != null) { |
| Object o; |
| // File tags |
| o = descriptors.get("file"); if (o != null) dict.name = ((String) o); |
| o = descriptors.get("fileComment"); if (o != null) dict.comment = ((String) o); |
| o = descriptors.get("fileLanguage"); if (o != null) dict.language = ((String) o); |
| o = descriptors.get("fileCountry"); if (o != null) dict.country = ((String) o); |
| o = descriptors.get("fileVariant"); if (o != null) dict.variant = ((String) o); |
| o = descriptors.get("fileManager"); if (o != null) dict.manager = ((String) o); |
| |
| // Group tags |
| o = descriptors.get("group"); |
| if (o != null) { |
| group = new BundleGroup(dict, (String)o); |
| item.setParentGroup(group); |
| dict.addBundleGroup(group); |
| } |
| o = descriptors.get("groupComment"); if (o != null) group.setComment((String) o); |
| |
| // Item tags |
| o = descriptors.get("comment"); if (o != null) item.setComment((String) o); |
| o = descriptors.get("translated"); if (o != null) item.setTranslated(((String) o).equalsIgnoreCase("true")); |
| o = descriptors.get("creator"); if (o != null) item.setCreator((String) o); |
| o = descriptors.get("modifier"); if (o != null) item.setModifier((String) o); |
| o = descriptors.get("created"); if (o != null) item.setCreatedDate((String) o); |
| o = descriptors.get("modified"); if (o != null) item.setModifiedDate((String) o); |
| |
| // Lookup tags (e.g. {_#_} _description_) |
| Enumeration keys = descriptors.keys(); |
| while (keys.hasMoreElements()) { |
| String tag = (String)keys.nextElement(); |
| if (tag.startsWith("{")) { |
| if (tag.indexOf("}") < 0) continue; |
| String lookup = tag.substring(1,tag.indexOf("}")); |
| item.getLookups().put(lookup, descriptors.get(tag)); |
| } |
| } |
| } |
| } // end check of comment line |
| if (line.trim().length() < 1) continue; |
| |
| // Grab the name and value (translation) from the line |
| int breakpoint = 0; |
| boolean started = false; |
| char array[] = line.toCharArray(); |
| for (int i=0; i < array.length; i++) { |
| if (!started && array[i] != ' ' && array[i] != '\t') started = true; |
| if (started && (array[i] == '=' || array[i] == ':' || array[i] == ' ' || array[i] == '\t')) { |
| breakpoint = i; |
| break; |
| } |
| } |
| String key = String.valueOf(array,0,breakpoint); |
| |
| item.setKey(key); |
| String translation = p.getProperty(key); |
| if (translation == null || translation.equals("")) |
| item.setTranslation(line.substring(line.indexOf("=")+1,line.length()).trim()); |
| else item.setTranslation(translation); |
| |
| dict.addBundleItem(item); |
| item = new BundleItem(group,null,null); |
| } // end while - main NLS file |
| |
| // Now that we have parsed the entire main language file, populate the allNLSKey set with the dictionary keys |
| allBundleKeys = new Vector(); |
| Enumeration keys = ((Bundle)bundles.elementAt(0)).allItems.keys(); |
| while (keys.hasMoreElements()) { |
| allBundleKeys.addElement(keys.nextElement()); |
| } |
| |
| // Now go through all of the other languages |
| for (int i = 1; i < encodings.length; i++) { |
| if (encodings[i].equals("kr")) continue; // I can't handle double byte character sets yet |
| // Try to obtain the new file |
| File tempFile = new File(resDir, NLSbaseClass + "_" + encodings[i] + NLSpostfix); |
| fr = new FileReader(tempFile); |
| br = new BufferedReader(fr); |
| |
| // Try to obtain the java readable properties for the file |
| p = new Properties(); |
| p.load(new FileInputStream(tempFile)); |
| |
| // Set the dictionary for the main file |
| dict = new Bundle(encodings[i]); |
| bundles.addElement(dict); |
| // Set up the first group in case there are NLS items which were not assigned to a group |
| group = new BundleGroup(dict, "Ungrouped Items"); |
| dict.addBundleGroup(group); |
| group.setComment("NLS Items which were not initially assigned to a group"); |
| item = new BundleItem(group,null,null); |
| // Create the rest of the groups |
| while ((line = br.readLine()) != null) { |
| String commentLine = null; |
| // Grab the text following the # sign |
| if (line.indexOf("#") >= 0) { |
| commentLine = line.substring(line.indexOf("#")+1,line.length()); |
| line = line.substring(0,line.indexOf("#")); |
| } |
| if (commentLine != null && commentLine.trim().length() > 0) { |
| // Process any information made available in comment '@' information |
| Hashtable descriptors = getDescriptors(null,commentLine); |
| if (descriptors != null) { |
| Object o; |
| // File tags |
| o = descriptors.get("file"); if (o != null) dict.name = ((String) o); |
| o = descriptors.get("fileComment"); if (o != null) dict.comment = ((String) o); |
| o = descriptors.get("fileLanguage"); if (o != null) dict.language = ((String) o); |
| o = descriptors.get("fileCountry"); if (o != null) dict.country = ((String) o); |
| o = descriptors.get("fileVariant"); if (o != null) dict.variant = ((String) o); |
| o = descriptors.get("fileManager"); if (o != null) dict.manager = ((String) o); |
| |
| // Group tags |
| o = descriptors.get("group"); |
| if (o != null) { |
| group = new BundleGroup(dict, (String)o); |
| item.setParentGroup(group); |
| dict.addBundleGroup(group); |
| } |
| o = descriptors.get("groupComment"); if (o != null) group.setComment((String) o); |
| |
| // Item tags |
| o = descriptors.get("comment"); if (o != null) item.setComment((String) o); |
| o = descriptors.get("translated"); if (o != null) item.setTranslated(((String) o).equalsIgnoreCase("true")); |
| o = descriptors.get("creator"); if (o != null) item.setCreator((String) o); |
| o = descriptors.get("modifier"); if (o != null) item.setModifier((String) o); |
| o = descriptors.get("created"); if (o != null) item.setCreatedDate((String) o); |
| o = descriptors.get("modified"); if (o != null) item.setModifiedDate((String) o); |
| |
| // Lookup tags (e.g. {_#_} _description_) |
| Enumeration descKeys = descriptors.keys(); |
| while (descKeys.hasMoreElements()) { |
| String tag = (String)descKeys.nextElement(); |
| if (tag.startsWith("{")) { |
| if (tag.indexOf("}") < 0) continue; |
| String lookup = tag.substring(1,tag.indexOf("}")); |
| item.getLookups().put(lookup, descriptors.get(tag)); |
| } |
| } |
| } |
| } // end check of comment line |
| if (line.trim().length() < 1) continue; |
| |
| // Grab the name and value (translation) from the line |
| int breakpoint = 0; |
| boolean started = false; |
| char array[] = line.toCharArray(); |
| for (int j=0; j < array.length; j++) { |
| if (!started && array[j] != ' ' && array[j] != '\t') started = true; |
| if (started && (array[j] == '=' || array[j] == ':' || array[j] == ' ' || array[j] == '\t')) { |
| breakpoint = j; |
| break; |
| } |
| } |
| String key = String.valueOf(array,0,breakpoint); |
| item.setKey(key); |
| String translation = p.getProperty(key); |
| if (translation == null || translation.equals("")) |
| item.setTranslation(line.substring(line.indexOf("=")+1,line.length()).trim()); |
| else item.setTranslation(translation); |
| |
| dict.addBundleItem(item); |
| item = new BundleItem(group,null,null); |
| } // end while - next line |
| } // end for looop through languages |
| // Add this opened file to our recent files |
| Preferences.addRecentFilePreference(mainFile.getName(), mainFile.getAbsolutePath()); |
| } // end RBManager() |
| |
| // *** METHODS *** |
| |
| /** |
| * Main |
| */ |
| |
| public static void main(String args[]) { |
| // Make sure the user specified a path |
| if (args.length < 1) { |
| new RBManager(); |
| return; |
| } |
| } // main |
| |
| public String toString() { return baseClass; } |
| |
| /** |
| * Write the contents of the file to the output stream |
| */ |
| |
| public void writeToFile() throws IOException { |
| for (int i = 0; i < bundles.size(); i++) { |
| Bundle bundle = (Bundle)bundles.elementAt(i); |
| File outputFile = new File(currentDirectory, baseClass + |
| ((bundle.encoding == null || bundle.encoding.equals("")) ? "" : "_" + bundle.encoding) + |
| ".properties"); |
| FileWriter fw = new FileWriter(outputFile); |
| bundle.writeContents(fw); |
| fw.flush(); |
| fw.close(); |
| } |
| // In case this is a newly created bundle or the location has changed recently, update the recent files, preference |
| Preferences.addRecentFilePreference(baseClass + ".properties", currentDirectory.getAbsolutePath() + File.separator + |
| baseClass + ".properties"); |
| } |
| |
| /** |
| * Calling this method removes a resource from the resource bundle. This method does not permanently |
| * erase the file containing the resources at this encoding, however any changes or saves that take |
| * place once this file has been removed will not be reflected in this hidden file. To restore the resource, |
| * the bundle will have to be recreated. (This last point may change) |
| */ |
| |
| public void hideResource(String encoding) { |
| for (int i=0; i < bundles.size(); i++) { |
| Bundle bundle = (Bundle)bundles.elementAt(i); |
| if (bundle.encoding.equals(encoding)) { |
| bundles.removeElement(bundle); |
| break; |
| } |
| } |
| } |
| |
| /** |
| * Erases permanently one of the resource files. Be careful about calling this method there is nothing you can do |
| * once a file is erased. |
| */ |
| |
| public void eraseFile(String encoding) throws IOException { |
| for (int i = 0; i < bundles.size(); i++) { |
| Bundle bundle = (Bundle)bundles.elementAt(i); |
| if (!(bundle.encoding.equals(encoding))) continue; |
| File outputFile = new File(currentDirectory, baseClass + |
| ((bundle.encoding == null || bundle.encoding.equals("")) ? "" : "_" + bundle.encoding) + |
| ".properties"); |
| boolean success = outputFile.delete(); |
| if (!success) throw new IOException(Resources.getTranslation("error_deletion_not_possible")); |
| hideResource(encoding); |
| break; |
| } |
| } |
| |
| /** |
| * Writes only one of the resource files to the file system. This file is specified by the encoding parameter |
| */ |
| |
| public void writeToFile(String encoding) throws IOException { |
| for (int i = 0; i < bundles.size(); i++) { |
| Bundle bundle = (Bundle)bundles.elementAt(i); |
| if (bundle.encoding.equals(encoding) || (i==0 && encoding.equals(""))) { |
| File outputFile = new File(currentDirectory, baseClass + |
| ((bundle.encoding == null || bundle.encoding.equals("")) ? "" : "_" + bundle.encoding) + |
| ".properties"); |
| FileWriter fw = new FileWriter(outputFile); |
| bundle.writeContents(fw); |
| fw.flush(); |
| fw.close(); |
| break; |
| } |
| } |
| // In case this is a newly created bundle or the location has changed recently, update the recent files, preference |
| Preferences.addRecentFilePreference(baseClass + ".properties", currentDirectory.getAbsolutePath() + File.separator + |
| baseClass + ".properties"); |
| } |
| |
| /** |
| * Given a BundleItem and some properties to change for that item, this method first checks to make sure the passed |
| * item is valid and if it is, the properties of that item are changed to reflect those passed in as parameters to this |
| * method. |
| * @return true if the BundleItem was valid and updateable, false if otherwise (in this case no changes were made). |
| */ |
| |
| public boolean editItem(BundleItem item, String name, String value, String groupName, String comment, Hashtable lookups) { |
| if (name == null || name.equals("") || groupName == null || groupName.equals("") || item == null) return false; |
| String oldName = item.getKey(); |
| String oldComment = item.getComment(); |
| String oldValue = item.getTranslation(); |
| //String oldGroupName = item.getParentGroup().getName(); |
| // Loop through the bundles |
| for (int i = 0; i < bundles.size(); i++) { |
| Bundle bundle = (Bundle)bundles.elementAt(i); |
| BundleItem oldItem = (BundleItem)bundle.allItems.get(oldName); |
| if (oldItem == null) break; |
| if (!oldName.equals(name)) { |
| // A new key |
| oldItem.setKey(name); |
| bundle.allItems.remove(oldItem); |
| bundle.allItems.put(oldItem.getKey(), oldItem); |
| } |
| if (oldItem.getComment() == null || oldItem.getComment().equals(oldComment)) oldItem.setComment(comment); |
| if (oldItem.getTranslation().equals(oldValue)) oldItem.setTranslation(value); |
| oldItem.setLookups(lookups); |
| if (!oldItem.getParentGroup().getName().equals(groupName)) { |
| // A new group |
| oldItem.getParentGroup().removeBundleItem(oldItem.getKey()); |
| BundleGroup bg = bundle.getBundleGroup(groupName); |
| if (bg == null) bg = bundle.getUngroupedGroup(); |
| oldItem.setParentGroup(bg); |
| bg.addBundleItem(oldItem); |
| } |
| } |
| return true; |
| } |
| |
| /** |
| * Attempts to create a new item in each of the language files. The method first checks the base Resource Bundle |
| * to make sure that the item name does not all ready exist. If it does exist the item is not created. |
| * @param name The unique key of the item |
| * @param value The translation of the item for the base class |
| * @param groupName The group name, should all ready exist in the base class |
| * @param comment An optional comment to be added to the item, can be <CODE>null</CODE> |
| * @return An error response. If the creation was successful <CODE>true</CODE> is returned, if there was an error <CODE>false</CODE> is returned. |
| */ |
| |
| public boolean createItem(String name, String value, String groupName, String comment, Hashtable lookups) { |
| if (name == null || name.equals("") || groupName == null || groupName.equals("")) return false; |
| Bundle mainBundle = (Bundle)bundles.firstElement(); |
| BundleGroup mainGroup = null; |
| if (mainBundle.allItems.containsKey(name)) return false; |
| for (int i=0; i < mainBundle.getGroupCount(); i++) { |
| BundleGroup bg = mainBundle.getBundleGroup(i); |
| if (bg.getName().equals(groupName)) {mainGroup = bg; break;} |
| } |
| if (mainGroup == null) return false; |
| // Add to the base class |
| BundleItem mainItem = new BundleItem(mainGroup, name, value); |
| mainItem.setTranslated(true); |
| mainItem.setCreator(currentUser); |
| mainItem.setModifier(currentUser); |
| mainItem.setComment(comment); |
| mainBundle.allItems.put(name, mainItem); |
| mainGroup.addBundleItem(mainItem); |
| if (lookups != null) mainItem.setLookups(lookups); |
| // Add to the rest of the bundles |
| for (int i=1; i < bundles.size(); i++) { |
| Bundle bundle = (Bundle)bundles.elementAt(i); |
| // Find the group |
| BundleGroup group = null; |
| for (int j=0; j < bundle.getGroupCount(); j++) { |
| BundleGroup bg = bundle.getBundleGroup(j); |
| if (bg.getName().equals(groupName)) {group = bg; break;} |
| } |
| if (group == null) { |
| group = new BundleGroup(bundle, groupName); |
| bundle.addBundleGroup(group); |
| } |
| BundleItem item = new BundleItem(group, name, value); |
| item.setCreator(currentUser); |
| item.setModifier(currentUser); |
| item.setComment(comment); |
| if (lookups != null) item.setLookups(lookups); |
| bundle.allItems.put(name, item); |
| bundle.addUntranslatedItem(item); |
| group.addBundleItem(item); |
| } |
| return true; |
| } |
| |
| /** |
| * Attempts to create a new group in each of the language files. The method first checks the base Resource Bundle |
| * to make sure that the group name does not all ready exist. If it does exist the group is not created. |
| * @param groupName The unique group name to be created |
| * @param groupComment An optional comment to be added to the group, can be <CODE>null</CODE> |
| * @return An error response. If the creation was successful <CODE>true</CODE> is returned, if there was an error <CODE>false</CODE> is returned. |
| */ |
| public boolean createGroup(String groupName, String groupComment) { |
| if (groupName == null || groupName.equals("")) |
| return false; |
| // Check to see if the group exists |
| Bundle mainBundle = (Bundle)bundles.firstElement(); |
| if (mainBundle.hasGroup(groupName)) |
| return false; |
| |
| // Create the group |
| for (int i=0; i < bundles.size(); i++) { |
| Bundle bundle = (Bundle)bundles.elementAt(i); |
| BundleGroup bg = new BundleGroup(bundle, groupName); |
| if (groupComment != null) |
| bg.setComment(groupComment); |
| bundle.addBundleGroup(bg); |
| } |
| return true; |
| } |
| |
| /** |
| * Removes a group and all of the items within that group from the various |
| * Resource Bundles known to the system. This method removes the group from |
| * the protected vector of groups, then removes all items in that group from |
| * the protected vector of untranslated items, and the protected hashtable of |
| * all items. |
| */ |
| |
| public void deleteGroup(String groupName) { |
| if (groupName == null) return; |
| // Loop through all of the bundles; |
| for (int i=0; i < bundles.size(); i++) { |
| Bundle bundle = (Bundle)bundles.elementAt(i); |
| bundle.removeGroup(groupName); |
| } |
| } |
| |
| /** |
| * Remove resource items of the given name from each of the resource bundles that the system |
| * knows about. This works by first removing the item from the protected vector of translated |
| * items, if it is there, and then removing it from the the hashtable of all items, and then |
| * removing it from its respective group. |
| */ |
| |
| public void deleteItem(String itemName) { |
| if (itemName == null) return; |
| // Loop through all of the bundles; |
| for (int i=0; i < bundles.size(); i++) { |
| // Loop through untranslated items |
| Bundle bundle = (Bundle)bundles.elementAt(i); |
| bundle.removeUntranslatedItem(itemName); |
| |
| // Loop through all Items |
| Enumeration items = bundle.allItems.elements(); |
| while(items.hasMoreElements()) { |
| BundleItem item = (BundleItem)items.nextElement(); |
| if (item.getKey().equals(itemName)) { |
| bundle.allItems.remove(item); |
| item.getParentGroup().removeBundleItem(item.getKey()); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Looks through the resources contained in the bundle for a resource of the given encoding. Note that this |
| * search is case sensitive. |
| * @return True if the encoding exists as one of the resource files, false otherwise |
| */ |
| |
| public boolean hasResource(String encoding) { |
| // Check to see if the encoding exists |
| for (int i=0; i < bundles.size(); i++) { |
| Bundle b = (Bundle)bundles.elementAt(i); |
| if (b.encoding.equals(encoding)) return true; |
| } |
| return false; |
| } |
| |
| /** |
| * Attempts to create a new resource file with the given encoding. The method first checks the base Resource Bundle |
| * to make sure that encoding does not all ready exist. If it does exist the resource file is not created. |
| * @param title An optional, quick title for the file, can be <CODE>null</CODE> |
| * @param comment An optional comment to be added to the resource, can be <CODE>null</CODE> |
| * @param manager The name of the person responsible for this resource, can be <CODE>null</CODE> |
| * @param encoding The proper encoding for the resource. Must be of form 'language', 'language_country', or 'language_country_variant' |
| * @param language A more formal name for the language (e.g. 'English', 'Deutsch', etc.), can be <CODE>null</CODE> |
| * @param country A more formal name for the country described by the resource, can be <CODE>null</CODE> |
| * @param variant A more formal name for the variant described by the resource, can be <CODE>null</CODE> |
| * @param copyValues An indication of wether or not to populate the resource with the items in the base class |
| * @return An error response. If the creation was successful <CODE>true</CODE> is returned, if there was an error <CODE>false</CODE> is returned. |
| */ |
| |
| public boolean createResource(String title, String comment, String manager, String encoding, |
| String language, String country, String variant, boolean copyValues) { |
| if (encoding == null || encoding.equals("") || encoding.startsWith("_")) return false; |
| // Check to see if the encoding exists |
| if (hasResource(encoding)) return false; |
| // Create the resource |
| Bundle bundle = new Bundle(encoding); |
| bundle.name = title; |
| bundle.comment = comment; |
| bundle.manager = manager; |
| bundle.language = language; |
| bundle.country = country; |
| bundle.variant = variant; |
| |
| // Create a default group |
| bundle.addBundleGroup("Ungrouped Items", "These are resource items that have not been assigned a group"); |
| |
| if (copyValues) { |
| Bundle mainBundle = (Bundle)bundles.firstElement(); |
| for (int i=0; i < mainBundle.getGroupCount(); i++) { |
| BundleGroup mainGroup = mainBundle.getBundleGroup(i); |
| BundleGroup bg = new BundleGroup(bundle,mainGroup.getName()); |
| bg.setComment(mainGroup.getComment()); |
| bundle.addBundleGroup(bg); |
| for (int j=0; j < mainGroup.getItemCount(); j++) { |
| BundleItem mainItem = mainGroup.getBundleItem(j); |
| BundleItem item = new BundleItem(bg, mainItem.getKey(), mainItem.getTranslation()); |
| item.setComment(mainItem.getComment()); |
| item.setCreator(mainItem.getCreator()); |
| item.setModifier(mainItem.getModifier()); |
| item.setLookups(new Hashtable()); |
| // TODO: This should be done in the Bundle class |
| Enumeration keys = mainItem.getLookups().keys(); |
| while (keys.hasMoreElements()) { |
| String name = (String)keys.nextElement(); |
| String value = (String)mainItem.getLookups().get(name); |
| item.getLookups().put(new String(name), new String(value)); |
| } |
| bg.addBundleItem(item); |
| bundle.addUntranslatedItem(item); |
| } |
| } |
| } |
| |
| bundles.addElement(bundle); |
| |
| return true; |
| } |
| |
| /** |
| * Returns the number of duplicate NLS entries |
| */ |
| |
| public int getNumberDuplicates() { |
| return ((Bundle)bundles.firstElement()).duplicates.size(); |
| } |
| |
| /** |
| * Returns a single string with a comma delimited listing of all duplicate entries found in the NLS resources |
| */ |
| |
| public String getDuplicatesListing() { |
| return listStrings(getDuplicatesListingVector()); |
| } |
| |
| /** |
| * Returns a Vector collection of duplicate BundleItems found in the bundle |
| */ |
| |
| public Vector getDuplicatesListingVector() { |
| return ((Bundle)bundles.firstElement()).duplicates; |
| } |
| |
| /** |
| * A useful debugging method that lists the various BundleGroup names in a String. |
| */ |
| |
| public String getGroupListing() { |
| return listStrings(getGroupListingVector()); |
| } |
| |
| /** |
| * Returns a vector collection of all of the BundleGroup items founds int the bundle. |
| */ |
| |
| public Vector getGroupListingVector() { |
| Vector v = new Vector(); |
| Bundle bundle = (Bundle)bundles.firstElement(); |
| for (int i=0; i < bundle.getGroupCount(); i++) { |
| String name = bundle.getBundleGroup(i).getName(); |
| v.addElement(name); |
| } |
| return v; |
| } |
| |
| /** |
| * Returns the total number of languages that the system seems to support |
| */ |
| |
| public int getNumberLanguages() { |
| return bundles.size(); |
| } |
| |
| /** |
| * Returns a single string comprised of a comma delimited listing of all languages the system seems to support |
| */ |
| |
| public String getLanguageListing() { |
| return listStrings(getLanguageListingVector()); |
| } |
| |
| /** |
| * Returns a vector of strings comprising a list of all languages in the system |
| */ |
| |
| public Vector getLanguageListingVector() { |
| Vector v = new Vector(); |
| |
| for (int i = 0; i < bundles.size(); i++) { |
| Bundle dict = (Bundle)bundles.elementAt(i); |
| String dictStr = new String(); |
| if (dict.language != null) dictStr += dict.language; |
| if (dict.country != null) dictStr += " " + dict.country; |
| if (dict.variant != null) dictStr += " " + dict.variant; |
| if (dictStr.trim().equals("")) dictStr = (dict.encoding.trim().equals("") ? "Base Resource Bundle" : dict.encoding); |
| v.addElement(dictStr); |
| } |
| |
| return v; |
| } |
| |
| /** |
| * Returns the number of translations contained across all language files |
| */ |
| |
| public int getNumberTotalTranslations() { |
| return allBundleKeys.size(); |
| } |
| |
| /** |
| * Returns the number of BundleGroups in the bundle. |
| */ |
| |
| public int getNumberGroups() { |
| return ((Bundle)bundles.firstElement()).getGroupCount(); |
| } |
| |
| /** |
| * Returns the name of the user currently using the editor |
| */ |
| |
| public String getUser() { |
| return currentUser; |
| } |
| |
| /** |
| * Sets the name of the user currently using the editor |
| */ |
| |
| public void setUser(String user) { |
| currentUser = user; |
| } |
| |
| /** |
| * Sets the name of the base class associated with this resource bundle |
| */ |
| |
| public void setBaseClass(String baseClassName) { |
| baseClass = baseClassName; |
| } |
| |
| /** |
| * Sets the directory in the file system in which this resource bundle is to be |
| * saved and retrieved. |
| */ |
| |
| public void setFileDirectory(File directory) { |
| if (directory.isDirectory()) currentDirectory = directory; |
| } |
| |
| /** |
| * Returns the base class name if known, or "Unknown Base Class" otherwise. |
| */ |
| public String toSring() { |
| return (baseClass == null ? "Unknown Base Class" : baseClass); |
| } |
| |
| /** |
| * Returns the base class name or null if it does not exist. |
| */ |
| |
| public String getBaseClass() { |
| return baseClass; |
| } |
| |
| /** |
| * A Vector of NLSbundles, one for each language |
| */ |
| public Vector getBundles() { |
| return bundles; |
| } |
| |
| /** |
| * Return a bundle from a locale |
| * @return The requested resource bundle |
| */ |
| public Bundle getBundle(String locale) { |
| Bundle bundle = null; |
| if (hasResource(locale)) { |
| for (int i = 0; i < bundles.size(); i++) { |
| Bundle tempb = (Bundle)bundles.elementAt(i); |
| if (tempb.encoding.equals(locale)) { |
| bundle = tempb; |
| break; |
| } |
| } |
| } |
| return bundle; |
| } |
| |
| /** |
| * Returns the name of the file that is the base class file for the resource bundle. |
| */ |
| |
| public File getBaseFile() { |
| return new File(currentDirectory,baseClass + ".properties"); |
| } |
| |
| // Return a single comma delimited string made from a vector of strings |
| private String listStrings(Vector v) { |
| String retStr = new String(); |
| for (int i = 0; i < v.size(); i++) { |
| Object o = v.elementAt(i); |
| if (!(o instanceof String)) continue; |
| String s = (String)o; |
| if (i > 0) retStr += ", "; |
| retStr += s; |
| } |
| return retStr; |
| } |
| |
| // Init - called before ant construction |
| private void init() { |
| allBundleKeys = new Vector(); |
| bundles = new Vector(); |
| currentUser = "Unknown"; |
| } |
| |
| // Return a hashtable of the tags in a comment line (i.e. the text after each '@' character) and their values |
| private Hashtable getDescriptors(Hashtable result, String line) { |
| // Recursion terminating condition |
| if (line == null || line.length() <= 0 || line.indexOf("@") < 0) return result; |
| // Otherwise generate what information we can and recurse |
| if (result == null) result = new Hashtable(); |
| // Strip off any information before and including a '@' |
| line = line.substring(line.indexOf("@")+1, line.length()); |
| // There should be a space after the '@_tag_' and the value of this property |
| if (line.indexOf(" ") < 0) return result; // This shouldn't happen if things are formatted right |
| // Add the text after the '@' character up to the first whitespace (has to be a space, not tab or other whitespace) |
| String name = line.substring(0,line.indexOf(" ")).trim(); |
| // Now strip off the tag name |
| line = line.substring(line.indexOf(" "), line.length()); |
| // If there is another '@' character we take the value up until that character |
| if (line.indexOf("@") >= 0) { |
| result.put(name,line.substring(0,line.indexOf("@")).trim()); |
| } |
| // Otherwise we take the rest of the characters in the line |
| else { |
| result.put(name,line.trim()); |
| return result; |
| } |
| // Recurse |
| return getDescriptors(result, line.substring(line.indexOf("@"), line.length())); |
| } |
| |
| // Checks an array of strings to see if it contains a particular string |
| /* private static boolean arrayContains(String[] array, String match) { |
| for (int i = 0; i < array.length; i++) { |
| if (array[i].equals(match)) return true; |
| } |
| return false; |
| }*/ |
| |
| // Prints the usage of the program when called from main |
| /* private static void printUsage() { |
| String usage = new String(); |
| usage += "Usage:\n\njava com.ibm.almaden.TempusFugit.Tools.RBManager fileName ((-r | -d) encoding?)?"; |
| usage += "\n\n fileName -> The file (and path?) representing the main NLS resource\n\t\t(i.e. TempusFugit.resources)\n"; |
| usage += " encoding -> Returns results for only the language encoding specified\n"; |
| usage += " flag -r -> Gives only a status report on the state of the translations\n"; |
| System.out.println(usage); |
| }*/ |
| |
| } |
| |
