[Terk-developer] embed/src/terkapi Chat.cpp, NONE, 1.1 Chat.h, NONE, 1.1

[Ivan D. <idr...@us...>]

Update of /cvsroot/terk/embed/src/terkapi
In directory sc8-pr-cvs10.sourceforge.net:/tmp/cvs-serv19949/src/terkapi

Added Files:
	Chat.cpp Chat.h 
Log Message:
recovering: adding more files

--- NEW FILE: Chat.cpp ---
// **********************************************************************
//
// Copyright (c) 2005 ZeroC, Inc. All rights reserved.
//
// This copy of Ice-E is licensed to you under the terms described in the
// ICEE_LICENSE file included in this distribution.
//
// **********************************************************************

// Ice-E version 1.0.0
// Generated from file `Chat.ice'

#include <Chat.h>
#include <IceE/LocalException.h>
#include <IceE/BasicStream.h>
#ifndef ICEE_PURE_CLIENT
#  include <IceE/Object.h>
#endif
#include <IceE/LocalException.h>

#ifndef ICEE_IGNORE_VERSION
#   if ICEE_INT_VERSION / 100 != 100
#       error IceE version mismatch!
#   endif
#   if ICEE_INT_VERSION % 100 < 0
#       error IceE patch level mismatch!
#   endif
#endif

#ifndef ICEE_PURE_CLIENT

void
IceInternal::incRef(::TeRK::Qwerk* p)
{
    p->__incRef();
}

void
IceInternal::decRef(::TeRK::Qwerk* p)
{
    p->__decRef();
}

#endif // ICEE_PURE_CLIENT

void
IceInternal::incRef(::IceProxy::TeRK::Qwerk* p)
{
    p->__incRef();
}

void
IceInternal::decRef(::IceProxy::TeRK::Qwerk* p)
{
    p->__decRef();
}

void
TeRK::__write(::IceInternal::BasicStream* __os, const ::TeRK::QwerkPrx& v)
{
    __os->write(::Ice::ObjectPrx(v));
}

void
TeRK::__read(::IceInternal::BasicStream* __is, ::TeRK::QwerkPrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
	v = 0;
    }
    else
    {
	v = new ::IceProxy::TeRK::Qwerk;
	v->__copyFrom(proxy);
    }
}

static const ::std::string __TeRK__Qwerk_ids[3] =
{
    "::Ice::Object",
    "::TeRK::Qwerk",
    "::peer::PeerConnectionEventHandler"
};

#ifndef ICEE_PURE_CLIENT

bool
TeRK::Qwerk::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__TeRK__Qwerk_ids, __TeRK__Qwerk_ids + 3, _s);
}

::std::vector< ::std::string>
TeRK::Qwerk::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__TeRK__Qwerk_ids[0], &__TeRK__Qwerk_ids[3]);
}

const ::std::string&
TeRK::Qwerk::ice_id(const ::Ice::Current&) const
{
    return __TeRK__Qwerk_ids[1];
}

const ::std::string&
TeRK::Qwerk::ice_staticId()
{
    return __TeRK__Qwerk_ids[1];
}

::IceInternal::DispatchStatus
TeRK::Qwerk::___cameraTiltUp(::IceInternal::Incoming& __in, const ::Ice::Current& __current)
{
    cameraTiltUp(__current);
    return ::IceInternal::DispatchOK;
}

::IceInternal::DispatchStatus
TeRK::Qwerk::___cameraTiltDown(::IceInternal::Incoming& __in, const ::Ice::Current& __current)
{
    cameraTiltDown(__current);
    return ::IceInternal::DispatchOK;
}

::IceInternal::DispatchStatus
TeRK::Qwerk::___cameraPanLeft(::IceInternal::Incoming& __in, const ::Ice::Current& __current)
{
    cameraPanLeft(__current);
    return ::IceInternal::DispatchOK;
}

::IceInternal::DispatchStatus
TeRK::Qwerk::___cameraPanRight(::IceInternal::Incoming& __in, const ::Ice::Current& __current)
{
    cameraPanRight(__current);
    return ::IceInternal::DispatchOK;
}

