#97746#

6 files changed, 1647 insertions, 0 deletions

diff --git a/javaunohelper/com/sun/star/lib/uno/helper/ComponentBase.java b/javaunohelper/com/sun/star/lib/uno/helper/ComponentBase.java
new file mode 100644
index 000000000000..b6c2ffa50fcb
--- /dev/null
+++ b/javaunohelper/com/sun/star/lib/uno/helper/ComponentBase.java
@@ -0,0 +1,165 @@
+/*************************************************************************
+ *
+ *  $RCSfile: ComponentBase.java,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: jl $ $Date: 2002-04-11 13:39:51 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, as published by the Free Software Foundation.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *  MA  02111-1307  USA
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (the "License"); You may not use this file
+ *  except in compliance with the License. You may obtain a copy of the
+ *  License at http://www.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+
+package com.sun.star.lib.uno.helper;
+import com.sun.star.lang.XComponent;
+import com.sun.star.lang.XEventListener;
+import com.sun.star.lang.EventObject;
+import java.util.List;
+import java.util.Collections;
+import java.util.LinkedList;
+import com.sun.star.uno.Type;
+
+/** This class can be used as the base class for UNO components. In addition to the functionality ,which
+ *  is inherited from WeakBase, it implements com.sun.star.lang.XComponent.
+ */
+public class ComponentBase extends WeakBase implements XComponent
+{
+    private final boolean DEBUG= false;
+    public MultiTypeInterfaceContainer listenerContainer;
+    private boolean bDisposed= false;
+    static final Type  EVT_LISTENER_TYPE= new Type(XEventListener.class);
+
+
+    /** Creates a new instance of CompBase */
+    public ComponentBase()
+    {
+        super();
+        listenerContainer= new MultiTypeInterfaceContainer();
+    }
+
+    /** Override to perform extra clean-up work. Provided for subclasses. It is
+        called during dispose()
+     */
+    public void disposing()
+    {
+    }
+
+    /** Method of XComponent. It is called by the owning client when the component is not needed
+     *  anymore. The registered listeners are notified that this method has been called.
+     */
+    public void dispose()
+    {
+        //Assuming that listener release references to this object during the
+        // disposing call then it might happen that this object is being unreferenced
+        // which leads to be gc'ed and the notification might be interrupted.
+        ComponentBase selfRef= this;
+        // Determine in a thread-safe way if this is the first call to this method.
+        // Only then we proceed with the notification of event listeners.
+        // It is an error to call this method more then once.
+        boolean bDoDispose= false;
+        synchronized (this)
+        {
+            if ( bDisposed == false)
+            {
+                bDoDispose= true;
+                bDisposed= true;
+            }
+        }
+        // The notification occures in an unsynchronized block in order to avoid
+        // deadlocks if one of the listeners calls back in a different thread on
+        // a synchronized method which uses the same object.
+        if (bDoDispose)
+        {
+            listenerContainer.disposeAndClear(new EventObject(this));
+            //notify subclasses that disposing is in progress
+            disposing();
+        }
+        else
+        {
+            // in a multithreaded environment, it can't be avoided, that dispose is called twice.
+            // However this condition is traced, because it MAY indicate an error.
+            if (DEBUG)
+                System.out.println("OComponentHelper::dispose() - dispose called twice" );
+        }
+        selfRef= null;
+    }
+
+    /** Method of XComponent.
+     */
+    public void removeEventListener(XEventListener xEventListener)
+    {
+        listenerContainer.removeInterface( EVT_LISTENER_TYPE, xEventListener);
+    }
+
+    public void addEventListener(XEventListener listener)
+    {
+        boolean bDoDispose= false;
+        synchronized (this)
+        {
+            if (bDisposed == true)
+                bDoDispose= true;
+            else
+               listenerContainer.addInterface(EVT_LISTENER_TYPE, listener);
+        }
+        if (bDoDispose )
+        {
+            listener.disposing( new EventObject(this));
+        }
+    }
+
+    protected void finalize() throws Throwable
+    {
+        if (bDisposed == false)
+            dispose();
+        super.finalize();
+    }
+}
diff --git a/javaunohelper/com/sun/star/lib/uno/helper/InterfaceContainer.java b/javaunohelper/com/sun/star/lib/uno/helper/InterfaceContainer.java
new file mode 100644
index 000000000000..68bd2742d90a
--- /dev/null
+++ b/javaunohelper/com/sun/star/lib/uno/helper/InterfaceContainer.java
@@ -0,0 +1,895 @@
+/*************************************************************************
+ *
+ *  $RCSfile: InterfaceContainer.java,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: jl $ $Date: 2002-04-11 13:39:51 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, as published by the Free Software Foundation.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *  MA  02111-1307  USA
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (the "License"); You may not use this file
+ *  except in compliance with the License. You may obtain a copy of the
+ *  License at http://www.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+
+package com.sun.star.lib.uno.helper;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Iterator;
+import java.util.ListIterator;
+import java.util.NoSuchElementException;
+import java.util.Collection;
+import com.sun.star.lang.EventObject;
+import com.sun.star.lang.XEventListener;
+import com.sun.star.uno.UnoRuntime;
+import java.lang.ClassCastException;
+import com.sun.star.uno.XInterface;
+import java.util.AbstractList;
+
+/**
+ * This class is a container for interfaces.
+ *
+ * It is intended to be used as storage for UNO interface of a specific type.
+ * The client has to ensure that the container contains only elements of the same
+ * type. If one needs to store different types, then one uses OMultiTypeInterfaceContainer.
+ * When the client calls disposeAndClear, the contained objects are queried for
+ * com.sun.star.lang.XEventListener and disposing is called. Afterwards
+ * the list cannot be used anymore.
+ *
+ * This list does not allow null values.
+ * All methods are thread-safe. The same holds true for
+ * iterators, issued by this class. Several iterators can exist at the same time and can also
+ * be modified (java.util.ListIterator.add, java.util.ListIterator.remove etc.). To make this work,
+ * the InterfaceContainer provides the iterators with copys of the list's data.
+ * The add and remove calls on the iterator modify the data in the iterator's list as well as
+ * in InterfaceContainer. Modification on InterfaceContainer, however, are not
+ * synchronized with existing iterators. For example
+ * <pre>
+ * InterfaceContainer cont= new InterfaceContainer();
+ * ListIterator it= cont.listIterator();
+ *
+ * cont.add( someInterface);
+ * // one cannot obtain someInterface through iterator it,
+ * // instead get a new iterator
+ * it= cont.listIterator();
+ * // it now keeps a fresh copy of cont and hence contains someInterface
+ *
+ * // Adding an interface on the iterator will cause the interface also to be added
+ * // to InterfaceContainer
+ * it.add( someOtherInterface);
+ * // someOtherInterface is now in it and cont
+ * ListIterator it2= cont.listIterator();
+ * //someOtherInterface can also be obtained by all newly created iterators, e.g. it2.
+ * </pre>
+ *
+ *  The add and remove methods of an iterator work on a particular location within a list,
+ *  dependent on what the value of the iterator's cursor is. After the call the value at the
+ *  appropriate position has been modified. Since the iterator received a copy of InterfaceContainer's
+ *  data, InterfaceContainer may have been modified (by List methods or through other iterators).
+ *  Therefore both data sets may not contain the same elements anymore. Consequently, a List method
+ *  that modifies data, does not modify InterfaceContainer's data at a certain index
+ *  (according to the iterators cursor). Instead, new elements are added at the end of list. When
+ *  Iterator.remove is called, then the first occurrence of that element in InterfaceContainer
+ *  is removed.
+ *  ListIterator.set is not supported.
+ *
+ * A lot of  methods resemble those of the  to java.util.List interface, allthough
+ * this class does not implement it. However, the list iterators returned, for example by
+ * the listIterator method implement the java.util.ListIterator interface.
+ * Implementing the List interface would mean to support all none - optional methods as
+ * prescribed by the interface declaration. Among those is the subList method which returns
+ * a range of values of the list's data wrapped in a List implementation. Changes to the sub
+ * list have to cause changes in the main list. This is a problem, since this class is to be
+ * used in a multi-threaded environment. The sub list could work on a copy as the iterators
+ * do, but all the functions which work on an given index could not be properly supported.
+ * Unfortunatly, the List interface documentation states that all optional methods implemented
+ * by the list have to be implemented in the sub list. That would mean to do without all those
+ * critical methods, allthough they might work well in the "main list" (as opposed to sub list).
+ */
+public class InterfaceContainer implements Cloneable
+{
+    final boolean DEBUG= false;
+    /**
+     * The array buffer into which the elements of the ArrayList are stored.
+     * The capacity of the ArrayList is the length of this array buffer.
+     */
+    Object elementData[];
+
+    /**
+     * The size of the ArrayList (the number of elements it contains).
+     *
+     * @serial
+     */
+    private int size;
+
+
+    //private ArrayList data= new ArrayList();
+    /** Creates a new instance of InterfaceContainer */
+    public InterfaceContainer()
+    {
+        this(10);
+    }
+    /**
+     * Constructs an empty list with the specified initial capacity.
+     *
+     * @param   initialCapacity   the initial capacity of the list.
+     * @exception IllegalArgumentException if the specified initial capacity
+     *            is negative
+     */
+    public InterfaceContainer(int initialCapacity)
+    {
+        if (initialCapacity < 0)
+            throw new java.lang.IllegalArgumentException("Illegal Capacity: "+
+            initialCapacity);
+        this.elementData = new Object[initialCapacity];
+    }
+
+    /**
+     * Trims the capacity of this <tt>ArrayList</tt> instance to be the
+     * list's current size.  An application can use this operation to minimize
+     * the storage of an <tt>ArrayList</tt> instance.
+     */
+    synchronized public void trimToSize()
+    {
+        int oldCapacity = elementData.length;
+        if (size < oldCapacity)
+        {
+            Object oldData[] = elementData;
+            elementData = new Object[size];
+            System.arraycopy(oldData, 0, elementData, 0, size);
+        }
+    }
+
+    /**
+     * Increases the capacity of this <tt>ArrayList</tt> instance, if
+     * necessary, to ensure  that it can hold at least the number of elements
+     * specified by the minimum capacity argument.
+     *
+     * @param   minCapacity   the desired minimum capacity.
+     */
+    synchronized public void ensureCapacity(int minCapacity)
+    {
+        int oldCapacity = elementData.length;
+        if (minCapacity > oldCapacity)
+        {
+            Object oldData[] = elementData;
+            int newCapacity = (oldCapacity * 3)/2 + 1;
+            if (newCapacity < minCapacity)
+                newCapacity = minCapacity;
+            elementData = new Object[newCapacity];
+            System.arraycopy(oldData, 0, elementData, 0, size);
+        }
+    }
+
+    /**
+     * Appends the specified element to the end of this list.
+     *
+     * @param o element to be appended to this list.
+     * @return <tt>true</tt> (as per the general contract of Collection.add).
+     */
+    synchronized public boolean add(Object o)
+    {
+        boolean ret= false;
+        if (elementData != null && o != null)
+        {
+            ensureCapacity(size + 1);  // Increments modCount!!
+            elementData[size++] = o;
+            ret= true;
+        }
+        return ret;
+    }
+
+    /**
+     * Inserts the specified element at the specified position in this
+     * list. Shifts the element currently at that position (if any) and
+     * any subsequent elements to the right (adds one to their indices).
+     *
+     * @param index index at which the specified element is to be inserted.
+     * @param element element to be inserted.
+     * @throws    IndexOutOfBoundsException if index is out of range
+     *        <tt>(index &lt; 0 || index &gt; size())</tt>.
+     */
+    synchronized public void add(int index, Object element)
+    {
+        if (elementData != null && element != null)
+        {
+            if (index > size || index < 0)
+                throw new IndexOutOfBoundsException(
+                "Index: "+index+", Size: "+size);
+
+            ensureCapacity(size+1);
+            System.arraycopy(elementData, index, elementData, index + 1,
+            size - index);
+            elementData[index] = element;
+            size++;
+        }
+    }
+
+
+    /**
+     * Appends all of the elements in the specified Collection to the end of
+     * this list, in the order that they are returned by the
+     * specified Collection's Iterator.  The behavior of this operation is
+     * undefined if the specified Collection is modified while the operation
+     * is in progress.  (This implies that the behavior of this call is
+     * undefined if the specified Collection is this list, and this
+     * list is nonempty.)
+     *
+     * @param c the elements to be inserted into this list.
+     * @throws    IndexOutOfBoundsException if index out of range <tt>(index
+     *        &lt; 0 || index &gt; size())</tt>.
+     */
+    synchronized public boolean addAll(Collection c)
+    {
+        int numNew = c.size();
+        ensureCapacity(size + numNew);
+
+        Iterator e = c.iterator();
+        for (int i=0; i<numNew; i++)
+        {
+            Object o= e.next();
+            if (o != null)
+                elementData[size++] = o;
+        }
+        return numNew != 0;
+    }
+    /**
+     * Inserts all of the elements in the specified Collection into this
+     * list, starting at the specified position.  Shifts the element
+     * currently at that position (if any) and any subsequent elements to
+     * the right (increases their indices).  The new elements will appear
+     * in the list in the order that they are returned by the
+     * specified Collection's iterator.
+     *
+     * @param index index at which to insert first element
+     *          from the specified collection.
+     * @param c elements to be inserted into this list.
+     * @throws    IndexOutOfBoundsException if index out of range <tt>(index
+     *        &lt; 0 || index &gt; size())</tt>.
+     */
+    synchronized public boolean addAll(int index, Collection c)
+    {
+        boolean ret= false;
+        if (elementData != null)
+        {
+            if (index > size || index < 0)
+                throw new IndexOutOfBoundsException(
+                "Index: "+index+", Size: "+size);
+            // only add  the non-null elements
+            int sizeCol= c.size();
+            Object[] arColl= new Object[sizeCol];
+            Iterator icol= c.iterator();
+            int curIndex= 0;
+            for (int i=0; i < sizeCol; i++)
+            {
+                Object o= icol.next();
+                if (o != null)
+                    arColl[curIndex++]= o;
+            }
+            int numNew = curIndex;
+            ensureCapacity(size + numNew);  // Increments modCount!!
+
+            int numMoved = size - index;
+            if (numMoved > 0)
+                System.arraycopy(elementData, index, elementData, index + numNew,
+                numMoved);
+
+            for (int i=0; i<numNew; i++)
+            {
+                elementData[index++]= arColl[i];
+            }
+            size += numNew;
+            ret= numNew != 0;
+        }
+        return ret;
+    }
+
+    /**
+     * Removes all of the elements from this list.  The list will
+     * be empty after this call returns.
+     */
+    synchronized public void clear()
+    {
+        if (elementData != null)
+        {
+            // Let gc do its work
+            for (int i = 0; i < size; i++)
+                elementData[i] = null;
+
+            size = 0;
+        }
+    }
+    /**
+     * Returns <tt>true</tt> if this list contains the specified element.
+     *
+     * @param elem element whose presence in this List is to be tested.
+     */
+    synchronized public boolean contains(Object elem)
+    {
+        return indexOf(elem) >= 0;
+    }
+
+    synchronized public boolean containsAll(Collection collection)
+    {
+        boolean retVal= true;
+        if (elementData != null && collection != null)
+        {
+            Iterator it= collection.iterator();
+            while (it.hasNext())
+            {
+                Object obj= it.next();
+                if (false == contains(obj))
+                {
+                    retVal= false;
+                    break;
+                }
+            }
+        }
+        return retVal;
+    }
+    /**
+     * Returns the element at the specified position in this list.
+     *
+     * @param  index index of element to return.
+     * @return the element at the specified position in this list.
+     * @throws    IndexOutOfBoundsException if index is out of range <tt>(index
+     *        &lt; 0 || index &gt;= size())</tt>.
+     */
+    synchronized public Object get(int index)
+    {
+        if (elementData != null)
+        {
+            RangeCheck(index);
+            return elementData[index];
+        }
+        return null;
+    }
+
+    /**
+     * Searches for the first occurence of the given argument, testing
+     * for equality using the <tt>equals</tt> method.
+     *
+     * @param   elem   an object.
+     * @return  the index of the first occurrence of the argument in this
+     *          list; returns <tt>-1</tt> if the object is not found.
+     * @see     Object#equals(Object)
+     */
+    synchronized public int indexOf(Object elem)
+    {
+        int index= -1;
+        if (elementData != null && elem != null)
+        {
+            for (int i = 0; i < size; i++)
+            {
+                if (elem == elementData[i])
+                {
+                    index= i;
+                    break;
+                }
+            }
+
+            if (index == -1)
+            {
+                for (int i = 0; i < size; i++)
+                {
+                    if (UnoRuntime.areSame(elem, elementData[i]))
+                    {
+                        index= i;
+                        break;
+                    }
+                }
+            }
+        }
+        return index;
+    }
+    /**
+     * Tests if this list has no elements.
+     *
+     * @return  <tt>true</tt> if this list has no elements;
+     *          <tt>false</tt> otherwise.
+     */
+    synchronized public boolean isEmpty()
+    {
+        return size == 0;
+    }
+
+    synchronized public Iterator iterator()
+    {
+        if (elementData != null)
+        {
+            InterfaceContainer aCopy= (InterfaceContainer) clone();
+            return new Itr(aCopy);
+        }
+        return null;
+    }
+    /**
+     * Returns the index of the last occurrence of the specified object in
+     * this list.
+     *
+     * @param   elem   the desired element.
+     * @return  the index of the last occurrence of the specified object in
+     *          this list; returns -1 if the object is not found.
+     */
+    synchronized public int lastIndexOf(Object elem)
+    {
+        int index= -1;
+        if (elementData != null && elem != null)
+        {
+            for (int i = size-1; i >= 0; i--)
+            {
+                if (elem == elementData[i])
+                {
+                    index= i;
+                    break;
+                }
+            }
+            if (index == -1)
+            {
+                for (int i = size-1; i >= 0; i--)
+                {
+                    if (UnoRuntime.areSame(elem, elementData[i]))
+                    {
+                        index= i;
+                        break;
+                    }
+                }
+            }
+        }
+        return index;
+    }
+
+    /**
+     * Returns a shallow copy of this <tt>ArrayList</tt> instance. The contained
+     * references are copied but the objects not.
+     *
+     * @return  a clone of this <tt>List</tt> instance.
+     */
+    synchronized public Object clone()
+    {
+        Object ret= null;
+        if (elementData != null)
+        {
+            InterfaceContainer cont= new InterfaceContainer();
+            cont.elementData = new Object[size];
+            cont.size= size;
+            System.arraycopy(elementData, 0, cont.elementData, 0, size);
+            ret= cont;
+        }
+        return ret;
+    }
+    synchronized public ListIterator listIterator()
+    {
+        return listIterator(0);
+    }
+
+    /** The iterator keeps a copy of the list. Changes to InterfaceContainer do not
+     *  affect the data of the iterator. Conversly, changes to the iterator are effect
+     *  InterfaceContainer.
+     */
+    synchronized public ListIterator listIterator(int index)
+    {
+        if (elementData != null)
+        {
+            InterfaceContainer aCopy= (InterfaceContainer) clone();
+            return new LstItr(aCopy, index);
+        }
+        return null;
+    }
+    /**
+     * Removes the element at the specified position in this list.
+     * Shifts any subsequent elements to the left (subtracts one from their
+     * indices).
+     *
+     * @param index the index of the element to removed.
+     * @return the element that was removed from the list.
+     * @throws    IndexOutOfBoundsException if index out of range <tt>(index
+     *        &lt; 0 || index &gt;= size())</tt>.
+     */
+    synchronized public Object remove(int index)
+    {
+        Object ret= null;
+        if (elementData != null)
+        {
+            RangeCheck(index);
+            ret= elementData[index];
+
+            int numMoved = size - index - 1;
+            if (numMoved > 0)
+                System.arraycopy(elementData, index+1, elementData, index,
+                numMoved);
+            elementData[--size] = null; // Let gc do its work
+        }
+        return ret;
+    }
+
+
+    /** Parameter obj may  */
+    synchronized public boolean remove(Object obj)
+    {
+        boolean ret= false;
+        if (elementData != null && obj != null)
+        {
+            int index= indexOf(obj);
+            if (index != -1)
+            {
+                ret= true;
+                remove(index);
+            }
+        }
+        return ret;
+    }
+
+    synchronized public boolean removeAll(Collection collection)
+    {
+        boolean retVal= false;
+        if (elementData != null && collection != null)
+        {
+            Iterator it= collection.iterator();
+            while (it.hasNext())
+            {
+                Object obj= it.next();
+                boolean bMod= remove( obj);
+                if (bMod)
+                    retVal= true;
+            }
+        }
+        return retVal;
+    }
+
+    synchronized public boolean retainAll(Collection collection)
+    {
+        boolean retVal= false;
+        if (elementData != null && collection != null)
+        {
+            // iterate over data
+            Object[] arRetained= new Object[size];
+            int indexRetained= 0;
+            for(int i= 0; i < size; i++)
+            {
+                Object curElem= elementData[i];
+                // try to find the element in collection
+                Iterator itColl= collection.iterator();
+                boolean bExists= false;
+                while (itColl.hasNext())
+                {
+                    if (curElem == itColl.next())
+                    {
+                        // current element is in collection
+                        bExists= true;
+                        break;
+                    }
+                }
+                if (bExists == false)
+                {
+                    itColl= collection.iterator();
+                    while (itColl.hasNext())
+                    {
+                        Object o= itColl.next();
+                        if (o != null)
+                        {
+                            if (UnoRuntime.areSame(o, curElem))
+                            {
+                                bExists= true;
+                                break;
+                            }
+                        }
+                    }
+                }
+                if (bExists == true)
+                    arRetained[indexRetained++]= curElem;
+            }
+            retVal= size != indexRetained;
+            if (indexRetained > 0)
+            {
+                elementData= arRetained;
+                size= indexRetained;
+            }
+        }
+        return retVal;
+    }
+
+
+    /** Not supported.
+     * @param index index of element to replace.
+     * @param element element to be stored at the specified position.
+     * @return the element previously at the specified position.
+     * @throws    IndexOutOfBoundsException if index out of range
+     *        <tt>(index &lt; 0 || index &gt;= size())</tt>.
+     */
+    synchronized public Object set(int index, Object element)
+    {
+          Object ret= null;
+          if (elementData != null && element != null)
+          {
+              RangeCheck(index);
+              ret = elementData[index];
+              elementData[index] = element;
+          }
+          return ret;
+    }
+
+    /**
+     * Returns the number of elements in this list.
+     *
+     * @return  the number of elements in this list.
+     */
+    synchronized public int size()
+    {
+        if (elementData != null)
+            return size;
+        return 0;
+    }
+
+
+    /**
+     * Returns an array containing all of the elements in this list
+     * in the correct order.
+     *
+     * @return an array containing all of the elements in this list
+     *         in the correct order.
+     */
+    synchronized public Object[] toArray()
+    {
+        if (elementData != null)
+        {
+            Object[] result = new Object[size];
+            System.arraycopy(elementData, 0, result, 0, size);
+            return result;
+        }
+        return null;
+    }
+
+    /**
+     * Returns an array containing all of the elements in this list in the
+     * correct order.  The runtime type of the returned array is that of the
+     * specified array.  If the list fits in the specified array, it is
+     * returned therein.  Otherwise, a new array is allocated with the runtime
+     * type of the specified array and the size of this list.<p>
+     *
+     * If the list fits in the specified array with room to spare (i.e., the
+     * array has more elements than the list), the element in the array
+     * immediately following the end of the collection is set to
+     * <tt>null</tt>.  This is useful in determining the length of the list
+     * <i>only</i> if the caller knows that the list does not contain any
+     * <tt>null</tt> elements.
+     *
+     * @param a the array into which the elements of the list are to
+     *      be stored, if it is big enough; otherwise, a new array of the
+     *      same runtime type is allocated for this purpose.
+     * @return an array containing the elements of the list.
+     * @throws ArrayStoreException if the runtime type of a is not a supertype
+     *         of the runtime type of every element in this list.
+     */
+    synchronized public Object[] toArray(Object a[])
+    {
+        if (a.length < size)
+            a = (Object[])java.lang.reflect.Array.newInstance(
+            a.getClass().getComponentType(), size);
+        if (elementData != null)
+            System.arraycopy(elementData, 0, a, 0, size);
+
+        if (a.length > size)
+            a[size] = null;
+
+        return a;
+    }
+
+    /**
+     * Check if the given index is in range.  If not, throw an appropriate
+     * runtime exception.
+     */
+    private void RangeCheck(int index)
+    {
+        if (index >= size || index < 0)
+            throw new IndexOutOfBoundsException(
+            "Index: "+index+", Size: "+size);
+    }
+
+    public void disposeAndClear(EventObject evt)
+    {
+        Iterator aIt;
+        synchronized (this)
+        {
+            aIt= iterator();
+            // Container freigeben, falls im disposing neue Einträge kommen
+            // set the member to null, the iterator delete the values
+            clear();
+            elementData= null;
+            size= 0;
+        }
+        if (aIt != null)
+        {
+            while( aIt.hasNext() )
+            {
+                try
+                {
+                    Object o= aIt.next();
+                    XEventListener evtListener= (XEventListener) UnoRuntime.queryInterface(
+                    XEventListener.class, o);
+                    if( evtListener != null )
+                        evtListener.disposing( evt );
+                }
+                catch ( RuntimeException e)
+                {
+                    // be robust, if e.g. a remote bridge has disposed already.
+                    // there is no way, to delegate the error to the caller :o(.
+                }
+            }
+        }
+    }
+
+
+    private class Itr implements Iterator
+    {
+        InterfaceContainer dataIt;
+        /**
+         * Index of element to be returned by subsequent call to next.
+         */
+        int cursor= 0;
+        /**
+         * Index of element returned by most recent call to next or
+         * previous.  Reset to -1 if this element is deleted by a call
+         * to remove.
+         */
+        int lastRet = -1;
+
+        /** The object that has been returned by most recent call to next
+         *  or previous. Reset to null if this element is deleted by a call
+         *  to remove.
+         */
+        Object lastRetObj= null;
+
+        Itr(InterfaceContainer _data)
+        {
+            dataIt= _data;
+        }
+
+        synchronized public boolean hasNext()
+        {
+            return cursor !=dataIt.size();
+        }
+
+        public synchronized Object next()
+        {
+            try
+            {
+                Object next = dataIt.get(cursor);
+                lastRet = cursor++;
+                lastRetObj= next;
+                return next;
+            }
+            catch(java.lang.IndexOutOfBoundsException e)
+            {
+                throw new java.util.NoSuchElementException();
+            }
+        }
+
+        /** Removes the interface from the list, that has been last returned by a
+         *  call to next(). This is done according to the specification of the interface
+         *  method. The element is also removed from InterfaceContainer but independent
+         *  of the location. If the element is multiple times in InterfaceContainer then
+         *  it is up to the java.util.ArrayList implementation what element is removed.
+         */
+        public synchronized void remove()
+        {
+            if (lastRet == -1)
+                throw new IllegalStateException();
+            // Remove the entry from InterfaceContainer.
+            InterfaceContainer.this.remove(lastRetObj);
+            dataIt.remove(lastRet);
+
+            if (lastRet < cursor)
+                cursor--;
+            lastRet = -1;
+            lastRetObj= null;
+        }
+    }
+
+    private class LstItr extends Itr implements ListIterator
+    {
+
+        LstItr(InterfaceContainer _data, int _index)
+        {
+            super(_data);
+            cursor= _index;
+        }
+
+        /** Inserts an element to the iterators list according to the specification
+         *  of this interface method. The element is also added to InterfaceContainer
+         *  but its location within the list cannot be guaranteed.
+         */
+        public synchronized void add(Object o)
+        {
+            InterfaceContainer.this.add(o);
+            dataIt.add(cursor++, o);
+            lastRet = -1;
+            lastRetObj= null;
+        }
+
+        synchronized public boolean hasPrevious()
+        {
+            return cursor != 0;
+        }
+
+        synchronized public int nextIndex()
+        {
+            return cursor;
+        }
+
+        public synchronized Object previous()
+        {
+            try
+            {
+                Object previous = dataIt.get(--cursor);
+                lastRet = cursor;
+                lastRetObj= previous;
+                return previous;
+            } catch(IndexOutOfBoundsException e)
+            {
+                throw new NoSuchElementException();
+            }
+        }
+
+        synchronized public int previousIndex()
+        {
+            return cursor-1;
+        }
+
+        /** This is not possible since several iterators can modify InterfaceContainer
+         */
+        public synchronized void set(Object o)
+        {
+            throw new UnsupportedOperationException();
+        }
+
+
+    } // class LstItr
+}
+
diff --git a/javaunohelper/com/sun/star/lib/uno/helper/MultiTypeInterfaceContainer.java b/javaunohelper/com/sun/star/lib/uno/helper/MultiTypeInterfaceContainer.java
new file mode 100644
index 000000000000..6f1078341a91
--- /dev/null
+++ b/javaunohelper/com/sun/star/lib/uno/helper/MultiTypeInterfaceContainer.java
@@ -0,0 +1,200 @@
+/*************************************************************************
+ *
+ *  $RCSfile: MultiTypeInterfaceContainer.java,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: jl $ $Date: 2002-04-11 13:39:51 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, as published by the Free Software Foundation.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *  MA  02111-1307  USA
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (the "License"); You may not use this file
+ *  except in compliance with the License. You may obtain a copy of the
+ *  License at http://www.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+
+package com.sun.star.lib.uno.helper;
+import com.sun.star.uno.Type;
+import com.sun.star.lang.EventObject;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Iterator;
+
+public class MultiTypeInterfaceContainer
+{
+
+    private Map map= new HashMap();
+
+    /** Creates a new instance of MultiTypeInterfaceContainer */
+    public MultiTypeInterfaceContainer()
+    {
+    }
+
+    /** only returns types which have at least one value in InterfaceContainer
+     *  return value can contain an element null, if someone called
+     *  addInterface (null, interf)
+     */
+    synchronized public Type[] getContainedTypes()
+    {
+        int size;
+        Type[] retVal= null;
+
+        if ( (size=map.size()) > 0)
+        {
+            Type [] arTypes= new Type[size];
+            Iterator it= map.keySet().iterator();
+
+            int countTypes= 0;
+            while (it.hasNext())
+            {
+                Object key= it.next();
+                InterfaceContainer cont= (InterfaceContainer) map.get(key);
+                if (cont != null && cont.size() > 0)
+                {
+                    if (key == null)
+                        arTypes[countTypes++]= new Type();
+                    else if (key instanceof Type)
+                        arTypes[countTypes++]= (Type) key;
+                    else if (key instanceof Class)
+                        arTypes[countTypes++]= new Type((Class) key);
+                    else
+                        arTypes[countTypes++]= new Type(key.getClass());
+                }
+            }
+
+            if (countTypes != size)
+            {
+                retVal= new Type[countTypes];
+                System.arraycopy(arTypes, 0, retVal, 0, countTypes);
+            }
+            else
+                retVal= arTypes;
+        }
+        if (retVal == null)
+            retVal= new Type[0];
+        return retVal;
+    }
+
+    /** param key can be null */
+    synchronized public InterfaceContainer getContainer(Type key)
+    {
+        InterfaceContainer retVal= null;
+        Iterator it= map.keySet().iterator();
+        while (it.hasNext())
+        {
+            Object obj= it.next();
+            if (obj == null && key == null)
+            {
+                retVal= (InterfaceContainer) map.get(null);
+                break;
+            }
+            else if( obj != null && obj.equals(key))
+            {
+                retVal= (InterfaceContainer) map.get(obj);
+                break;
+            }
+        }
+        return retVal;
+    }
+
+
+    synchronized public int addInterface(Object ckey, Object iface)
+    {
+        //If the key is a Type then it does not matter if the objects are different
+        // if they represent the same type. This is because Types overrides hashCode and
+        // equals. For example:
+        // Type a= new Type(XInterface.class);
+        // Type b= new Type(XInterface.class);
+        // Allthough a != b , the map interprets both as being the same.
+        InterfaceContainer cont= (InterfaceContainer) map.get(ckey);
+        if (cont != null)
+        {
+            cont.add(iface);
+        }
+        else
+        {
+            cont= new InterfaceContainer();
+            cont.add(iface);
+            map.put(ckey, cont);
+        }
+        return cont.size();
+    }
+
+
+    synchronized public int removeInterface(Type key, Object iface)
+    {
+        int retVal= 0;
+        InterfaceContainer cont= (InterfaceContainer) map.get(key);
+        if (cont != null)
+        {
+            cont.remove(iface);
+            retVal= cont.size();
+        }
+        return retVal;
+    }
+
+    public void disposeAndClear(EventObject evt)
+    {
+        Iterator it= null;
+        synchronized(this)
+        {
+            it= map.values().iterator();
+        }
+        while (it.hasNext() )
+            ((InterfaceContainer) it.next()).disposeAndClear(evt);
+    }
+
+    synchronized public void clear()
+    {
+        Iterator it= map.values().iterator();
+        while (it.hasNext())
+            ((InterfaceContainer) it.next()).clear();
+    }
+}
diff --git a/javaunohelper/com/sun/star/lib/uno/helper/WeakAdapter.java b/javaunohelper/com/sun/star/lib/uno/helper/WeakAdapter.java
new file mode 100644
index 000000000000..b3a5a1f46dee
--- /dev/null
+++ b/javaunohelper/com/sun/star/lib/uno/helper/WeakAdapter.java
@@ -0,0 +1,137 @@
+/*************************************************************************
+ *
+ *  $RCSfile: WeakAdapter.java,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: jl $ $Date: 2002-04-11 13:39:51 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, as published by the Free Software Foundation.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *  MA  02111-1307  USA
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (the "License"); You may not use this file
+ *  except in compliance with the License. You may obtain a copy of the
+ *  License at http://www.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+
+package com.sun.star.lib.uno.helper;
+import java.lang.ref.WeakReference;
+import com.sun.star.uno.XAdapter;
+import com.sun.star.uno.XReference;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Collections;
+import java.util.LinkedList;
+
+/** An XAdapter implementation that holds a weak reference (java.lang.ref.WeakReference)
+ *  to an object. Clients can register listener (com.sun.star.lang.XReference) which
+ *  are notified when the the object (the one which is kept weak) is being finalized. That
+ *  is, that object is being destroyed because there are not any hard references
+ *  to it.
+ */
+public class WeakAdapter implements XAdapter
+{
+    private final boolean DEBUG= false;
+    // references the XWeak implementation
+    private WeakReference m_weakRef;
+    // contains XReference objects registered by addReference
+    private List m_xreferenceList;
+
+    /**
+     *@param component the object that is to be held weak
+     */
+    public WeakAdapter(Object component)
+    {
+        m_weakRef= new WeakReference(component);
+        m_xreferenceList= Collections.synchronizedList( new LinkedList());
+    }
+
+    /** Called by the XWeak implementation (WeakBase) when it is being finalized.
+     *  It is only being called once.
+     *  The registererd XReference listeners are notified. On notification they are
+     *  to unregister themselves. The notification is thread-safe. However, it is possible
+     *  to add a listener during the notification process, which will never receive a
+     *  notification. To prevent this, one would have to synchronize this method with
+     *  the addReference method. But this can result in deadlocks in a multithreaded
+     *  environment.
+     */
+    void referentDying()
+    {
+        //synchronized call
+        Object[] references= m_xreferenceList.toArray();
+        for (int i= references.length; i > 0; i--)
+        {
+            ((XReference) references[i-1]).dispose();
+        }
+    }
+
+    /** Method  of com.sun.star.uno.XAdapter. It is called to obtain a hard reference
+     *  to the object which is kept weak by this instance.
+     *  @return hard reference to the object
+     */
+    public Object queryAdapted()
+    {
+        return m_weakRef.get();
+    }
+    /** Method of com.sun.star.uno.XAdapter. Called by clients to register listener which
+     * are notified when the weak object is dying.
+     *@param xReference a listener
+     */
+    public void removeReference(XReference xReference)
+    {
+        m_xreferenceList.remove(xReference);
+    }
+    /** Method of com.sun.star.uno.XAdapter. Called by clients to unregister listeners.
+     *@param a listener
+     */
+    public void addReference(XReference xReference)
+    {
+        m_xreferenceList.add(xReference);
+    }
+}
+
diff --git a/javaunohelper/com/sun/star/lib/uno/helper/WeakBase.java b/javaunohelper/com/sun/star/lib/uno/helper/WeakBase.java
new file mode 100644
index 000000000000..1913748c291f
--- /dev/null
+++ b/javaunohelper/com/sun/star/lib/uno/helper/WeakBase.java
@@ -0,0 +1,164 @@
+/*************************************************************************
+ *
+ *  $RCSfile: WeakBase.java,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: jl $ $Date: 2002-04-11 13:39:51 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, as published by the Free Software Foundation.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *  MA  02111-1307  USA
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (the "License"); You may not use this file
+ *  except in compliance with the License. You may obtain a copy of the
+ *  License at http://www.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+
+package com.sun.star.lib.uno.helper;
+import com.sun.star.uno.XWeak;
+import com.sun.star.uno.XAdapter;
+import com.sun.star.lang.XTypeProvider;
+import com.sun.star.uno.Type;
+import java.lang.reflect.Field;
+import java.util.Vector;
+import com.sun.star.uno.UnoRuntime;
+
+
+/** This class can be used as the base class for UNO components. It implements the capability
+ *  to be kept weak (com.sun.star.uno.XWeak) and it implements com.sun.star.lang.XTypeProvider
+ *  which is necessary for using the component with StarBasic.
+ */
+public class WeakBase implements XWeak, XTypeProvider {
+    private final boolean DEBUG= false;
+
+    private final String UNO_INTERFACE_FIELD="UNOTYPEINFO";
+    private final String UNO_INTERFACE_TYPE="[Lcom.sun.star.lib.uno.typeinfo.TypeInfo;";
+    // Contains all WeakAdapter which have been created in this class
+    // They have to be notified when this object dies
+    private WeakAdapter m_adapter;
+
+    // for XTypeProvider.getImplementationId
+       static byte[] _implementationId;
+
+     /** Method of XWeak. The returned XAdapter implementation can be used to keap
+      * a weak reference to this object.
+      * @return a com.sun.star.uno.XAdapter implementation.
+      */
+     synchronized public XAdapter queryAdapter() {
+        if (m_adapter == null)
+            m_adapter= new WeakAdapter(this);
+         return m_adapter;
+     }
+
+     /** Override of Object.finalize. When there are no references to this object anymore
+         then the garbage collector calls this method. Thereby causing the adapter object
+         to be notified. The adapter, in turn, notifies all listeners (com.sun.star.uno.XReference)
+      */
+     protected void finalize() throws java.lang.Throwable {
+        if (m_adapter != null)
+            m_adapter.referentDying();
+        super.finalize();
+     }
+
+     /** Method of XTypeProvider. It returns an array of Type objects which represent
+      * all implemented UNO interfaces of this object.
+      * @return Type objects of all implemented interfaces.
+      */
+     public Type[] getTypes() {
+        Vector vec= new Vector();
+        Class currentClass= getClass();
+        do {
+            Class interfaces[]= currentClass.getInterfaces();
+            for(int i = 0; i < interfaces.length; ++ i) {
+                // Test if it is a UNO interface, look for
+                //    public static final com.sun.star.lib.uno.typeinfo.TypeInfo UNOTYPEINFO[]
+                try{
+                    Field unoField= interfaces[i].getField(UNO_INTERFACE_FIELD);
+                    if (unoField.getType().getName().equals(UNO_INTERFACE_TYPE)) {
+                        vec.add(new Type(interfaces[i]));
+                    }
+                }catch (NoSuchFieldException nfe) {
+                }
+            }
+            // get the superclass the currentClass inherits from
+            currentClass= currentClass.getSuperclass();
+        } while (currentClass != null);
+
+        Type types[]= new Type[vec.size()];
+        for( int i= 0; i < types.length; i++)
+           types[i]= (Type) vec.elementAt(i);
+
+        return types;
+     }
+
+     /** Method of XTypeProvider. It provides an identifier that represents the set of UNO
+      * interfaces implemented by this class. All instances of this class
+      * which run in the same Java Virtual Machine return the same array. (This only works as long
+      * the ClassLoader preserves the class even if no instance exist.)
+      *@return identifier as array of bytes
+      */
+     synchronized public byte[] getImplementationId() {
+         if (_implementationId == null) {
+            int hash = hashCode();
+            String sName= getClass().getName();
+            byte[] arName= sName.getBytes();
+            int nNameLength= arName.length;
+
+            _implementationId= new byte[ 4 + nNameLength];
+            _implementationId[0] = (byte)(hash & 0xff);
+            _implementationId[1] = (byte)((hash >>> 8) & 0xff);
+            _implementationId[2] = (byte)((hash >>> 16) & 0xff);
+            _implementationId[3] = (byte)((hash >>>24) & 0xff);
+
+            for (int i= 0; i < nNameLength; i++) {
+                _implementationId[4 + i]= arName[i];
+            }
+        }
+        return _implementationId;
+     }
+}
diff --git a/javaunohelper/com/sun/star/lib/uno/helper/makefile.mk b/javaunohelper/com/sun/star/lib/uno/helper/makefile.mk
new file mode 100644
index 000000000000..53fd75af7c0e
--- /dev/null
+++ b/javaunohelper/com/sun/star/lib/uno/helper/makefile.mk
@@ -0,0 +1,86 @@
+#*************************************************************************
+#
+#   $RCSfile: makefile.mk,v $
+#
+#   $Revision: 1.1 $
+#
+#   last change: $Author: jl $ $Date: 2002-04-11 13:39:51 $
+#
+#   The Contents of this file are made available subject to the terms of
+#   either of the following licenses
+#
+#          - GNU Lesser General Public License Version 2.1
+#          - Sun Industry Standards Source License Version 1.1
+#
+#   Sun Microsystems Inc., October, 2000
+#
+#   GNU Lesser General Public License Version 2.1
+#   =============================================
+#   Copyright 2000 by Sun Microsystems, Inc.
+#   901 San Antonio Road, Palo Alto, CA 94303, USA
+#
+#   This library is free software; you can redistribute it and/or
+#   modify it under the terms of the GNU Lesser General Public
+#   License version 2.1, as published by the Free Software Foundation.
+#
+#   This library is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#   Lesser General Public License for more details.
+#
+#   You should have received a copy of the GNU Lesser General Public
+#   License along with this library; if not, write to the Free Software
+#   Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+#   MA  02111-1307  USA
+#
+#
+#   Sun Industry Standards Source License Version 1.1
+#   =================================================
+#   The contents of this file are subject to the Sun Industry Standards
+#   Source License Version 1.1 (the "License"); You may not use this file
+#   except in compliance with the License. You may obtain a copy of the
+#   License at http://www.openoffice.org/license.html.
+#
+#   Software provided under this License is provided on an "AS IS" basis,
+#   WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+#   WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+#   MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+#   See the License for the specific provisions governing your rights and
+#   obligations concerning the Software.
+#
+#   The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+#
+#   Copyright: 2000 by Sun Microsystems, Inc.
+#
+#   All Rights Reserved.
+#
+#   Contributor(s): _______________________________________
+#
+#
+#
+#*************************************************************************
+
+PRJ=..$/..$/..$/..$/..$/..
+
+PRJNAME = juhelper
+PACKAGE = com$/sun$/star$/lib$/uno$/helper
+TARGET  = com_sun_star_lib_uno_helper
+
+
+# --- Settings -----------------------------------------------------
+.INCLUDE : $(PRJ)$/util$/makefile.pmk
+
+# Files --------------------------------------------------------
+JARFILES = sandbox.jar ridl.jar jurt.jar unoil.jar
+
+
+JAVACLASSFILES= \
+    $(CLASSDIR)$/$(PACKAGE)$/WeakBase.class 	\
+        $(CLASSDIR)$/$(PACKAGE)$/WeakAdapter.class  	\
+    $(CLASSDIR)$/$(PACKAGE)$/ComponentBase.class		\
+    $(CLASSDIR)$/$(PACKAGE)$/InterfaceContainer.class	\
+    $(CLASSDIR)$/$(PACKAGE)$/MultiTypeInterfaceContainer.class
+# --- Targets ------------------------------------------------------
+
+.INCLUDE :  target.mk
+