diff --git a/configmgr/inc/pch/precompiled_configmgr.hxx b/configmgr/inc/pch/precompiled_configmgr.hxx
index d67a23b..9ebd156 100644
--- configmgr/inc/pch/precompiled_configmgr.hxx
+++ configmgr/inc/pch/precompiled_configmgr.hxx
@@ -247,7 +247,7 @@
 #include "salhelper/simplereferenceobject.hxx"
 #include "osl/socket.hxx"
 #include "osl/thread.hxx"
-#include "vos/timer.hxx"
+#include "salhelper/timer.hxx"
 //---MARKER---
 
 #endif
diff --git a/configmgr/source/treecache/cachewritescheduler.hxx b/configmgr/source/treecache/cachewritescheduler.hxx
index 26e5e03..faa4cf9 100644
--- configmgr/source/treecache/cachewritescheduler.hxx
+++ configmgr/source/treecache/cachewritescheduler.hxx
@@ -51,8 +51,8 @@
 #define INCLUDED_SET
 #endif
 
-#ifndef _VOS_TIMER_HXX_
-#include <vos/timer.hxx>
+#ifndef _SALHELPER_TIMER_HXX_
+#include <salhelper/timer.hxx>
 #endif
 #ifndef _RTL_REF_HXX_
 #include <rtl/ref.hxx>