::IceInternal::DispatchStatus
TeRK::Qwerk::___driveForward(::IceInternal::Incoming& __in, const ::Ice::Current& __current)
{
    driveForward(__current);
    return ::IceInternal::DispatchOK;
}

::IceInternal::DispatchStatus
TeRK::Qwerk::___driveBack(::IceInternal::Incoming& __in, const ::Ice::Current& __current)
{
    driveBack(__current);
    return ::IceInternal::DispatchOK;
}

::IceInternal::DispatchStatus
TeRK::Qwerk::___spinLeft(::IceInternal::Incoming& __in, const ::Ice::Current& __current)
{
    spinLeft(__current);
    return ::IceInternal::DispatchOK;
}

::IceInternal::DispatchStatus
TeRK::Qwerk::___spinRight(::IceInternal::Incoming& __in, const ::Ice::Current& __current)
{
    spinRight(__current);
    return ::IceInternal::DispatchOK;
}

::IceInternal::DispatchStatus
TeRK::Qwerk::___stop(::IceInternal::Incoming& __in, const ::Ice::Current& __current)
{
    stop(__current);
    return ::IceInternal::DispatchOK;
}

static ::std::string __TeRK__Qwerk_all[] =
{
    "cameraPanLeft",
    "cameraPanRight",
    "cameraTiltDown",
    "cameraTiltUp",
    "driveBack",
    "driveForward",
    "ice_id",
    "ice_ids",
    "ice_isA",
    "ice_ping",
    "peerConnected",
    "peerConnectedNoProxy",
    "peerDisconnected",
    "spinLeft",
    "spinRight",
    "stop"
};

::IceInternal::DispatchStatus
TeRK::Qwerk::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__TeRK__Qwerk_all, __TeRK__Qwerk_all + 16, current.operation);
    if(r.first == r.second)
    {
	return ::IceInternal::DispatchOperationNotExist;
    }

    switch(r.first - __TeRK__Qwerk_all)
    {
	case 0:
	{
	    return ___cameraPanLeft(in, current);
	}
	case 1:
	{
	    return ___cameraPanRight(in, current);
	}
	case 2:
	{
	    return ___cameraTiltDown(in, current);
	}
	case 3:
	{
	    return ___cameraTiltUp(in, current);
	}
	case 4:
	{
	    return ___driveBack(in, current);
	}
	case 5:
	{
	    return ___driveForward(in, current);
	}
	case 6:
	{
	    return ___ice_id(in, current);
	}
	case 7:
	{
	    return ___ice_ids(in, current);
	}
	case 8:
	{
	    return ___ice_isA(in, current);
	}
	case 9:
	{
	    return ___ice_ping(in, current);
	}
	case 10:
	{
	    return ___peerConnected(in, current);
	}
	case 11:
	{
	    return ___peerConnectedNoProxy(in, current);
	}
	case 12:
	{
	    return ___peerDisconnected(in, current);
	}
	case 13:
	{
	    return ___spinLeft(in, current);
	}
	case 14:
	{
	    return ___spinRight(in, current);
	}
	case 15:
	{
	    return ___stop(in, current);
	}
    }

    assert(false);
    return ::IceInternal::DispatchOperationNotExist;
}

