This software aims to create an applet and panel tools to manage a wireless interface card, such as

				//
				// Timer.cpp
				//
				// $Id: //poco/Main/Foundation/src/Timer.cpp#5 $
				//
				// Copyright (c) 2004, Guenter Obiltschnig/Applied Informatics.
				// All rights reserved.
				//
				// Redistribution and use in source and binary forms, with or without
				// modification, are permitted provided that the following conditions
				// are met:
				//
				// 1. Redistributions of source code must retain the above copyright
				//    notice, this list of conditions and the following disclaimer.
				//
				// 2. Redistributions in binary form must reproduce the above copyright
				//    notice, this list of conditions and the following disclaimer in the
				//    documentation and/or other materials provided with the distribution.
				//
				// 3. Redistributions in any form must be accompanied by information on
				//    how to obtain complete source code for this software and any
				//    accompanying software that uses this software.  The source code
				//    must either be included in the distribution or be available for no
				//    more than the cost of distribution plus a nominal fee, and must be
				//    freely redistributable under reasonable conditions.  For an
				//    executable file, complete source code means the source code for all
				//    modules it contains.  It does not include source code for modules or
				//    files that typically accompany the major components of the operating
				//    system on which the executable file runs.
				//
				// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
				// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
				// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
				// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
				// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
				// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
				// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
				// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
				// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
				// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
				// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
				// POSSIBILITY OF SUCH DAMAGE.
				//
				
				
				#include "Foundation/Timer.h"
				#include "Foundation/ThreadPool.h"
				#include "Foundation/Exception.h"
				
				
				Foundation_BEGIN
				
				
				Timer::Timer(long startInterval, long periodicInterval): 
					_startInterval(startInterval), 
					_periodicInterval(periodicInterval),
					_pCallback(0)
				{
					poco_assert (startInterval >= 0 && periodicInterval >= 0);
				}
				
				
				Timer::~Timer()
				{
					stop();
				}
				
				
				void Timer::start(const AbstractTimerCallback& method)
				{
					poco_assert (!_pCallback);
				
					FastMutex::ScopedLock lock(_mutex);	
					_pCallback = method.clone();
					_wakeUp.reset();
					ThreadPool::defaultPool().start(*this);
				}
				
				
				void Timer::stop()
				{
					FastMutex::ScopedLock lock(_mutex);
					if (_pCallback)
					{
						_periodicInterval = 0;
						_mutex.unlock();
						_wakeUp.set();
						_done.wait(); // warning: deadlock if called from timer callback
						_mutex.lock();
						delete _pCallback;
						_pCallback = 0;
					}
				}
				
				
				void Timer::restart()
				{
					FastMutex::ScopedLock lock(_mutex);
					if (_pCallback)
					{
						_wakeUp.set();
					}
				}
				
				
				void Timer::restart(long milliseconds)
				{
					poco_assert (milliseconds >= 0);
					FastMutex::ScopedLock lock(_mutex);
					if (_pCallback)
					{
						_periodicInterval = milliseconds;
						_wakeUp.set();
					}
				}
				
				
				long Timer::getStartInterval() const
				{
					FastMutex::ScopedLock lock(_mutex);
					return _startInterval;
				}
				
				
				void Timer::setStartInterval(long milliseconds)
				{
					poco_assert (milliseconds >= 0);
					FastMutex::ScopedLock lock(_mutex);
					_startInterval = milliseconds;
				}
				
				
				long Timer::getPeriodicInterval() const
				{
					FastMutex::ScopedLock lock(_mutex);
					return _periodicInterval;
				}
				
				
				void Timer::setPeriodicInterval(long milliseconds)
				{
					poco_assert (milliseconds >= 0);
					FastMutex::ScopedLock lock(_mutex);
					_periodicInterval = milliseconds;
				}
				
				
				void Timer::run()
				{
					long interval;
					{
						FastMutex::ScopedLock lock(_mutex);
						interval = _startInterval;
					}
					do
					{
						if (_wakeUp.tryWait(interval))
						{
							FastMutex::ScopedLock lock(_mutex);
							interval = _periodicInterval;
						}
						else
						{
							try
							{
								_pCallback->invoke(*this);
							}
							catch (std::exception& e)
							{
								poco_bugcheck_msg(e.what());
							}
							catch (...)
							{
								poco_bugcheck();
							}
							{
								FastMutex::ScopedLock lock(_mutex);
								interval = _periodicInterval;
							}
						}
					}
					while (interval > 0);
					_done.set();
				}
				
				
				AbstractTimerCallback::AbstractTimerCallback()
				{
				}
				
				
				AbstractTimerCallback::AbstractTimerCallback(const AbstractTimerCallback& callback)
				{
				}
				
				
				AbstractTimerCallback::~AbstractTimerCallback()
				{
				}
				
				
				AbstractTimerCallback& AbstractTimerCallback::operator = (const AbstractTimerCallback& callback)
				{
					return *this;
				}
				
				
				Foundation_END