@@ -74,14 +74,14 @@ namespace configmgr
 	{
 		typedef std::set< RequestOptions, lessRequestOptions > CacheWriteList; // fire and forget!
 
-		class Timer : public vos::OTimer
+		class Timer : public salhelper::Timer
 		{
 		public:
 			OCacheWriteScheduler* pParent;
 
 			Timer(OCacheWriteScheduler& _rParent) : pParent(&_rParent) {};
 
-			// vos::OTimer
+			// salhelper::Timer
 			virtual void SAL_CALL onShot();
 
 			// stop the scheduling
@@ -130,7 +130,7 @@ namespace configmgr
 		/// stop and discard pending activities
 		void stopAndWriteCache();
 	private:
-		// vos::OTimer
+		// salhelper::Timer
 		void onTimerShot();
 
 		void runWriter();
diff --git a/configmgr/source/treecache/disposetimer.cxx b/configmgr/source/treecache/disposetimer.cxx
index df23693..e81f959 100644
--- configmgr/source/treecache/disposetimer.cxx
+++ configmgr/source/treecache/disposetimer.cxx
@@ -283,7 +283,7 @@ TimeStamp OTreeDisposeScheduler::runDisposer(TimeStamp const& _aActualTime)
 // -------------------------------------------------------------------------
 
 static inline
-TimeStamp getExpirationTime( vos::OTimer const& aTimer )
+TimeStamp getExpirationTime( salhelper::Timer const& aTimer )
 {
     OSL_ENSURE(aTimer.isTicking(), "Timer is already expired !");
 
@@ -299,9 +299,9 @@ TimeStamp getExpirationTime( vos::OTimer const& aTimer )
 
 #if OSL_DEBUG_LEVEL > 0
 static
-void checkTimerStarted( vos::OTimer const& aTimer, TimeStamp const& _aLimit)
+void checkTimerStarted( salhelper::Timer const& aTimer, TimeStamp const& _aLimit)
 {
-    const TimeInterval tolerance( vos::TTimeValue(1) ); // milliseconds
+    const TimeInterval tolerance( salhelper::TTimeValue(1) ); // milliseconds
     if (aTimer.isTicking())
     {
         TimeStamp   const    expires = getExpirationTime(aTimer);
diff --git a/configmgr/source/treecache/disposetimer.hxx b/configmgr/source/treecache/disposetimer.hxx
index a61eaa0..8d188bb 100644
--- configmgr/source/treecache/disposetimer.hxx
+++ configmgr/source/treecache/disposetimer.hxx
@@ -47,8 +47,8 @@
 #include <osl/mutex.hxx>
 #endif
 
-#ifndef _VOS_TIMER_HXX_
-#include <vos/timer.hxx>
+#ifndef _SALHELPER_TIMER_HXX_
+#include <salhelper/timer.hxx>
 #endif
 #ifndef _RTL_REF_HXX_
 #include <rtl/ref.hxx>
@@ -86,14 +86,14 @@ namespace configmgr
 		typedef std::multimap< TimeStamp, RequestOptions, ltTimeStamp > Agenda;
         typedef backend::CacheController CacheManager;
 
-		class Timer : public vos::OTimer
+		class Timer : public salhelper::Timer
 		{
 		public:
 			OTreeDisposeScheduler* pParent;
 
 			Timer(OTreeDisposeScheduler& _rParent) : pParent(&_rParent) {};
 
-			// vos::OTimer
+			// salhelper::Timer
 			virtual void SAL_CALL onShot();
 
 			// stop the scheduling
@@ -173,7 +173,7 @@ namespace configmgr
 		void stopAndClearTasks();
 
 	private:
-		// vos::OTimer
+		// salhelper::Timer
 		void onTimerShot();
 
         typedef std::pair<bool,RequestOptions> Task;
diff --git a/configmgr/source/treecache/timestamp.hxx b/configmgr/source/treecache/timestamp.hxx
index 293ecad..0cbcf0d 100644
--- configmgr/source/treecache/timestamp.hxx
+++ configmgr/source/treecache/timestamp.hxx
@@ -36,7 +36,7 @@
 #ifndef CONFIGMGR_TIMESTAMP_HXX
 #define CONFIGMGR_TIMESTAMP_HXX
 
-#include <vos/timer.hxx>
+#include <salhelper/timer.hxx>
 
 namespace configmgr
 {
@@ -44,7 +44,7 @@ namespace configmgr
 
 	class TimeInterval
 	{
-		vos::TTimeValue m_aTime;
+		salhelper::TTimeValue m_aTime;
 	public:
 		TimeInterval() : m_aTime()
 		{}
@@ -59,13 +59,13 @@ namespace configmgr
 
 		sal_Bool isEmpty() const { return m_aTime.isEmpty(); }
 
-		vos::TTimeValue const& getTimeValue() const { return m_aTime; }
+		salhelper::TTimeValue const& getTimeValue() const { return m_aTime; }
 	};	
 ////////////////////////////////////////////////////////////////////////////////
 
 	class TimeStamp
 	{
-		vos::TTimeValue m_aTime;
+		salhelper::TTimeValue m_aTime;
 	public:
 		TimeStamp() : m_aTime()
 		{}
@@ -77,7 +77,7 @@ namespace configmgr
 		TimeStamp& operator += (TimeInterval const& aInterval)
 		{ m_aTime.addTime(aInterval.getTimeValue()); return *this; }
 
-		vos::TTimeValue const& getTimeValue() const { return m_aTime; }
+		salhelper::TTimeValue const& getTimeValue() const { return m_aTime; }
 
 		sal_Bool isNever() const;
 
diff --git a/connectivity/inc/pch/precompiled_connectivity.hxx b/connectivity/inc/pch/precompiled_connectivity.hxx
index 67dd6dc..9dd4961 100644
--- connectivity/inc/pch/precompiled_connectivity.hxx
+++ connectivity/inc/pch/precompiled_connectivity.hxx
@@ -335,7 +335,7 @@
 #include "rtl/ref.hxx"
 #include "rtl/ref.hxx"		
 #include "salhelper/simplereferenceobject.hxx"
-#include "vos/timer.hxx"
+#include "salhelper/timer.hxx"
 //---MARKER---
 
 #endif
diff --git a/connectivity/source/cpool/ZConnectionPool.cxx b/connectivity/source/cpool/ZConnectionPool.cxx
index da0e3e7..20ec0d6 100644
--- connectivity/source/cpool/ZConnectionPool.cxx
+++ connectivity/source/cpool/ZConnectionPool.cxx
@@ -125,7 +125,7 @@ OConnectionPool::OConnectionPool(const Reference< XDriver >& _xDriver,
 	OPoolCollection::getNodeValue(getTimeoutNodeName(),m_xDriverNode) >>= m_nALiveCount;
 	calculateTimeOuts();
 	
-	m_xInvalidator = new OPoolTimer(this,::vos::TTimeValue(m_nTimeOut,0));
+	m_xInvalidator = new OPoolTimer(this,::salhelper::TTimeValue(m_nTimeOut,0));
 	m_xInvalidator->start();
 }
 // -----------------------------------------------------------------------------
diff --git a/connectivity/source/cpool/ZConnectionPool.hxx b/connectivity/source/cpool/ZConnectionPool.hxx
index ddc240d..444def7 100644
--- connectivity/source/cpool/ZConnectionPool.hxx
+++ connectivity/source/cpool/ZConnectionPool.hxx
@@ -65,8 +65,8 @@
 #ifndef _OSL_MUTEX_HXX_
 #include <osl/mutex.hxx>
 #endif
-#ifndef _VOS_TIMER_HXX_ 
-#include <vos/timer.hxx>
+#ifndef _SALHELPER_TIMER_HXX_
+#include <salhelper/timer.hxx>
 #endif
 #ifndef _RTL_REF_HXX_
 #include <rtl/ref.hxx>
@@ -81,12 +81,12 @@ namespace connectivity
 	//==========================================================================
 	/// OPoolTimer - Invalidates the connection pool
 	//==========================================================================
-	class OPoolTimer : public ::vos::OTimer
+	class OPoolTimer : public ::salhelper::Timer
 	{
 		OConnectionPool* m_pPool;
 	public:
-		OPoolTimer(OConnectionPool* _pPool,const ::vos::TTimeValue& _Time) 
-			: ::vos::OTimer(_Time)
+		OPoolTimer(OConnectionPool* _pPool,const ::salhelper::TTimeValue& _Time) 
+			: ::salhelper::Timer(_Time)
 			,m_pPool(_pPool)
 		{}
 	protected:
diff --git a/connectivity/source/cpool/makefile.mk b/connectivity/source/cpool/makefile.mk
index 3a2b263..c7f7ee2 100644
--- connectivity/source/cpool/makefile.mk
+++ connectivity/source/cpool/makefile.mk
@@ -72,7 +72,8 @@ SHL1STDLIBS=\
 	$(VOSLIB)					\
 	$(COMPHELPERLIB)			\
 	$(DBTOOLSLIB)				\
-	$(SALLIB)
+	$(SALLIB)				\
+	$(SALHELPERLIB)
 
 SHL1DEPN=
 SHL1IMPLIB=	i$(SHL1TARGET)
diff --git a/extensions/inc/pch/precompiled_extensions.hxx b/extensions/inc/pch/precompiled_extensions.hxx
index 49b59cb..603afc5 100644
--- extensions/inc/pch/precompiled_extensions.hxx
+++ extensions/inc/pch/precompiled_extensions.hxx
@@ -552,7 +552,7 @@
 #include "rtl/ref.hxx"
 #include "salhelper/simplereferenceobject.hxx"
 #include "osl/thread.hxx"
-#include "vos/timer.hxx"
+#include "salhelper/timer.hxx"
 
 #include "xmloff/nmspmap.hxx"
 //---MARKER---
diff --git a/extensions/source/plugin/base/xplugin.cxx b/extensions/source/plugin/base/xplugin.cxx
index ea1e8d9..9707561 100644
--- extensions/source/plugin/base/xplugin.cxx
+++ extensions/source/plugin/base/xplugin.cxx
@@ -55,7 +55,7 @@
 #include <tools/urlobj.hxx>
 #include <tools/string.hxx>
 #include <vcl/svapp.hxx>
-#include <vos/timer.hxx>
+#include <salhelper/timer.hxx>
 #include <osl/file.hxx>
 
 #ifdef UNX
@@ -74,7 +74,7 @@ using namespace com::sun::star::plugin;
 using namespace rtl;
 using namespace osl;
 
-class PluginDisposer : public vos::OTimer
+class PluginDisposer : public salhelper::Timer
 {
 private:
     XPlugin_Impl*       m_pPlugin;
@@ -82,8 +82,7 @@ private:
     virtual void SAL_CALL onShot();
 public:
     PluginDisposer( XPlugin_Impl* pPlugin ) :
-        OTimer( vos::TTimeValue( 2, 0 ),
-                vos::TTimeValue( 2, 0 ) ),
+        salhelper::Timer( salhelper::TTimeValue( 2, 0 ), salhelper::TTimeValue( 2, 0 ) ),
         m_pPlugin( pPlugin )
         { start(); }
     ~PluginDisposer() {}
diff --git a/extensions/source/plugin/util/makefile.mk b/extensions/source/plugin/util/makefile.mk
index 2465658..6f3512f 100644
--- extensions/source/plugin/util/makefile.mk
+++ extensions/source/plugin/util/makefile.mk
@@ -98,7 +98,8 @@ SHL1STDLIBS+= \
 	$(UCBHELPERLIB)		\
 	$(CPPUHELPERLIB)	\
 	$(CPPULIB)			\
-	$(SALLIB)
+	$(SALLIB)			\
+	$(SALHELPERLIB)
 
 .IF "$(OS)"=="MACOSX" && "$(GUIBASE)"=="unx"
 SHL1STDLIBS+= -lX11
diff --git a/framework/inc/helper/timerhelper.hxx b/framework/inc/helper/timerhelper.hxx
index 13fcd64..2814800 100644
--- framework/inc/helper/timerhelper.hxx
+++ framework/inc/helper/timerhelper.hxx
@@ -40,8 +40,8 @@
 #include <threadhelp/threadhelpbase.hxx>
 #endif
 
-#ifndef _VOS_TIMER_HXX_
-#include <vos/timer.hxx>
+#ifndef _SALHELPER_TIMER_HXX_
+#include <salhelper/timer.hxx>
 #endif
 
 #ifndef _OSL_MUTEX_HXX_
@@ -68,13 +68,13 @@ namespace framework
 	/** implements a timer
 	*/
     class OTimerHelper : private ThreadHelpBase
-                       , public ::vos::OTimer
+                       , public ::salhelper::Timer
 	{
 	protected:
 		ITimerListener*	m_pListener;
 
 	public:
-        OTimerHelper( const ::vos::TTimeValue& _rExpireTime );
+        OTimerHelper( const ::salhelper::TTimeValue& _rExpireTime );
 
 		// the link set here will be called with m_rMutex acquired
         void            setListener( ITimerListener* _pListener )       { m_pListener = _pListener; }
diff --git a/framework/inc/pch/precompiled_framework.hxx b/framework/inc/pch/precompiled_framework.hxx
index dfb58b7..6e25f90 100644
--- framework/inc/pch/precompiled_framework.hxx
+++ framework/inc/pch/precompiled_framework.hxx
@@ -496,7 +496,7 @@
 #include "osl/mutex.hxx"
 #include "rtl/ref.hxx"
 #include "osl/thread.hxx"
-#include "vos/timer.hxx"
+#include "salhelper/timer.hxx"
 
 //---MARKER---
 #endif
diff --git a/framework/source/helper/timerhelper.cxx b/framework/source/helper/timerhelper.cxx
index a955d23..bcec53a 100644
--- framework/source/helper/timerhelper.cxx
+++ framework/source/helper/timerhelper.cxx
@@ -57,9 +57,9 @@ namespace framework
 	//= OTimerHelper
 	//====================================================================
 	//--------------------------------------------------------------------
-    OTimerHelper::OTimerHelper( const ::vos::TTimeValue& _rExpireTime  )
-        : ThreadHelpBase ( &Application::GetSolarMutex()    )
-        , OTimer         ( _rExpireTime                     )
+    OTimerHelper::OTimerHelper( const ::salhelper::TTimeValue& _rExpireTime  )
+        : ThreadHelpBase  ( &Application::GetSolarMutex()    )
+        , salhelper::Timer( _rExpireTime                     )
 	{
 	}
 
diff --git a/framework/util/makefile.mk b/framework/util/makefile.mk
index bf5bb39..70230ea 100644
--- framework/util/makefile.mk
+++ framework/util/makefile.mk
@@ -348,6 +348,7 @@ SHL4STDLIBS=	\
 				$(CPPULIB)							\
 				$(VOSLIB)							\
 				$(SALLIB)					        \
+				$(SALHELPERLIB)					        \
 				$(UCBHELPERLIB)
 
 SHL4DEF=		$(MISC)$/$(SHL4TARGET).def
diff --git a/goodies/inc/pch/precompiled_goodies.hxx b/goodies/inc/pch/precompiled_goodies.hxx
index 92e927b..4558988 100644
--- goodies/inc/pch/precompiled_goodies.hxx
+++ goodies/inc/pch/precompiled_goodies.hxx
@@ -176,7 +176,7 @@
 
 #include "sal/macros.h"
 #include "osl/mutex.hxx"
-#include "vos/timer.hxx"
+#include "salhelper/timer.hxx"
 //---MARKER---
 
 #endif
diff --git a/goodies/source/graphic/grfcache.cxx b/goodies/source/graphic/grfcache.cxx
index d67a403..2e3f069 100644
--- goodies/source/graphic/grfcache.cxx
+++ goodies/source/graphic/grfcache.cxx
@@ -36,7 +36,7 @@
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_goodies.hxx"
 
-#include <vos/timer.hxx>
+#include <salhelper/timer.hxx>
 #include <tools/debug.hxx>
 #include <vcl/outdev.hxx>
 #include <tools/poly.hxx>
@@ -415,7 +415,7 @@ class GraphicDisplayCacheEntry
 {
 private:
 
-	::vos::TTimeValue           maReleaseTime;
+	::salhelper::TTimeValue           maReleaseTime;
     const GraphicCacheEntry*	mpRefCacheEntry;
 	GDIMetaFile*				mpMtf;
 	BitmapEx*					mpBmpEx;
@@ -468,8 +468,8 @@ public:
     const ULONG					GetOutDevDrawMode() const { return mnOutDevDrawMode; }
     const USHORT				GetOutDevBitCount()	const { return mnOutDevBitCount; }
     
-    void                        SetReleaseTime( const ::vos::TTimeValue& rReleaseTime ) { maReleaseTime = rReleaseTime; }
-    const ::vos::TTimeValue&    GetReleaseTime() const { return maReleaseTime; }
+    void                        SetReleaseTime( const ::salhelper::TTimeValue& rReleaseTime ) { maReleaseTime = rReleaseTime; }
+    const ::salhelper::TTimeValue&    GetReleaseTime() const { return maReleaseTime; }
 								
 	BOOL						Matches( OutputDevice* pOut, const Point& /*rPtPixel*/, const Size& rSzPixel,
 										 const GraphicCacheEntry* pCacheEntry, const GraphicAttr& rAttr ) const
@@ -774,12 +774,12 @@ void GraphicCache::SetCacheTimeout( ULONG nTimeoutSeconds )
     if( mnReleaseTimeoutSeconds != nTimeoutSeconds )
     {
         GraphicDisplayCacheEntry*   pDisplayEntry = (GraphicDisplayCacheEntry*) maDisplayCache.First();
-        ::vos::TTimeValue           aReleaseTime;
+        ::salhelper::TTimeValue           aReleaseTime;
 
         if( ( mnReleaseTimeoutSeconds = nTimeoutSeconds ) != 0 )
         {
             osl_getSystemTime( &aReleaseTime );
-            aReleaseTime.addTime( ::vos::TTimeValue( nTimeoutSeconds, 0 ) );
+            aReleaseTime.addTime( ::salhelper::TTimeValue( nTimeoutSeconds, 0 ) );
         }
 
 	    while( pDisplayEntry )
@@ -870,10 +870,10 @@ BOOL GraphicCache::CreateDisplayCacheObj( OutputDevice* pOut, const Point& rPt,
 
         if( GetCacheTimeout() )
         {
-            ::vos::TTimeValue aReleaseTime;
+            ::salhelper::TTimeValue aReleaseTime;
 
             osl_getSystemTime( &aReleaseTime );
-            aReleaseTime.addTime( ::vos::TTimeValue( GetCacheTimeout(), 0 ) );
+            aReleaseTime.addTime( ::salhelper::TTimeValue( GetCacheTimeout(), 0 ) );
             pNewEntry->SetReleaseTime( aReleaseTime );
         }
 																			
@@ -904,10 +904,10 @@ BOOL GraphicCache::CreateDisplayCacheObj( OutputDevice* pOut, const Point& rPt,
 
         if( GetCacheTimeout() )
         {
-            ::vos::TTimeValue aReleaseTime;
+            ::salhelper::TTimeValue aReleaseTime;
 
             osl_getSystemTime( &aReleaseTime );
-            aReleaseTime.addTime( ::vos::TTimeValue( GetCacheTimeout(), 0 ) );
+            aReleaseTime.addTime( ::salhelper::TTimeValue( GetCacheTimeout(), 0 ) );
             pNewEntry->SetReleaseTime( aReleaseTime );
         }
 																			
@@ -934,7 +934,7 @@ BOOL GraphicCache::DrawDisplayCacheObj( OutputDevice* pOut, const Point& rPt, co
 	{
 		if( pDisplayCacheEntry->Matches( pOut, aPtPixel, aSzPixel, pCacheEntry, rAttr ) )
 		{
-            ::vos::TTimeValue aReleaseTime;
+            ::salhelper::TTimeValue aReleaseTime;
 
 			// put found object at last used position
 			maDisplayCache.Insert( maDisplayCache.Remove( pDisplayCacheEntry ), LIST_APPEND );
@@ -942,7 +942,7 @@ BOOL GraphicCache::DrawDisplayCacheObj( OutputDevice* pOut, const Point& rPt, co
             if( GetCacheTimeout() )
             {
                 osl_getSystemTime( &aReleaseTime );
-                aReleaseTime.addTime( ::vos::TTimeValue( GetCacheTimeout(), 0 ) );
+                aReleaseTime.addTime( ::salhelper::TTimeValue( GetCacheTimeout(), 0 ) );
             }
 
             pDisplayCacheEntry->SetReleaseTime( aReleaseTime );
@@ -1009,14 +1009,14 @@ IMPL_LINK( GraphicCache, ReleaseTimeoutHdl, Timer*, pTimer )
 {
     pTimer->Stop();
 
-    ::vos::TTimeValue           aCurTime;
+    ::salhelper::TTimeValue           aCurTime;
 	GraphicDisplayCacheEntry*   pDisplayEntry = (GraphicDisplayCacheEntry*) maDisplayCache.First();
 
     osl_getSystemTime( &aCurTime );
 
 	while( pDisplayEntry )
 	{
-        const ::vos::TTimeValue& rReleaseTime = pDisplayEntry->GetReleaseTime();
+        const ::salhelper::TTimeValue& rReleaseTime = pDisplayEntry->GetReleaseTime();
 
 		if( !rReleaseTime.isEmpty() && ( rReleaseTime < aCurTime ) )
 		{
diff --git a/salhelper/inc/salhelper/timer.hxx b/salhelper/inc/salhelper/timer.hxx
new file mode 100644
index 0000000..56631d7
--- /dev/null
+++ salhelper/inc/salhelper/timer.hxx
@@ -0,0 +1,247 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: timer.hxx,v $
+ *
+ *  $Revision: 1.3 $
+ *
+ *  last change: $Author: vg $ $Date: 2006/06/02 12:40:52 $
+ *
+ *  The Contents of this file are made available subject to
+ *  the terms of GNU Lesser General Public License Version 2.1.
+ *
+ *
+ *    GNU Lesser General Public License Version 2.1
+ *    =============================================
+ *    Copyright 2005 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
+ *
+ ************************************************************************/
+
+
+#ifndef _SALHELPER_TIMER_HXX_
+#define _SALHELPER_TIMER_HXX_
+
+#ifndef _SALHELPER_SIMPMLEREFERENCEOBJECT_HXX_
+#	include <salhelper/simplereferenceobject.hxx>
+#endif
+#ifndef _OSL_TIME_H_
+#	include <osl/time.h>
+#endif
+
+namespace salhelper
+{
+
+/** Helper class for easier manipulation with TimeValue.
+ *
+ *  Times are seconds in UTC since 01.01.1970
+ */
+struct TTimeValue : public TimeValue
+{
+    TTimeValue()
+    {
+        Seconds = 0;
+        Nanosec = 0;
+    }
+
+    TTimeValue( sal_uInt32 Secs, sal_uInt32 Nano )
+    {
+        Seconds = Secs;
+        Nanosec = Nano;
+
+        normalize();
+    }
+
+    TTimeValue(sal_uInt32 MilliSecs)
+    {
+        Seconds = MilliSecs / 1000L;
+        Nanosec = (MilliSecs % 1000) * 1000000L;
+
+        normalize();
+    }
+
+    TTimeValue( const TTimeValue& rTimeValue )
+    {
+        Seconds = rTimeValue.Seconds;
+        Nanosec = rTimeValue.Nanosec;
+
+        normalize();
+    }
+
+    TTimeValue( const TimeValue& rTimeValue )
+    {
+        Seconds = rTimeValue.Seconds;
+        Nanosec = rTimeValue.Nanosec;
+
+        normalize();
+    }
+
+    void SAL_CALL normalize()
+    {
+        if ( Nanosec > 1000000000 )
+        {
+            Seconds += Nanosec / 1000000000;
+            Nanosec %= 1000000000;
+        }
+    }
+
+    void SAL_CALL addTime( const TTimeValue& Delta )
+    {
+        Seconds += Delta.Seconds;
+        Nanosec += Delta.Nanosec;
+
+        normalize();
+    }
+
+    sal_Bool SAL_CALL isEmpty() const
+    {
+        return ( ( Seconds == 0 ) && ( Nanosec == 0 ) );
+    }
+};
+
+inline sal_Bool operator<( const TTimeValue& rTimeA, const TTimeValue& rTimeB )
+{
+    if ( rTimeA.Seconds < rTimeB.Seconds )
+        return sal_True;
+    else if ( rTimeA.Seconds > rTimeB.Seconds )
+        return sal_False;
+    else
+        return ( rTimeA.Nanosec < rTimeB.Nanosec );
+}
+
+inline sal_Bool operator>( const TTimeValue& rTimeA, const TTimeValue& rTimeB )
+{
+    if ( rTimeA.Seconds > rTimeB.Seconds )
+        return sal_True;
+    else if ( rTimeA.Seconds < rTimeB.Seconds )
+        return sal_False;
+    else
+        return ( rTimeA.Nanosec > rTimeB.Nanosec );
+}
+
+inline sal_Bool operator==( const TTimeValue& rTimeA, const TTimeValue& rTimeB )
+{
+    return ( ( rTimeA.Seconds == rTimeB.Seconds ) &&
+             ( rTimeA.Nanosec == rTimeB.Nanosec ) );
+}
+
+class TimerManager;
+
+/** Interface for the Timer and handling the event
+*/
+class Timer : public salhelper::SimpleReferenceObject
+{
+public:
+
+    /** Constructor.
+     */
+  	Timer();
+
+	/** Constructor.
+     */
+  	Timer( const TTimeValue& Time );
+
+	/** Constructor.
+     */
+  	Timer( const TTimeValue& Time, const TTimeValue& RepeatTime );
+
+  	/** Start timer.
+     */
+  	void        SAL_CALL start();
+
+  	/** Abort timer prematurely.
+     */
+  	void        SAL_CALL stop();
+
+  	/** Returns sal_True if timer is running.
+     */
+  	sal_Bool    SAL_CALL isTicking() const;
+
+	/** Is the timer expired?
+     */
+  	sal_Bool    SAL_CALL isExpired() const;
+
+	/** Does pTimer expires before us?
+     */
+  	sal_Bool    SAL_CALL expiresBefore( const Timer* pTimer ) const;
+
+	/** Set the absolute time when the timer should fire.
+     */
+  	void        SAL_CALL setAbsoluteTime( const TTimeValue& Time );
+
+	/** Set the time to fire to 'now' + Remaining.
+     */
+  	void        SAL_CALL setRemainingTime( const TTimeValue& Remaining );
+
+	/** Set the time to fire to 'now' + Remaining with repeat interveal
+     * Repeat.
+     */
+  	void		SAL_CALL setRemainingTime( const TTimeValue& Remaining, const TTimeValue& Repeat );
+
+	/** Adds Time to the 'fire time'.
+     */
+  	void		SAL_CALL addTime( const TTimeValue& Time );
+
+	/** Returns the remaining time before timer expiration relative to now.
+     */
+  	TTimeValue  SAL_CALL getRemainingTime() const;
+
+protected:
+
+    /** Destructor.
+     */
+    virtual ~Timer();
+
+    /** What should be done when the 'timer fires'.
+     */
+    virtual void SAL_CALL onShot() = 0;
+
+protected:
+
+    /** holds (initial) exparation time of this timer.
+     */
+	TTimeValue  m_aTimeOut;
+
+    /** holds the time of exparation of this timer.
+     */
+	TTimeValue  m_aExpired;
+
+    /** holds the time interveal of successive expirations.
+     */
+	TTimeValue  m_aRepeatDelta;
+
+    /** Pointer to the next timer (to fire).
+     */
+  	Timer*      m_pNext;
+
+private:
+
+    /** Copy constructor disabled.
+     */
+    Timer( const Timer& rTimer );
+
+    /** Assignment operator disabled.
+     */
+    void SAL_CALL operator=( const Timer& rTimer );
+
+	friend class TimerManager;
+};
+
+}
+
+#endif  //_SALHELPER_TIMER_HXX_
diff --git a/salhelper/prj/d.lst b/salhelper/prj/d.lst
index 14f233d..192cb39 100644
--- salhelper/prj/d.lst
+++ salhelper/prj/d.lst
@@ -10,6 +10,7 @@ mkdir: %_DEST%\inc%_EXT%\salhelper
 ..\inc\salhelper\refobj.hxx %_DEST%\inc%_EXT%\salhelper\refobj.hxx
 ..\inc\salhelper\simplereferenceobject.hxx %_DEST%\inc%_EXT%\salhelper\simplereferenceobject.hxx
 ..\inc\salhelper\singletonref.hxx %_DEST%\inc%_EXT%\salhelper\singletonref.hxx
+..\inc\salhelper\timer.hxx %_DEST%\inc%_EXT%\salhelper\timer.hxx
 
 ..\%__SRC%\bin\salhelper*.dll %_DEST%\bin%_EXT%\salhelper*.dll
 ..\%__SRC%\lib\*salhelper*.lib %_DEST%\lib%_EXT%\*
diff --git a/salhelper/source/gcc3.map b/salhelper/source/gcc3.map
index 3968981..56a7316 100644
--- salhelper/source/gcc3.map
+++ salhelper/source/gcc3.map
@@ -77,4 +77,25 @@ UDK_3.1 {
 	_ZN9salhelper14ExtCommandLineD2Ev;
 	_ZNK9salhelper14ExtCommandLine13getCommandArgEjRN3rtl8OUStringE;
 	_ZNK9salhelper14ExtCommandLine18getCommandArgCountEv;
+
+	_ZN9salhelper5TimerC1ERKNS_10TTimeValueE;
+	_ZN9salhelper5TimerC1ERKNS_10TTimeValueES3_;
+	_ZN9salhelper5TimerC1Ev;
+	_ZN9salhelper5TimerC2ERKNS_10TTimeValueE;
+	_ZN9salhelper5TimerC2ERKNS_10TTimeValueES3_;
+	_ZN9salhelper5TimerC2Ev;
+	_ZN9salhelper5TimerD0Ev;
+	_ZN9salhelper5TimerD1Ev;
+	_ZN9salhelper5TimerD2Ev;
+	_ZN9salhelper5Timer5startEv;
+	_ZN9salhelper5Timer4stopEv;
+	_ZNK9salhelper5Timer9isTickingEv;
+	_ZNK9salhelper5Timer9isExpiredEv;
+	_ZNK9salhelper5Timer13expiresBeforeEPKS0_;
+	_ZN9salhelper5Timer15setAbsoluteTimeERKNS_10TTimeValueE;
+	_ZN9salhelper5Timer16setRemainingTimeERKNS_10TTimeValueE;
+	_ZN9salhelper5Timer16setRemainingTimeERKNS_10TTimeValueES3_;
+	_ZN9salhelper5Timer7addTimeERKNS_10TTimeValueE;
+	_ZNK9salhelper5Timer16getRemainingTimeEv;
+
 } UDK_3_0_0;
diff --git a/salhelper/source/makefile.mk b/salhelper/source/makefile.mk
index 0cbb6b7..860f645 100644
--- salhelper/source/makefile.mk
+++ salhelper/source/makefile.mk
@@ -55,7 +55,8 @@ SLOFILES=	\
 	$(SLO)$/condition.obj \
 	$(SLO)$/dynload.obj \
 	$(SLO)$/extcommandline.obj \
-	$(SLO)$/simplereferenceobject.obj
+	$(SLO)$/simplereferenceobject.obj \
+	$(SLO)$/timer.obj
 
 # SCO: the linker does know about weak symbols, but we can't ignore multiple defined symbols
 .IF "$(OS)"=="SCO" || "$(OS)$(COM)"=="OS2GCC"
diff --git a/salhelper/source/timer.cxx b/salhelper/source/timer.cxx
new file mode 100644
index 0000000..0770be2
--- /dev/null
+++ salhelper/source/timer.cxx
@@ -0,0 +1,494 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: timer.cxx,v $
+ *
+ *  $Revision: 1.6 $
+ *
+ *  last change: $Author: vg $ $Date: 2006/06/02 12:45:24 $
+ *
+ *  The Contents of this file are made available subject to
+ *  the terms of GNU Lesser General Public License Version 2.1.
+ *
+ *
+ *    GNU Lesser General Public License Version 2.1
+ *    =============================================
+ *    Copyright 2005 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
+ *
+ ************************************************************************/
+
+#include <salhelper/timer.hxx>
+
+#include <osl/diagnose.h>
+#include <salhelper/simplereferenceobject.hxx>
+#include <osl/thread.hxx>
+#include <osl/conditn.hxx>
+#include <osl/mutex.hxx>
+
+using namespace salhelper;
+
+class salhelper::TimerManager : public osl::Thread
+{
+    
+public:
+
+    ///
+  	TimerManager();
+    
+	///
+  	~TimerManager();
+    
+  	/// register timer
+    sal_Bool SAL_CALL registerTimer(salhelper::Timer* pTimer);
+
+  	/// unregister timer
+    sal_Bool SAL_CALL unregisterTimer(salhelper::Timer* pTimer);
+
+  	/// lookup timer
+    sal_Bool SAL_CALL lookupTimer(const salhelper::Timer* pTimer);
+
+	/// retrieves the "Singleton" TimerManager Instance
+	static TimerManager* SAL_CALL getTimerManager();
+
+    
+protected:
+    
+ 	/// worker-function of thread
+  	virtual void SAL_CALL run();
+
+    // Checking and triggering of a timer event
+    void SAL_CALL checkForTimeout();
+
+    // cleanup Method
+    virtual void SAL_CALL onTerminated();
+    
+  	// sorted-queue data
+  	salhelper::Timer*		m_pHead;
+    // List Protection
+    osl::Mutex					m_Lock;
+    // Signal the insertion of a timer
+    osl::Condition				m_notEmpty;
+
+    // Synchronize access to TimerManager
+	static osl::Mutex 			m_Access;
+
+    // "Singleton Pattern"
+    static salhelper::TimerManager* m_pManager;
+
+    friend class TimerManagerCleanup;
+    
+};
+
+using namespace salhelper;
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Timer class
+//
+
+Timer::Timer()
+    : m_aTimeOut( 0 ),
+      m_aExpired( 0 ),
+      m_aRepeatDelta( 0 ),
+      m_pNext( NULL )
+{
+}
+
+Timer::Timer( const TTimeValue& Time )
+    : m_aTimeOut( Time ),
+      m_aRepeatDelta( 0 ),
+      m_aExpired( 0 ),
+      m_pNext( NULL )
+{
+}
+
+Timer::Timer( const TTimeValue& Time, const TTimeValue& Repeat )
+    : m_aTimeOut( Time ),
+      m_aRepeatDelta( Repeat ),
+      m_aExpired( 0 ),
+      m_pNext( NULL )
+{
+}
+
+Timer::~Timer()
+{
+    stop();
+}
+
+void Timer::start()
+{
+    if (! isTicking())
+    {
+        if (! m_aTimeOut.isEmpty())
+            setRemainingTime(m_aTimeOut);
+
+        TimerManager *pManager = TimerManager::getTimerManager();
+
+        OSL_ASSERT(pManager);
+
+        if ( pManager != 0 )
+        {
+            pManager->registerTimer(this);
+        }
+    }
+}
+
+void Timer::stop()
+{
+    TimerManager *pManager = TimerManager::getTimerManager();
+
+    OSL_ASSERT(pManager);
+
+    if ( pManager != 0 )
+    {
+        pManager->unregisterTimer(this);
+    }
+}
+
+sal_Bool Timer::isTicking() const
+{
+    TimerManager *pManager = TimerManager::getTimerManager();
+
+    OSL_ASSERT(pManager);
+
+    if (pManager)
+        return pManager->lookupTimer(this);
+    else
+        return sal_False;
+
+}
+
+sal_Bool Timer::isExpired() const
+{
+    TTimeValue Now;
+
+    osl_getSystemTime(&Now);
+
+    return !(Now < m_aExpired);
+}
+
+sal_Bool Timer::expiresBefore(const Timer* pTimer) const
+{
+    OSL_ASSERT(pTimer);
+
+    if ( pTimer != 0 )
+    {
+        return m_aExpired < pTimer->m_aExpired;
+    }
+    else
+    {
+        return sal_False;
+    }
+}
+
+void Timer::setAbsoluteTime(const TTimeValue& Time)
+{
+    m_aTimeOut     = 0;
+    m_aExpired     = Time;
+    m_aRepeatDelta = 0;
+
+    m_aExpired.normalize();
+}
+
+void Timer::setRemainingTime(const TTimeValue& Remaining)
+{
+    osl_getSystemTime(&m_aExpired);
+
+    m_aExpired.addTime(Remaining);
+}
+
+void Timer::setRemainingTime(const TTimeValue& Remaining, const TTimeValue& Repeat)
+{
+    osl_getSystemTime(&m_aExpired);
+
+    m_aExpired.addTime(Remaining);
+
+    m_aRepeatDelta = Repeat;
+}
+
+void Timer::addTime(const TTimeValue& Delta)
+{
+    m_aExpired.addTime(Delta);
+}
+
+TTimeValue Timer::getRemainingTime() const
+{
+    TTimeValue Now;
+
+    osl_getSystemTime(&Now);
+
+    sal_Int32 secs = m_aExpired.Seconds - Now.Seconds;
+
+    if (secs < 0)
+        return TTimeValue(0, 0);
+
+    sal_Int32 nsecs = m_aExpired.Nanosec - Now.Nanosec;
+
+    if (nsecs < 0)
+    {
+        if (secs > 0)
+        {
+            secs  -= 1;
+            nsecs += 1000000000L;
+        }
+        else
+            return TTimeValue(0, 0);
+    }
+
+    return TTimeValue(secs, nsecs);
+}
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Timer manager
+//
+
+osl::Mutex salhelper::TimerManager::m_Access;
+TimerManager* salhelper::TimerManager::m_pManager = NULL;
+
+TimerManager::TimerManager()
+{
+    osl::MutexGuard Guard(&m_Access);
+
+    OSL_ASSERT(m_pManager == 0);
+
+    m_pManager = this;
+
+    m_pHead= 0;
+
+    m_notEmpty.reset();
+
+    // start thread
+    create();
+}
+
+TimerManager::~TimerManager()
+{
+    osl::MutexGuard Guard(&m_Access);
+
+    if ( m_pManager == this )
+        m_pManager = 0;
+}
+
+void TimerManager::onTerminated()
+{
+    delete this; // mfe: AAARRRGGGHHH!!!
+}
+    
+TimerManager* TimerManager::getTimerManager()
+{    
+    osl::MutexGuard Guard(&m_Access); 
+
+    if (! m_pManager)
+        new TimerManager;
+
+    return (m_pManager);
+}	
+
+sal_Bool TimerManager::registerTimer(Timer* pTimer)
+{
+    OSL_ASSERT(pTimer);
+
+    if ( pTimer == 0 )
+    {
+        return sal_False;
+    }
+
+    osl::MutexGuard Guard(&m_Lock);
+
+    // try to find one with equal or lower remaining time.
+    Timer** ppIter = &m_pHead;
+
+    while (*ppIter) 
+    {
+        if (pTimer->expiresBefore(*ppIter))
+        {	
+            // next element has higher remaining time, 
+            // => insert new timer before
+            break;
+        }
+        ppIter= &((*ppIter)->m_pNext);
+    } 
+
+    // next element has higher remaining time, 
+    // => insert new timer before
+    pTimer->m_pNext= *ppIter;
+    *ppIter = pTimer;
+
+
+    if (pTimer == m_pHead)
+    {
+        // it was inserted as new head
+        // signal it to TimerManager Thread
+        m_notEmpty.set();
+    }
+
+    return sal_True;
+}
+
+sal_Bool TimerManager::unregisterTimer(Timer* pTimer)
+{
+    OSL_ASSERT(pTimer);
+
+    if ( pTimer == 0 )
+    {
+        return sal_False;
+    }
+
+    // lock access
+    osl::MutexGuard Guard(&m_Lock);
+
+    Timer** ppIter = &m_pHead;
+
+    while (*ppIter) 
+    {
+        if (pTimer == (*ppIter))
+        {	
+            // remove timer from list
+            *ppIter = (*ppIter)->m_pNext;
+            return sal_True;
+        }
+        ppIter= &((*ppIter)->m_pNext);
+    } 
+
+    return sal_False;
+}
+
+sal_Bool TimerManager::lookupTimer(const Timer* pTimer) 
+{
+    OSL_ASSERT(pTimer);
+
+    if ( pTimer == 0 )
+    {
+        return sal_False;
+    }
+
+    // lock access
+    osl::MutexGuard Guard(&m_Lock);
+
+    // check the list
+    for (Timer* pIter = m_pHead; pIter != 0; pIter= pIter->m_pNext)
+    {
+        if (pIter == pTimer)
+        {    
+            return sal_True;
+        }
+    }
+
+    return sal_False;
+}
+
+void TimerManager::checkForTimeout()
+{
+
+    m_Lock.acquire();
+
+    if ( m_pHead == 0 )
+    {
+        m_Lock.release();        
+        return;
+    }
+
+    Timer* pTimer = m_pHead;
+
+    if (pTimer->isExpired())
+    {
+        // remove expired timer
+        m_pHead = pTimer->m_pNext;
+
+        pTimer->acquire();
+
+        m_Lock.release();
+
+        pTimer->onShot();
+
+        // restart timer if specified
+        if ( ! pTimer->m_aRepeatDelta.isEmpty() )
+        {
+            TTimeValue Now;
+
+            osl_getSystemTime(&Now);
+
+            Now.Seconds += pTimer->m_aRepeatDelta.Seconds;				
+            Now.Nanosec += pTimer->m_aRepeatDelta.Nanosec;				
+
+            pTimer->m_aExpired = Now;
+
+            registerTimer(pTimer);
+        }
+        pTimer->release();
+    }
+    else
+    {
+        m_Lock.release();
+    }
+
+
+    return;
+}
+
+void TimerManager::run() 
+{
+    setPriority( osl_Thread_PriorityBelowNormal );
+
+    while (schedule())
+    {
+        TTimeValue		delay;
+        TTimeValue*		pDelay=0;
+
+
+        m_Lock.acquire();
+
+        if (m_pHead != 0)
+        {
+            delay = m_pHead->getRemainingTime();
+            pDelay=&delay;
+        }
+        else
+        {
+            pDelay=0;
+        }
+
+
+        m_notEmpty.reset();
+
+        m_Lock.release();
+
+
+        m_notEmpty.wait(pDelay);
+
+        checkForTimeout();
+    }
+
+}
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Timer manager cleanup
+//
+
+// jbu:
+// The timer manager cleanup has been removed (no thread is killed anymore).
+// So the thread leaks.
+// This will result in a GPF in case the salhelper-library gets unloaded before
+// process termination.
+// -> TODO : rewrite this file, so that the timerManager thread gets destroyed,
+//           when there are no timers anymore !
diff --git a/svtools/inc/pch/precompiled_svtools.hxx b/svtools/inc/pch/precompiled_svtools.hxx
index f8e7c08..e9cc7c5 100644
--- svtools/inc/pch/precompiled_svtools.hxx
+++ svtools/inc/pch/precompiled_svtools.hxx
@@ -435,7 +435,7 @@
 #include <salhelper/simplereferenceobject.hxx>
 #include <osl/security.hxx>
 #include <osl/thread.hxx>
-#include <vos/timer.hxx>
+#include <salhelper/timer.hxx>
 
 //---MARKER---
 
diff --git a/svtools/source/contnr/fileview.cxx b/svtools/source/contnr/fileview.cxx
index bb1c3ec..a655b0d 100644
--- svtools/source/contnr/fileview.cxx
+++ svtools/source/contnr/fileview.cxx
@@ -141,8 +141,8 @@
 #ifndef _OSL_CONDITN_HXX_
 #include <osl/conditn.hxx>
 #endif
-#ifndef _VOS_TIMER_HXX_
-#include <vos/timer.hxx>
+#ifndef _SALHELPER_TIMER_HXX_
+#include <salhelper/timer.hxx>
 #endif
 
 #ifndef _SV_SVAPP_HXX
@@ -178,7 +178,7 @@ using namespace ::comphelper;
 using namespace ::ucbhelper;
 using ::svt::SortingData_Impl;
 using ::svt::FolderDescriptor;
-using ::vos::TTimeValue;
+using ::salhelper::TTimeValue;
 using ::rtl::OUString;
 
 #define ALL_FILES_FILTER    "*.*"
@@ -229,7 +229,7 @@ namespace
     //====================================================================
     //= CallbackTimer
     //====================================================================
-    class CallbackTimer : public ::vos::OTimer
+    class CallbackTimer : public ::salhelper::Timer
     {
     protected:
         ITimeoutHandler* m_pTimeoutHandler;
@@ -641,7 +641,7 @@ protected:
                                         m_pContentEnumerator;
     Link                                m_aCurrentAsyncActionHandler;
     ::osl::Condition                    m_aAsyncActionFinished;
-    ::rtl::Reference< ::vos::OTimer >   m_pCancelAsyncTimer;
+    ::rtl::Reference< ::salhelper::Timer >   m_pCancelAsyncTimer;
     ::svt::EnumerationResult            m_eAsyncActionResult;
     bool                                m_bRunningAsyncAction;
     bool                                m_bAsyncActionCancelled;
diff --git a/tools/inc/pch/precompiled_tools.hxx b/tools/inc/pch/precompiled_tools.hxx
index 4d115f3..c45f76c 100644
--- tools/inc/pch/precompiled_tools.hxx
+++ tools/inc/pch/precompiled_tools.hxx
@@ -94,6 +94,6 @@
 #include "sal/macros.h"
 #include "osl/mutex.hxx"
 #include "osl/signal.h"
-#include "vos/timer.hxx"
+#include "salhelper/timer.hxx"
 //---MARKER---
 #endif