bool
TeRK::operator==(const ::TeRK::Qwerk& l, const ::TeRK::Qwerk& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
TeRK::operator!=(const ::TeRK::Qwerk& l, const ::TeRK::Qwerk& r)
{
    return static_cast<const ::Ice::Object&>(l) != static_cast<const ::Ice::Object&>(r);
}

bool
TeRK::operator<(const ::TeRK::Qwerk& l, const ::TeRK::Qwerk& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

#endif // ICEE_PURE_CLIENT

void
IceProxy::TeRK::Qwerk::cameraTiltUp()
{
    cameraTiltUp(__defaultContext());
}

void
IceProxy::TeRK::Qwerk::cameraTiltUp(const ::Ice::Context& __ctx)
{
    int __cnt = 0;
    while(true)
    {
	try
	{
	    ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase = __getDelegate();
	    ::IceDelegate::TeRK::Qwerk* __del = dynamic_cast< ::IceDelegate::TeRK::Qwerk*>(__delBase.get());
	    __del->cameraTiltUp(__ctx);
	    return;
	}
	catch(const ::IceInternal::NonRepeatable& __ex)
	{
	    __rethrowException(*__ex.get());
	}
	catch(const ::Ice::LocalException& __ex)
	{
	    __handleException(__ex, __cnt);
	}
#if defined(_MSC_VER) && (_MSC_VER == 1201) && defined(_M_ARM) // EVC4 SP4 bug.
	catch(...)
	{
	    throw;
	}
#endif
    }
}

void
IceProxy::TeRK::Qwerk::cameraTiltDown()
{
    cameraTiltDown(__defaultContext());
}

void
IceProxy::TeRK::Qwerk::cameraTiltDown(const ::Ice::Context& __ctx)
{
    int __cnt = 0;
    while(true)
    {
	try
	{
	    ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase = __getDelegate();
	    ::IceDelegate::TeRK::Qwerk* __del = dynamic_cast< ::IceDelegate::TeRK::Qwerk*>(__delBase.get());
	    __del->cameraTiltDown(__ctx);
	    return;
	}
	catch(const ::IceInternal::NonRepeatable& __ex)
	{
	    __rethrowException(*__ex.get());
	}
	catch(const ::Ice::LocalException& __ex)
	{
	    __handleException(__ex, __cnt);
	}
#if defined(_MSC_VER) && (_MSC_VER == 1201) && defined(_M_ARM) // EVC4 SP4 bug.
	catch(...)
	{
	    throw;
	}
#endif
    }
}

void
IceProxy::TeRK::Qwerk::cameraPanLeft()
{
    cameraPanLeft(__defaultContext());
}

void
IceProxy::TeRK::Qwerk::cameraPanLeft(const ::Ice::Context& __ctx)
{
    int __cnt = 0;
    while(true)
    {
	try
	{
	    ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase = __getDelegate();
	    ::IceDelegate::TeRK::Qwerk* __del = dynamic_cast< ::IceDelegate::TeRK::Qwerk*>(__delBase.get());
	    __del->cameraPanLeft(__ctx);
	    return;
	}
	catch(const ::IceInternal::NonRepeatable& __ex)
	{
	    __rethrowException(*__ex.get());
	}
	catch(const ::Ice::LocalException& __ex)
	{
	    __handleException(__ex, __cnt);
	}
#if defined(_MSC_VER) && (_MSC_VER == 1201) && defined(_M_ARM) // EVC4 SP4 bug.
	catch(...)
	{
	    throw;
	}
#endif
    }
}

void
IceProxy::TeRK::Qwerk::cameraPanRight()
{
    cameraPanRight(__defaultContext());
}

void
IceProxy::TeRK::Qwerk::cameraPanRight(const ::Ice::Context& __ctx)
{
    int __cnt = 0;
    while(true)
    {
	try
	{
	    ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase = __getDelegate();
	    ::IceDelegate::TeRK::Qwerk* __del = dynamic_cast< ::IceDelegate::TeRK::Qwerk*>(__delBase.get());
	    __del->cameraPanRight(__ctx);
	    return;
	}
	catch(const ::IceInternal::NonRepeatable& __ex)
	{
	    __rethrowException(*__ex.get());
	}
	catch(const ::Ice::LocalException& __ex)
	{
	    __handleException(__ex, __cnt);
	}
#if defined(_MSC_VER) && (_MSC_VER == 1201) && defined(_M_ARM) // EVC4 SP4 bug.
	catch(...)
	{
	    throw;
	}
#endif
    }
}

void
IceProxy::TeRK::Qwerk::driveForward()
{
    driveForward(__defaultContext());
}

void
IceProxy::TeRK::Qwerk::driveForward(const ::Ice::Context& __ctx)
{
    int __cnt = 0;
    while(true)
    {
	try
	{
	    ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase = __getDelegate();
	    ::IceDelegate::TeRK::Qwerk* __del = dynamic_cast< ::IceDelegate::TeRK::Qwerk*>(__delBase.get());
	    __del->driveForward(__ctx);
	    return;
	}
	catch(const ::IceInternal::NonRepeatable& __ex)
	{
	    __rethrowException(*__ex.get());
	}
	catch(const ::Ice::LocalException& __ex)
	{
	    __handleException(__ex, __cnt);
	}
#if defined(_MSC_VER) && (_MSC_VER == 1201) && defined(_M_ARM) // EVC4 SP4 bug.
	catch(...)
	{
	    throw;
	}
#endif
    }
}

void
IceProxy::TeRK::Qwerk::driveBack()
{
    driveBack(__defaultContext());
}

void
IceProxy::TeRK::Qwerk::driveBack(const ::Ice::Context& __ctx)
{
    int __cnt = 0;
    while(true)
    {
	try
	{
	    ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase = __getDelegate();
	    ::IceDelegate::TeRK::Qwerk* __del = dynamic_cast< ::IceDelegate::TeRK::Qwerk*>(__delBase.get());
	    __del->driveBack(__ctx);
	    return;
	}
	catch(const ::IceInternal::NonRepeatable& __ex)
	{
	    __rethrowException(*__ex.get());
	}
	catch(const ::Ice::LocalException& __ex)
	{
	    __handleException(__ex, __cnt);
	}
#if defined(_MSC_VER) && (_MSC_VER == 1201) && defined(_M_ARM) // EVC4 SP4 bug.
	catch(...)
	{
	    throw;
	}
#endif
    }
}

void
IceProxy::TeRK::Qwerk::spinLeft()
{
    spinLeft(__defaultContext());
}

void
IceProxy::TeRK::Qwerk::spinLeft(const ::Ice::Context& __ctx)
{
    int __cnt = 0;
    while(true)
    {
	try
	{
	    ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase = __getDelegate();
	    ::IceDelegate::TeRK::Qwerk* __del = dynamic_cast< ::IceDelegate::TeRK::Qwerk*>(__delBase.get());
	    __del->spinLeft(__ctx);
	    return;
	}
	catch(const ::IceInternal::NonRepeatable& __ex)
	{
	    __rethrowException(*__ex.get());
	}
	catch(const ::Ice::LocalException& __ex)
	{
	    __handleException(__ex, __cnt);
	}
#if defined(_MSC_VER) && (_MSC_VER == 1201) && defined(_M_ARM) // EVC4 SP4 bug.
	catch(...)
	{
	    throw;
	}
#endif
    }
}

void
IceProxy::TeRK::Qwerk::spinRight()
{
    spinRight(__defaultContext());
}

void
IceProxy::TeRK::Qwerk::spinRight(const ::Ice::Context& __ctx)
{
    int __cnt = 0;
    while(true)
    {
	try
	{
	    ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase = __getDelegate();
	    ::IceDelegate::TeRK::Qwerk* __del = dynamic_cast< ::IceDelegate::TeRK::Qwerk*>(__delBase.get());
	    __del->spinRight(__ctx);
	    return;
	}
	catch(const ::IceInternal::NonRepeatable& __ex)
	{
	    __rethrowException(*__ex.get());
	}
	catch(const ::Ice::LocalException& __ex)
	{
	    __handleException(__ex, __cnt);
	}
#if defined(_MSC_VER) && (_MSC_VER == 1201) && defined(_M_ARM) // EVC4 SP4 bug.
	catch(...)
	{
	    throw;
	}
#endif
    }
}

void
IceProxy::TeRK::Qwerk::stop()
{
    stop(__defaultContext());
}

void
IceProxy::TeRK::Qwerk::stop(const ::Ice::Context& __ctx)
{
    int __cnt = 0;
    while(true)
    {
	try
	{
	    ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase = __getDelegate();
	    ::IceDelegate::TeRK::Qwerk* __del = dynamic_cast< ::IceDelegate::TeRK::Qwerk*>(__delBase.get());
	    __del->stop(__ctx);
	    return;
	}
	catch(const ::IceInternal::NonRepeatable& __ex)
	{
	    __rethrowException(*__ex.get());
	}
	catch(const ::Ice::LocalException& __ex)
	{
	    __handleException(__ex, __cnt);
	}
#if defined(_MSC_VER) && (_MSC_VER == 1201) && defined(_M_ARM) // EVC4 SP4 bug.
	catch(...)
	{
	    throw;
	}
#endif
    }
}

const ::std::string&
IceProxy::TeRK::Qwerk::ice_staticId()
{
    return __TeRK__Qwerk_ids[1];
}

::IceInternal::Handle< ::IceDelegate::Ice::Object>
IceProxy::TeRK::Qwerk::__createDelegate()
{
    return ::IceInternal::Handle< ::IceDelegate::Ice::Object>(new ::IceDelegate::TeRK::Qwerk);
}

bool
IceProxy::TeRK::operator==(const ::IceProxy::TeRK::Qwerk& l, const ::IceProxy::TeRK::Qwerk& r)
{
    return static_cast<const ::IceProxy::Ice::Object&>(l) == static_cast<const ::IceProxy::Ice::Object&>(r);
}

bool
IceProxy::TeRK::operator!=(const ::IceProxy::TeRK::Qwerk& l, const ::IceProxy::TeRK::Qwerk& r)
{
    return static_cast<const ::IceProxy::Ice::Object&>(l) != static_cast<const ::IceProxy::Ice::Object&>(r);
}

bool
IceProxy::TeRK::operator<(const ::IceProxy::TeRK::Qwerk& l, const ::IceProxy::TeRK::Qwerk& r)
{
    return static_cast<const ::IceProxy::Ice::Object&>(l) < static_cast<const ::IceProxy::Ice::Object&>(r);
}

void
IceDelegate::TeRK::Qwerk::cameraTiltUp(const ::Ice::Context& __context)
{
    static const ::std::string __operation("cameraTiltUp");
    ::IceInternal::Outgoing __out(__connection.get(), __reference.get(), __operation, static_cast< ::Ice::OperationMode>(0), __context);
    bool __ok = __out.invoke();
    try
    {
	::IceInternal::BasicStream* __is = __out.is();
	if(!__ok)
	{
	    try
	    {
		__is->throwException();
	    }
	    catch(const ::Ice::UserException& __ex)
	    {
		::Ice::UnknownUserException __uex(__FILE__, __LINE__);
		__uex.unknown = __ex.ice_name();
		throw __uex;
	    }
	}
    }
    catch(const ::Ice::LocalException& __ex)
    {
	throw ::IceInternal::NonRepeatable(__ex);
    }
#if defined(_MSC_VER) && (_MSC_VER == 1201) && defined(_M_ARM) // EVC4 SP4 bug.
    catch(...)
    {
	throw;
    }
#endif
}

void
IceDelegate::TeRK::Qwerk::cameraTiltDown(const ::Ice::Context& __context)
{
    static const ::std::string __operation("cameraTiltDown");
    ::IceInternal::Outgoing __out(__connection.get(), __reference.get(), __operation, static_cast< ::Ice::OperationMode>(0), __context);
    bool __ok = __out.invoke();
    try
    {
	::IceInternal::BasicStream* __is = __out.is();
	if(!__ok)
	{
	    try
	    {
		__is->throwException();
	    }
	    catch(const ::Ice::UserException& __ex)
	    {
		::Ice::UnknownUserException __uex(__FILE__, __LINE__);
		__uex.unknown = __ex.ice_name();
		throw __uex;
	    }
	}
    }
    catch(const ::Ice::LocalException& __ex)
    {
	throw ::IceInternal::NonRepeatable(__ex);
    }
#if defined(_MSC_VER) && (_MSC_VER == 1201) && defined(_M_ARM) // EVC4 SP4 bug.
    catch(...)
    {
	throw;
    }
#endif
}

void
IceDelegate::TeRK::Qwerk::cameraPanLeft(const ::Ice::Context& __context)
{
    static const ::std::string __operation("cameraPanLeft");
    ::IceInternal::Outgoing __out(__connection.get(), __reference.get(), __operation, static_cast< ::Ice::OperationMode>(0), __context);
    bool __ok = __out.invoke();
    try
    {
	::IceInternal::BasicStream* __is = __out.is();
	if(!__ok)
	{
	    try
	    {
		__is->throwException();
	    }
	    catch(const ::Ice::UserException& __ex)
	    {
		::Ice::UnknownUserException __uex(__FILE__, __LINE__);
		__uex.unknown = __ex.ice_name();
		throw __uex;
	    }
	}
    }
    catch(const ::Ice::LocalException& __ex)
    {
	throw ::IceInternal::NonRepeatable(__ex);
    }
#if defined(_MSC_VER) && (_MSC_VER == 1201) && defined(_M_ARM) // EVC4 SP4 bug.
    catch(...)
    {
	throw;
    }
#endif
}

void
IceDelegate::TeRK::Qwerk::cameraPanRight(const ::Ice::Context& __context)
{
    static const ::std::string __operation("cameraPanRight");
    ::IceInternal::Outgoing __out(__connection.get(), __reference.get(), __operation, static_cast< ::Ice::OperationMode>(0), __context);
    bool __ok = __out.invoke();
    try
    {
	::IceInternal::BasicStream* __is = __out.is();
	if(!__ok)
	{
	    try
	    {
		__is->throwException();
	    }
	    catch(const ::Ice::UserException& __ex)
	    {
		::Ice::UnknownUserException __uex(__FILE__, __LINE__);
		__uex.unknown = __ex.ice_name();
		throw __uex;
	    }
	}
    }
    catch(const ::Ice::LocalException& __ex)
    {
	throw ::IceInternal::NonRepeatable(__ex);
    }
#if defined(_MSC_VER) && (_MSC_VER == 1201) && defined(_M_ARM) // EVC4 SP4 bug.
    catch(...)
    {
	throw;
    }
#endif
}

void
IceDelegate::TeRK::Qwerk::driveForward(const ::Ice::Context& __context)
{
    static const ::std::string __operation("driveForward");
    ::IceInternal::Outgoing __out(__connection.get(), __reference.get(), __operation, static_cast< ::Ice::OperationMode>(0), __context);
    bool __ok = __out.invoke();
    try
    {
	::IceInternal::BasicStream* __is = __out.is();
	if(!__ok)
	{
	    try
	    {
		__is->throwException();
	    }
	    catch(const ::Ice::UserException& __ex)
	    {
		::Ice::UnknownUserException __uex(__FILE__, __LINE__);
		__uex.unknown = __ex.ice_name();
		throw __uex;
	    }
	}
    }
    catch(const ::Ice::LocalException& __ex)
    {
	throw ::IceInternal::NonRepeatable(__ex);
    }
#if defined(_MSC_VER) && (_MSC_VER == 1201) && defined(_M_ARM) // EVC4 SP4 bug.
    catch(...)
    {
	throw;
    }
#endif
}

void
IceDelegate::TeRK::Qwerk::driveBack(const ::Ice::Context& __context)
{
    static const ::std::string __operation("driveBack");
    ::IceInternal::Outgoing __out(__connection.get(), __reference.get(), __operation, static_cast< ::Ice::OperationMode>(0), __context);
    bool __ok = __out.invoke();
    try
    {
	::IceInternal::BasicStream* __is = __out.is();
	if(!__ok)
	{
	    try
	    {
		__is->throwException();
	    }
	    catch(const ::Ice::UserException& __ex)
	    {
		::Ice::UnknownUserException __uex(__FILE__, __LINE__);
		__uex.unknown = __ex.ice_name();
		throw __uex;
	    }
	}
    }
    catch(const ::Ice::LocalException& __ex)
    {
	throw ::IceInternal::NonRepeatable(__ex);
    }
#if defined(_MSC_VER) && (_MSC_VER == 1201) && defined(_M_ARM) // EVC4 SP4 bug.
    catch(...)
    {
	throw;
    }
#endif
}

void
IceDelegate::TeRK::Qwerk::spinLeft(const ::Ice::Context& __context)
{
    static const ::std::string __operation("spinLeft");
    ::IceInternal::Outgoing __out(__connection.get(), __reference.get(), __operation, static_cast< ::Ice::OperationMode>(0), __context);
    bool __ok = __out.invoke();
    try
    {
	::IceInternal::BasicStream* __is = __out.is();
	if(!__ok)
	{
	    try
	    {
		__is->throwException();
	    }
	    catch(const ::Ice::UserException& __ex)
	    {
		::Ice::UnknownUserException __uex(__FILE__, __LINE__);
		__uex.unknown = __ex.ice_name();
		throw __uex;
	    }
	}
    }
    catch(const ::Ice::LocalException& __ex)
    {
	throw ::IceInternal::NonRepeatable(__ex);
    }
#if defined(_MSC_VER) && (_MSC_VER == 1201) && defined(_M_ARM) // EVC4 SP4 bug.
    catch(...)
    {
	throw;
    }
#endif
}

void
IceDelegate::TeRK::Qwerk::spinRight(const ::Ice::Context& __context)
{
    static const ::std::string __operation("spinRight");
    ::IceInternal::Outgoing __out(__connection.get(), __reference.get(), __operation, static_cast< ::Ice::OperationMode>(0), __context);
    bool __ok = __out.invoke();
    try
    {
	::IceInternal::BasicStream* __is = __out.is();
	if(!__ok)
	{
	    try
	    {
		__is->throwException();
	    }
	    catch(const ::Ice::UserException& __ex)
	    {
		::Ice::UnknownUserException __uex(__FILE__, __LINE__);
		__uex.unknown = __ex.ice_name();
		throw __uex;
	    }
	}
    }
    catch(const ::Ice::LocalException& __ex)
    {
	throw ::IceInternal::NonRepeatable(__ex);
    }
#if defined(_MSC_VER) && (_MSC_VER == 1201) && defined(_M_ARM) // EVC4 SP4 bug.
    catch(...)
    {
	throw;
    }
#endif
}

void
IceDelegate::TeRK::Qwerk::stop(const ::Ice::Context& __context)
{
    static const ::std::string __operation("stop");
    ::IceInternal::Outgoing __out(__connection.get(), __reference.get(), __operation, static_cast< ::Ice::OperationMode>(0), __context);
    bool __ok = __out.invoke();
    try
    {
	::IceInternal::BasicStream* __is = __out.is();
	if(!__ok)
	{
	    try
	    {
		__is->throwException();
	    }
	    catch(const ::Ice::UserException& __ex)
	    {
		::Ice::UnknownUserException __uex(__FILE__, __LINE__);
		__uex.unknown = __ex.ice_name();
		throw __uex;
	    }
	}
    }
    catch(const ::Ice::LocalException& __ex)
    {
	throw ::IceInternal::NonRepeatable(__ex);
    }
#if defined(_MSC_VER) && (_MSC_VER == 1201) && defined(_M_ARM) // EVC4 SP4 bug.
    catch(...)
    {
	throw;
    }
#endif
}

--- NEW FILE: Chat.h ---
// **********************************************************************
//
// Copyright (c) 2005 ZeroC, Inc. All rights reserved.
//
// This copy of Ice-E is licensed to you under the terms described in the
// ICEE_LICENSE file included in this distribution.
//
// **********************************************************************

// Ice-E version 1.0.0
// Generated from file `Chat.ice'

#ifndef __Chat_h__
#define __Chat_h__

#include <IceE/LocalObjectF.h>
#include <IceE/ProxyF.h>
#ifndef ICEE_PURE_CLIENT
#  include <IceE/ObjectF.h>
#endif
#include <IceE/Exception.h>
#include <IceE/LocalObject.h>
#include <IceE/Proxy.h>
#ifndef ICEE_PURE_CLIENT
#  include <IceE/Object.h>
#  include <IceE/Incoming.h>
#endif
#include <IceE/Outgoing.h>
#include <IceE/UserExceptionFactory.h>
#include <IceE/FactoryTable.h>
#include <MRPLPeer.h>
#include <IceE/UndefSysMacros.h>

#ifndef ICEE_IGNORE_VERSION
#   if ICEE_INT_VERSION / 100 != 100
#       error IceE version mismatch!
#   endif
#   if ICEE_INT_VERSION % 100 < 0
#       error IceE patch level mismatch!
#   endif
#endif

namespace IceProxy
{

namespace TeRK
{

class Qwerk;
bool operator==(const Qwerk&, const Qwerk&);
bool operator!=(const Qwerk&, const Qwerk&);
bool operator<(const Qwerk&, const Qwerk&);

}

}

namespace TeRK
{

#ifndef ICEE_PURE_CLIENT

class Qwerk;
bool operator==(const Qwerk&, const Qwerk&);
bool operator!=(const Qwerk&, const Qwerk&);
bool operator<(const Qwerk&, const Qwerk&);

#endif // ICEE_PURE_CLIENT

}

namespace IceInternal
{

#ifndef ICEE_PURE_CLIENT

void incRef(::TeRK::Qwerk*);
void decRef(::TeRK::Qwerk*);

#endif // ICEE_PURE_CLIENT

void incRef(::IceProxy::TeRK::Qwerk*);
void decRef(::IceProxy::TeRK::Qwerk*);

}

namespace TeRK
{

#ifndef ICEE_PURE_CLIENT

typedef ::IceInternal::Handle< ::TeRK::Qwerk> QwerkPtr;

#endif // ICEE_PURE_CLIENT

typedef ::IceInternal::ProxyHandle< ::IceProxy::TeRK::Qwerk> QwerkPrx;

void __write(::IceInternal::BasicStream*, const QwerkPrx&);
void __read(::IceInternal::BasicStream*, QwerkPrx&);

}

namespace TeRK
{

}

namespace TeRK
{

#ifndef ICEE_PURE_CLIENT

class Qwerk : virtual public ::peer::PeerConnectionEventHandler
{
public:


    virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
    virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
    virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
    static const ::std::string& ice_staticId();

    virtual void cameraTiltUp(const ::Ice::Current& = ::Ice::Current()) = 0;
    ::IceInternal::DispatchStatus ___cameraTiltUp(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void cameraTiltDown(const ::Ice::Current& = ::Ice::Current()) = 0;
    ::IceInternal::DispatchStatus ___cameraTiltDown(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void cameraPanLeft(const ::Ice::Current& = ::Ice::Current()) = 0;
    ::IceInternal::DispatchStatus ___cameraPanLeft(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void cameraPanRight(const ::Ice::Current& = ::Ice::Current()) = 0;
    ::IceInternal::DispatchStatus ___cameraPanRight(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void driveForward(const ::Ice::Current& = ::Ice::Current()) = 0;
    ::IceInternal::DispatchStatus ___driveForward(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void driveBack(const ::Ice::Current& = ::Ice::Current()) = 0;
    ::IceInternal::DispatchStatus ___driveBack(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void spinLeft(const ::Ice::Current& = ::Ice::Current()) = 0;
    ::IceInternal::DispatchStatus ___spinLeft(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void spinRight(const ::Ice::Current& = ::Ice::Current()) = 0;
    ::IceInternal::DispatchStatus ___spinRight(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void stop(const ::Ice::Current& = ::Ice::Current()) = 0;
    ::IceInternal::DispatchStatus ___stop(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual ::IceInternal::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);
};

#endif // ICEE_PURE_CLIENT

}

namespace IceProxy
{

namespace TeRK
{

class Qwerk : virtual public ::IceProxy::peer::PeerConnectionEventHandler
{
public:

    void cameraTiltUp();
    void cameraTiltUp(const ::Ice::Context&);

    void cameraTiltDown();
    void cameraTiltDown(const ::Ice::Context&);

    void cameraPanLeft();
    void cameraPanLeft(const ::Ice::Context&);

    void cameraPanRight();
    void cameraPanRight(const ::Ice::Context&);

    void driveForward();
    void driveForward(const ::Ice::Context&);

    void driveBack();
    void driveBack(const ::Ice::Context&);

    void spinLeft();
    void spinLeft(const ::Ice::Context&);

    void spinRight();
    void spinRight(const ::Ice::Context&);

    void stop();
    void stop(const ::Ice::Context&);
    
    static const ::std::string& ice_staticId();

private: 

    virtual ::IceInternal::Handle< ::IceDelegate::Ice::Object> __createDelegate();
};

}

}

namespace IceDelegate
{

namespace TeRK
{

class Qwerk : virtual public ::IceDelegate::peer::PeerConnectionEventHandler
{
public:

    virtual void cameraTiltUp(const ::Ice::Context&);

    virtual void cameraTiltDown(const ::Ice::Context&);

    virtual void cameraPanLeft(const ::Ice::Context&);

    virtual void cameraPanRight(const ::Ice::Context&);

    virtual void driveForward(const ::Ice::Context&);

    virtual void driveBack(const ::Ice::Context&);

    virtual void spinLeft(const ::Ice::Context&);

    virtual void spinRight(const ::Ice::Context&);

    virtual void stop(const ::Ice::Context&);
};

}

}

#endif