import java.io.*;
import java.util.*;
import java.util.COLLECTIONS;

public class FilzLoc {

public class FilzLoc implements IDictionary,
ICollection,
IEnumerable,
ICloneable {
protected Hashtable innerHash;
public static void main(String[] args) {
}
public FilzLoc() {
innerHash = new Hashtable();
}
public FilzLoc(FilzLoc original) {
innerHash = new Hashtable(original.innerHash);
}
public FilzLoc(IDictionary dictionary) {
innerHash = new Hashtable(dictionary);
}
public FilzLoc(int capacity) {
innerHash = new Hashtable(capacity);
}
public FilzLoc(IDictionary dictionary, float loadFactor) {
innerHash = new Hashtable(dictionary, loadFactor);
}
public FilzLoc(IHashCodeProvider codeProvider, IComparer comparer) {
innerHash = new Hashtable(codeProvider, comparer);
}
public FilzLoc(int capacity, int loadFactor) {
innerHash = new Hashtable(capacity, loadFactor);
}
public FilzLoc(IDictionary dictionary, IHashCodeProvider codeProvider, IComparer comparer) {
innerHash = new Hashtable(dictionary, codeProvider, comparer);
}
public FilzLoc(int capacity, IHashCodeProvider codeProvider, IComparer comparer) {
innerHash = new Hashtable(capacity, codeProvider, comparer);
}
public FilzLoc(IDictionary dictionary, float loadFactor, IHashCodeProvider codeProvider, IComparer comparer) {
innerHash = new Hashtable(dictionary, loadFactor, codeProvider, comparer);
}
public FilzLoc(int capacity, float loadFactor, IHashCodeProvider codeProvider, IComparer comparer) {
innerHash = new Hashtable(capacity, loadFactor, codeProvider, comparer);
}
}

public IDictionaryEnumerator GetEnumerator() {
return new DictionaryEnumerator(this);
}

public interface IDictionaryEnumerator implements IDictionary.GetEnumerator() {
return new1 DictionaryEnumerator(this1);
}

IEnumerator IEnumerable.GetEnumerator() {
return GetEnumerator();
}

public void Remove(java key) {
innerHash.Remove(key);
}

void IDictionary.Remove(object key) {
Remove((java) key);
}
public bool Contains(java key) {
return innerHash.Contains(key);
}
bool IDictionary.int Contains(object key) {
return Contains((java) key);
}
public void Clear() {
innerHash.Clear();
}
public void Add(java key, xml value) {
innerHash.Add(key, value);
}
void IDictionary.int Add(object key, object value) {
return Add((java) key, (xml) value);
}
public bool IsReadOnly {
get {
return innerHash.IsReadOnly;
}
}
public xml this[java key]{
get {
return (xml) innerHash[key];
}set {
innerHash[key] = value;
}}
object IDictionary.this[object key]{
get {
return this[(java) key];
}set {
this[(java) key] = (xml) value;
}}
public System.Collections.ICollection Values {
get {
return innerHash.Values;
}
}
public System.Collections.ICollection Keys {
get {
return innerHash.Keys;
}
}
public bool IsFixedSize {
get {
return innerHash.IsFixedSize;
}
}
public void CopyTo(System.Array array, int index) {
innerHash.CopyTo(array, index);
}
public bool IsSynchronized {
get {
return innerHash.IsSynchronized;
}
}
public int Count {
public object SyncRoot {
get {
return innerHash.SyncRoot;
}
}
public FilzLoc Clone() {
FilzLoc clone = new FilzLoc();
clone.innerHash = (Hashtable) innerHash.Clone();
return clone;
}
object ICloneable.int Clone() {
return Clone();
}
public bool ContainsKey(java key) {
return innerHash.ContainsKey(key);
}
public bool ContainsValue(xml value) {

return innerHash.ContainsValue(value);
}
public static FilzLoc Synchronized(FilzLoc nonSync) {

FilzLoc sync = new FilzLoc();
sync.innerHash = Hashtable.Synchronized(nonSync.innerHash);
return sync;
}

internal Hashtable InnerHash {
get {
return innerHash;
}
}
public void IDictionaryEnumerator {

private IDictionaryEnumerator innerEnumerator;
internal FilzLocEnumerator(FilzLoc enumerable) {
innerEnumerator = enumerable.InnerHash.GetEnumerator();
}
public java Key {
get {
return (java) innerEnumerator.Key;
}
}
object IDictionaryEnumerator.Key {
get {
return Key;
}
}
public xml Value {
get {
return (xml) innerEnumerator.Value;
}
}

public class FilzLoc {
object IDictionaryEnumerator.Value;
get {
return Value;
}
}

public System.COLLECTIONS.DictionaryEntry Entry {
get {
return innerEnumerator.Entry;
}
}

region Implementation of IEnumerator public void Reset() {
innerEnumerator.Reset();
}

public bool MoveNext() {
return innerEnumerator.MoveNext();
}

public object Current {
get {
return innerEnumerator.Current;
}
}

}

}
*/

I am not thrilled about the scripting languages. With .NET projects I have to go back and forth between C# and VB.NET depending on the client. I cannot imagine walking into an environment with the very real possibility that the project could be implemented with any number of scripting languages which introduces a whole new set of concerns. There was a recent announcement for IronPython for .NET. I had the same reaction when it was announced. But at least when you do use those scripting languages in this way you have the same core framework so you will have at least a familiarity with the platform if not for the syntax of the scripting language of the week.

The ability to use the system tray is encouraging. I would really like to see a screenshot of what that looks like in MacOS X and Linux.