Changed the CCommandFactory logic that searches for commands.
* Changed the CCommandFactory logic that searches for commands; it now scans \resource\cif\fshell rather than \sys\bin. This means that the 'help' command now works on the emulator and on installs without all capabilities.
* Fixed wslog ciftest
// client.cpp
//
// Copyright (c) 2006 - 2010 Accenture. All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Accenture - Initial contribution
//
#include <fshell/iocli.h>
#include "clientserver.h"
#include <e32math.h>
#ifndef EKA2
//
// TServerStart.
//
TServerStart::TServerStart(TRequestStatus& aStatus)
: iId(RThread().Id()), iStatus(&aStatus)
{
aStatus = KRequestPending;
}
TPtrC TServerStart::AsCommand() const
{
return TPtrC(reinterpret_cast<const TText*>(this),sizeof(TServerStart)/sizeof(TText));
}
#endif
//
// Statics.
//
static TInt StartServer()
{
#ifdef EKA2
const TUidType serverUid(KNullUid, KNullUid, KServerUid3);
RProcess server;
TInt r = server.Create(KIoServerName, KNullDesC, serverUid);
if (r != KErrNone)
{
return r;
}
TRequestStatus stat;
server.Rendezvous(stat);
if (stat != KRequestPending)
{
server.Kill(0);
}
else
{
server.Resume();
}
User::WaitForRequest(stat); // wait for start or death
r = (server.ExitType() == EExitPanic) ? KErrGeneral : stat.Int();
server.Close();
return r;
#else
TRequestStatus started;
TServerStart start(started);
const TUidType serverUid(KNullUid, KNullUid, KServerUid3);
#ifdef __WINS__
RLibrary lib;
TInt r = lib.Load(KIoServerName, serverUid);
if (r != KErrNone)
{
return r;
}
TLibraryFunction ordinal1 = lib.Lookup(1);
TThreadFunction serverFunc = reinterpret_cast<TThreadFunction>(ordinal1());
TName name(KIoServerName);
name.AppendNum(Math::Random(), EHex);
RThread server;
r=server.Create(name, serverFunc,
KIoStackSize,
&start, &lib, NULL,
KIoInitHeapSize, KIoMaxHeapSize, EOwnerProcess);
lib.Close();
#else
RProcess server;
TInt r=server.Create(KIoServerName, start.AsCommand(), serverUid);
#endif
if (r != KErrNone)
{
return r;
}
TRequestStatus died;
server.Logon(died);
if (died != KRequestPending)
{
User::WaitForRequest(died);
server.Kill(0);
server.Close();
return died.Int();
}
server.Resume();
User::WaitForRequest(started, died);
if (started == KRequestPending)
{
server.Close();
return died.Int();
}
server.LogonCancel(died);
server.Close();
User::WaitForRequest(died);
return KErrNone;
#endif // EKA2
}
#ifndef EKA2
TInt E32Dll(TDllReason)
{
return 0;
}
#endif
//
// RIoSession.
//
EXPORT_C TInt RIoSession::Connect()
{
TInt retry = 2;
for (;;)
{
TInt r = CreateSession(KIoServerName, TVersion(0,0,0));
if ((r != KErrNotFound) && (r != KErrServerTerminated))
{
return r;
}
if (--retry == 0)
{
return r;
}
r = StartServer();
if ((r != KErrNone) && (r != KErrAlreadyExists))
{
return r;
}
}
}
EXPORT_C void RIoSession::ConnectL()
{
User::LeaveIfError(Connect());
}
EXPORT_C TInt RIoSession::SetObjectName(TInt aHandle, const TDesC& aName)
{
#ifdef EKA2
return SendReceive(EIoSetObjectName, TIpcArgs(aHandle, &aName));
#else
TInt p[4];
p[0] = aHandle;
p[1] = (TInt)&aName;
return SendReceive(EIoSetObjectName, &p[0]);
#endif
}
EXPORT_C void RIoSession::SetObjectNameL(TInt aHandle, const TDesC& aName)
{
User::LeaveIfError(SetObjectName(aHandle, aName));
}
EXPORT_C TInt RIoSession::FindFirstHandle(RIoHandle::TType aType, const TDesC& aMatchString, TInt& aFoundHandle, TName& aName)
{
#ifdef EKA2
TPckg<TInt> foundBuf(aFoundHandle);
return SendReceive(EIoFindFirstHandle, TIpcArgs(aType, &aMatchString, &foundBuf, &aName));
#else
TInt p[4];
p[0] = aType;
p[1] = &aMatchString;
p[2] = &aFoundHandle;
p[3] = &aName;
return SendReceive(EIoFindFirstHandle, &p[0]);
#endif
}
EXPORT_C TInt RIoSession::FindNextHandle(TInt& aFoundHandle, TName& aName)
{
#ifdef EKA2
TPckg<TInt> foundBuf(aFoundHandle);
return SendReceive(EIoFindNextHandle, TIpcArgs(&foundBuf, &aName));
#else
TInt p[4];
p[0] = &aFoundHandle;
p[1] = &aName;
return SendReceive(EIoFindNextHandle, &p[0]);
#endif
}
//
// RIoHandle.
//
EXPORT_C TInt RIoHandle::OpenFoundHandle(RIoSession& aSession, TInt aFoundHandle)
{
#ifdef EKA2
return CreateSubSession(aSession, EIoOpenFoundHandle, TIpcArgs(aFoundHandle));
#else
TInt p[4];
p[0] = aFoundHandle;
return CreateSubSession(aSession, EIoOpenFoundHandle, &p[0]);
#endif
}
EXPORT_C void RIoHandle::OpenFoundHandleL(RIoSession& aSession, TInt aFoundHandle)
{
User::LeaveIfError(OpenFoundHandle(aSession, aFoundHandle));
}
EXPORT_C void RIoHandle::Close()
{
CloseSubSession(EIoHandleClose);
}
EXPORT_C TInt RIoHandle::IsType(TType aType) const
{
#ifdef EKA2
return SendReceive(EIoHandleIsType, TIpcArgs(aType));
#else
TInt p[4];
p[0] = (TInt)aType;
return SendReceive(EIoHandleIsType, &p[0]);
#endif
}
EXPORT_C TBool RIoHandle::IsTypeL(TType aType) const
{
return User::LeaveIfError(IsType(aType));
}
EXPORT_C TInt RIoHandle::ObjectName(TDes& aName) const
{
#ifdef EKA2
return SendReceive(EIoHandleGetName, TIpcArgs(&aName));
#else
TInt p[4];
p[0] = &aName;
return SendReceive(EIoHandleGetName, &p[0]);
#endif
}
EXPORT_C void RIoHandle::ObjectNameL(TDes& aName) const
{
User::LeaveIfError(ObjectName(aName));
}
EXPORT_C TInt RIoHandle::Equals(const RIoHandle& aNother) const
{
#ifdef EKA2
return SendReceive(EIoHandleEquals, TIpcArgs(aNother.SubSessionHandle()));
#else
TInt p[4];
p[0] = (TInt)aNother.SubSessionHandle();
return SendReceive(EIoHandleEquals, &p[0]);
#endif
}
EXPORT_C TBool RIoHandle::EqualsL(const RIoHandle& aNother) const
{
return User::LeaveIfError(Equals(aNother));
}
EXPORT_C RIoSession RIoHandle::Session() const
{
RSessionBase session = RSubSessionBase::Session();
return static_cast<RIoSession&>(session);
}
//
// RIoReadWriteHandle.
//
EXPORT_C TInt RIoReadWriteHandle::SetMode(TMode aMode)
{
#ifdef EKA2
return SendReceive(EIoSetReadWriteMode, TIpcArgs(aMode));
#else
TInt p[4];
p[0] = (TInt)aMode;
return SendReceive(EIoSetReadWriteMode, &p[0]);
#endif
}
EXPORT_C void RIoReadWriteHandle::SetModeL(TMode aMode)
{
User::LeaveIfError(SetMode(aMode));
}
EXPORT_C TInt RIoReadWriteHandle::SetOwner(TThreadId aOwningThread)
{
#ifdef EKA2
return SendReceive(EIoHandleSetOwner, TIpcArgs(aOwningThread));
#else
TInt p[4];
p[0] = aOwningThread;
return SendReceive(EIoHandleSetOwner, &p[0]);
#endif
}
EXPORT_C void RIoReadWriteHandle::SetOwnerL(TThreadId aOwningThread)
{
User::LeaveIfError(SetOwner(aOwningThread));
}
EXPORT_C TInt RIoReadWriteHandle::SetUnderlyingConsole(RIoConsole& aConsole)
{
#ifdef EKA2
return SendReceive(EIoHandleSetUnderlyingConsole, TIpcArgs(aConsole.SubSessionHandle()));
#else
TInt p[4];
p[0] = aConsole.SubSessionHandle();
return SendReceive(EIoHandleSetUnderlyingConsole, &p[0]);
#endif
}
EXPORT_C void RIoReadWriteHandle::SetUnderlyingConsoleL(RIoConsole& aConsole)
{
User::LeaveIfError(SetUnderlyingConsole(aConsole));
}
EXPORT_C TInt RIoReadWriteHandle::AttachedToConsole() const
{
#ifdef EKA2
return SendReceive(EIoHandleAttachedToConsole);
#else
return SendReceive(EIoHandleAttachedToConsole, NULL);
#endif
}
EXPORT_C TBool RIoReadWriteHandle::AttachedToConsoleL() const
{
return User::LeaveIfError(AttachedToConsole());
}
//
// RIoReadHandle.
//
EXPORT_C TInt RIoReadHandle::Create(RIoSession& aSession)
{
#ifdef EKA2
return CreateSubSession(aSession, EIoCreateReader);
#else
return CreateSubSession(aSession, EIoCreateReader, NULL);
#endif
}
EXPORT_C void RIoReadHandle::CreateL(RIoSession& aSession)
{
User::LeaveIfError(Create(aSession));
}
EXPORT_C TInt RIoReadHandle::Open(RIoSession& aSession)
{
#ifdef EKA2
return CreateSubSession(aSession, EIoOpenReaderByThreadId);
#else
return CreateSubSession(aSession, EIoOpenReaderByThreadId, NULL);
#endif
}
EXPORT_C void RIoReadHandle::OpenL(RIoSession& aSession)
{
User::LeaveIfError(Open(aSession));
}
EXPORT_C TInt RIoReadHandle::Open(RIoSession& aSession, TThreadId aThreadId)
{
TPckgBuf<TThreadId> threadIdPckg(aThreadId);
#ifdef EKA2
return CreateSubSession(aSession, EIoOpenReaderByExplicitThreadId, TIpcArgs(&threadIdPckg));
#else
TInt p[4];
p[0] = &threadIdPckg;
return CreateSubSession(aSession, EIoOpenReaderByExplicitThreadId, &p[0]);
#endif
}
EXPORT_C void RIoReadHandle::OpenL(RIoSession& aSession, TThreadId aThreadId)
{
User::LeaveIfError(Open(aSession, aThreadId));
}
EXPORT_C TInt RIoReadHandle::Duplicate(RIoReadHandle& aReadHandle)
{
#ifdef EKA2
return SendReceive(EIoDuplicateReader, TIpcArgs(aReadHandle.SubSessionHandle()));
#else
TInt p[4];
p[0] = aReadHandle.SubSessionHandle();
return SendReceive(EIoDuplicateReader, &p[0]);
#endif
}
EXPORT_C void RIoReadHandle::DuplicateL(RIoReadHandle& aReadHandle)
{
User::LeaveIfError(Duplicate(aReadHandle));
}
EXPORT_C TInt RIoReadHandle::DuplicateHandleFromThread(TThreadId aThreadId)
{
return SendReceive(EIoDuplicateReaderHandleFromThread, TIpcArgs(TUint(aThreadId)));
}
EXPORT_C TInt RIoReadHandle::SetReadMode(TReadMode aMode)
{
#ifdef EKA2
return SendReceive(EIoSetReadMode, TIpcArgs(aMode));
#else
TInt p[4];
p[0] = (TInt)aMode;
return SendReceive(EIoSetReadMode, &p[0]);
#endif
}
EXPORT_C void RIoReadHandle::SetReadModeL(TReadMode aMode)
{
User::LeaveIfError(SetReadMode(aMode));
}
EXPORT_C TInt RIoReadHandle::SetToForeground()
{
#ifdef EKA2
return SendReceive(EIoSetReaderToForeground);
#else
return SendReceive(EIoSetReaderToForeground, NULL);
#endif
}
EXPORT_C void RIoReadHandle::SetToForegroundL()
{
User::LeaveIfError(SetToForeground());
}
EXPORT_C TInt RIoReadHandle::Read(TDes& aDes)
{
#ifdef EKA2
return SendReceive(EIoRead, TIpcArgs(&aDes));
#else
TInt p[4];
p[0] = (TInt)&aDes;
return SendReceive(EIoRead, &p[0]);
#endif
}
EXPORT_C void RIoReadHandle::ReadL(TDes& aDes)
{
User::LeaveIfError(Read(aDes));
}
EXPORT_C void RIoReadHandle::Read(TDes& aDes, TRequestStatus& aStatus)
{
#ifdef EKA2
return SendReceive(EIoRead, TIpcArgs(&aDes), aStatus);
#else
TInt p[4];
p[0] = (TInt)&aDes;
SendReceive(EIoRead, &p[0], aStatus);
#endif
}
EXPORT_C TInt RIoReadHandle::SetLineSeparator(const TDesC& aSeparator)
{
#ifdef EKA2
return SendReceive(EIoSetLineSeparator, TIpcArgs(&aSeparator));
#else
TInt p[4];
p[0] = (TInt)&aSeparator;
return SendReceive(EIoSetLineSeparator, &p[0]);
#endif
}
EXPORT_C void RIoReadHandle::SetLineSeparatorL(const TDesC& aSeparator)
{
User::LeaveIfError(SetLineSeparator(aSeparator));
}
EXPORT_C void RIoReadHandle::ReadCancel()
{
#ifdef EKA2
SendReceive(EIoReadCancel);
#else
SendReceive(EIoReadCancel, NULL);
#endif
}
EXPORT_C TInt RIoReadHandle::IsForeground() const
{
#ifdef EKA2
return SendReceive(EIoIsForegroundReader);
#else
return SendReceive(EIoIsForegroundReader, NULL);
#endif
}
EXPORT_C TBool RIoReadHandle::IsForegroundL() const
{
return User::LeaveIfError(IsForeground());
}
EXPORT_C void RIoReadHandle::NotifyChange(TPckgBuf<TUint>& aChangeType, TRequestStatus& aStatus)
{
#ifdef EKA2
SendReceive(EIoReadHandleNotifyChange, TIpcArgs(&aChangeType), aStatus);
#else
TInt p[4];
p[0] = (TInt)&aChangeType;;
SendReceive(EIoReadHandleNotifyChange, &p[0], aStatus);
#endif
}
EXPORT_C void RIoReadHandle::CancelNotifyChange()
{
SendReceive(EIoReadHandleCancelNotifyChange);
}
//
// RIoConsoleReadHandle.
//
EXPORT_C RIoConsoleReadHandle::RIoConsoleReadHandle()
{
}
EXPORT_C RIoConsoleReadHandle::RIoConsoleReadHandle(RIoReadHandle& aHandle)
{
*(RIoReadHandle*)this = aHandle; // Take a bit-wise copy of the base class.
}
EXPORT_C RIoConsoleReadHandle RIoConsoleReadHandle::operator=(RIoReadHandle& aHandle)
{
*(RIoReadHandle*)this = aHandle; // Take a bit-wise copy of the base class.
return *this;
}
EXPORT_C TUint RIoConsoleReadHandle::ReadKey()
{
TRequestStatus status;
WaitForKey(status);
User::WaitForRequest(status);
if (status.Int())
{
return EKeyNull;
}
return KeyCode();
}
EXPORT_C void RIoConsoleReadHandle::WaitForKey(TRequestStatus& aStatus)
{
#ifdef EKA2
return SendReceive(EIoConsoleWaitForKey, TIpcArgs(&iKeyBuf), aStatus);
#else
TInt p[4];
p[0] = (TInt)&iKeyBuf;
SendReceive(EIoConsoleWaitForKey, &p[0], aStatus);
#endif
}
EXPORT_C void RIoConsoleReadHandle::WaitForKeyCancel()
{
#ifdef EKA2
SendReceive(EIoConsoleWaitForKeyCancel);
#else
SendReceive(EIoConsoleWaitForKeyCancel, NULL);
#endif
}
EXPORT_C TUint RIoConsoleReadHandle::KeyCode() const
{
return iKeyBuf().iKeyCode;
}
EXPORT_C TUint RIoConsoleReadHandle::KeyModifiers() const
{
return iKeyBuf().iModifiers;
}
EXPORT_C TInt RIoConsoleReadHandle::CaptureKey(TUint aKeyCode, TUint aModifierMask, TUint aModifiers)
{
#ifdef EKA2
return SendReceive(EIoConsoleCaptureKey, TIpcArgs(aKeyCode, aModifierMask, aModifiers));
#else
TInt p[4];
p[0] = aKeyCode;
p[1] = aModifierMask;
p[2] = aModifiers;
return SendReceive(EIoConsoleCaptureKey, &p[0]);
#endif
}
EXPORT_C void RIoConsoleReadHandle::CaptureKeyL(TUint aKeyCode, TUint aModifierMask, TUint aModifiers)
{
User::LeaveIfError(CaptureKey(aKeyCode, aModifierMask, aModifiers));
}
EXPORT_C TInt RIoConsoleReadHandle::CancelCaptureKey(TUint aKeyCode, TUint aModifierMask, TUint aModifiers)
{
#ifdef EKA2
return SendReceive(EIoConsoleCancelCaptureKey, TIpcArgs(aKeyCode, aModifierMask, aModifiers));
#else
TInt p[4];
p[0] = aKeyCode;
p[1] = aModifierMask;
p[2] = aModifiers;
return SendReceive(EIoConsoleCancelCaptureKey, &p[0]);
#endif
}
EXPORT_C TInt RIoConsoleReadHandle::CaptureAllKeys()
{
#ifdef EKA2
return SendReceive(EIoConsoleCaptureAllKeys);
#else
return SendReceive(EIoConsoleCaptureAllKeys, NULL);
#endif
}
EXPORT_C void RIoConsoleReadHandle::CaptureAllKeysL()
{
User::LeaveIfError(CaptureAllKeys());
}
EXPORT_C TInt RIoConsoleReadHandle::CancelCaptureAllKeys()
{
#ifdef EKA2
return SendReceive(EIoConsoleCancelCaptureAllKeys);
#else
return SendReceive(EIoConsoleCancelCaptureAllKeys, NULL);
#endif
}
//
// RIoWriteHandle.
//
EXPORT_C TInt RIoWriteHandle::Create(RIoSession& aSession)
{
#ifdef EKA2
return CreateSubSession(aSession, EIoCreateWriter);
#else
return CreateSubSession(aSession, EIoCreateWriter, NULL);
#endif
}
EXPORT_C void RIoWriteHandle::CreateL(RIoSession& aSession)
{
User::LeaveIfError(Create(aSession));
}
EXPORT_C TInt RIoWriteHandle::Open(RIoSession& aSession)
{
#ifdef EKA2
return CreateSubSession(aSession, EIoOpenWriterByThreadId);
#else
return CreateSubSession(aSession, EIoOpenWriterByThreadId, NULL);
#endif
}
EXPORT_C void RIoWriteHandle::OpenL(RIoSession& aSession)
{
User::LeaveIfError(Open(aSession));
}
EXPORT_C TInt RIoWriteHandle::Open(RIoSession& aSession, TThreadId aThreadId)
{
TPckgBuf<TThreadId> threadIdPckg(aThreadId);
#ifdef EKA2
return CreateSubSession(aSession, EIoOpenWriterByExplicitThreadId, TIpcArgs(&threadIdPckg));
#else
TInt p[4];
p[0] = &threadIdPckg;
return CreateSubSession(aSession, EIoOpenWriterByExplicitThreadId, &p[0]);
#endif
}
EXPORT_C void RIoWriteHandle::OpenL(RIoSession& aSession, TThreadId aThreadId)
{
User::LeaveIfError(Open(aSession, aThreadId));
}
EXPORT_C TInt RIoWriteHandle::Duplicate(RIoWriteHandle& aWriteHandle)
{
#ifdef EKA2
return SendReceive(EIoDuplicateWriter, TIpcArgs(aWriteHandle.SubSessionHandle()));
#else
TInt p[4];
p[0] = aWriteHandle.SubSessionHandle();
return SendReceive(EIoDuplicateWriter, &p[0]);
#endif
}
EXPORT_C void RIoWriteHandle::DuplicateL(RIoWriteHandle& aWriteHandle)
{
User::LeaveIfError(Duplicate(aWriteHandle));
}
EXPORT_C TInt RIoWriteHandle::DuplicateHandleFromThread(TThreadId aThreadId)
{
return SendReceive(EIoDuplicateWriterHandleFromThread, TIpcArgs(TUint(aThreadId)));
}
EXPORT_C TInt RIoWriteHandle::Write(const TDesC& aDes)
{
#ifdef EKA2
return SendReceive(EIoWrite, TIpcArgs(&aDes));
#else
TInt p[4];
p[0] = (TInt)&aDes;
return SendReceive(EIoWrite, &p[0]);
#endif
}
EXPORT_C void RIoWriteHandle::WriteL(const TDesC& aDes)
{
User::LeaveIfError(Write(aDes));
}
EXPORT_C void RIoWriteHandle::Write(const TDesC& aDes, TRequestStatus& aStatus)
{
#ifdef EKA2
return SendReceive(EIoWrite, TIpcArgs(&aDes), aStatus);
#else
TInt p[4];
p[0] = (TInt)&aDes;
SendReceive(EIoWrite, &p[0], aStatus);
#endif
}
EXPORT_C void RIoWriteHandle::WriteCancel()
{
#ifdef EKA2
SendReceive(EIoWriteCancel);
#else
SendReceive(EIoWriteCancel, NULL);
#endif
}
//
// RIoConsoleWriteHandle.
//
EXPORT_C RIoConsoleWriteHandle::RIoConsoleWriteHandle()
{
}
EXPORT_C RIoConsoleWriteHandle::RIoConsoleWriteHandle(RIoWriteHandle& aHandle)
{
*(RIoWriteHandle*)this = aHandle; // Take a bit-wise copy of the base class.
}
EXPORT_C RIoConsoleWriteHandle RIoConsoleWriteHandle::operator=(RIoWriteHandle& aHandle)
{
*(RIoWriteHandle*)this = aHandle; // Take a bit-wise copy of the base class.
return *this;
}
EXPORT_C TInt RIoConsoleWriteHandle::GetCursorPos(TPoint& aPos) const
{
TPckg<TPoint> posPckg(aPos);
#ifdef EKA2
TInt err = SendReceive(EIoConsoleCursorPos, TIpcArgs(&posPckg));
#else
TInt p[4];
p[0] = (TInt)&posPckg;
TInt err = SendReceive(EIoConsoleCursorPos, &p[0]);
#endif
return err;
}
EXPORT_C TPoint RIoConsoleWriteHandle::GetCursorPosL() const
{
TPoint pos;
User::LeaveIfError(GetCursorPos(pos));
return pos;
}
EXPORT_C TInt RIoConsoleWriteHandle::SetCursorPosAbs(const TPoint& aPoint)
{
TPckg<TPoint> posPckg(aPoint);
#ifdef EKA2
return SendReceive(EIoConsoleSetCursorPosAbs, TIpcArgs(&posPckg));
#else
TInt p[4];
p[0] = (TInt)&posPckg;
return SendReceive(EIoConsoleSetCursorPosAbs, &p[0]);
#endif
}
EXPORT_C void RIoConsoleWriteHandle::SetCursorPosAbsL(const TPoint& aPos)
{
User::LeaveIfError(SetCursorPosAbs(aPos));
}
EXPORT_C TInt RIoConsoleWriteHandle::SetCursorPosRel(const TPoint& aPoint)
{
TPckg<TPoint> posPckg(aPoint);
#ifdef EKA2
return SendReceive(EIoConsoleSetCursorPosRel, TIpcArgs(&posPckg));
#else
TInt p[4];
p[0] = (TInt)&posPckg;
return SendReceive(EIoConsoleSetCursorPosRel, &p[0]);
#endif
}
EXPORT_C void RIoConsoleWriteHandle::SetCursorPosRelL(const TPoint& aPos)
{
User::LeaveIfError(SetCursorPosRel(aPos));
}
EXPORT_C TInt RIoConsoleWriteHandle::SetCursorHeight(TInt aPercentage)
{
#ifdef EKA2
return SendReceive(EIoConsoleSetCursorHeight, TIpcArgs(aPercentage));
#else
TInt p[4];
p[0] = aPercentage;
return SendReceive(EIoConsoleSetCursorHeight, &p[0]);
#endif
}
EXPORT_C void RIoConsoleWriteHandle::SetCursorHeightL(TInt aPercentage)
{
User::LeaveIfError(SetCursorHeight(aPercentage));
}
EXPORT_C TInt RIoConsoleWriteHandle::SetTitle(const TDesC& aTitle)
{
#ifdef EKA2
return SendReceive(EIoConsoleSetTitle, TIpcArgs(&aTitle));
#else
TInt p[4];
p[0] = (TInt)&aTitle;
return SendReceive(EIoConsoleSetTitle, &p[0]);
#endif
}
EXPORT_C void RIoConsoleWriteHandle::SetTitleL(const TDesC& aTitle)
{
User::LeaveIfError(SetTitle(aTitle));
}
EXPORT_C TInt RIoConsoleWriteHandle::ClearScreen()
{
#ifdef EKA2
return SendReceive(EIoConsoleClearScreen);
#else
return SendReceive(EIoConsoleClearScreen, NULL);
#endif
}
EXPORT_C void RIoConsoleWriteHandle::ClearScreenL()
{
User::LeaveIfError(ClearScreen());
}
EXPORT_C TInt RIoConsoleWriteHandle::ClearToEndOfLine()
{
#ifdef EKA2
return SendReceive(EIoConsoleClearToEndOfLine);
#else
return SendReceive(EIoConsoleClearToEndOfLine, NULL);
#endif
}
EXPORT_C void RIoConsoleWriteHandle::ClearToEndOfLineL()
{
User::LeaveIfError(ClearToEndOfLine());
}
EXPORT_C TInt RIoConsoleWriteHandle::GetScreenSize(TSize& aSize) const
{
TPckg<TSize> sizePckg(aSize);
#ifdef EKA2
TInt err = SendReceive(EIoConsoleScreenSize, TIpcArgs(&sizePckg));
#else
TInt p[4];
p[0] = (TInt)&sizePckg;
TInt err = SendReceive(EIoConsoleScreenSize, &p[0]);
#endif
return err;
}
EXPORT_C TSize RIoConsoleWriteHandle::GetScreenSizeL() const
{
TSize size;
User::LeaveIfError(GetScreenSize(size));
return size;
}
EXPORT_C TInt RIoConsoleWriteHandle::SetAttributes(TUint aAttributes, ConsoleAttributes::TColor aForegroundColor, ConsoleAttributes::TColor aBackgroundColor)
{
#ifdef EKA2
TInt err = SendReceive(EIoConsoleSetAttributes, TIpcArgs(aAttributes, aForegroundColor, aBackgroundColor));
#else
TInt p[4];
p[0] = aAttributes;
p[1] = aForegroundColor;
p[2] = aBackgroundColor;
TInt err = SendReceive(EIoConsoleSetAttributes, &p[0]);
#endif
return err;
}
EXPORT_C void RIoConsoleWriteHandle::SetAttributesL(TUint aAttributes, ConsoleAttributes::TColor aForegroundColor, ConsoleAttributes::TColor aBackgroundColor)
{
User::LeaveIfError(SetAttributes(aAttributes, aForegroundColor, aBackgroundColor));
}
EXPORT_C TInt RIoConsoleWriteHandle::SetAttributes(const ConsoleAttributes::TAttributes& aAttributes)
{
return SetAttributes(aAttributes.iAttributes, aAttributes.iForegroundColor, aAttributes.iBackgroundColor);
}
EXPORT_C TInt RIoConsoleWriteHandle::SetIsStdErr(TBool aFlag)
{
return SendReceive(EIoSetIsStdErr, TIpcArgs(aFlag));
}
//
// RIoEndPoint.
//
EXPORT_C TInt RIoEndPoint::Attach(RIoReadHandle& aReader, TReadMode aMode)
{
#ifdef EKA2
return SendReceive(EIoEndPointAttachReader, TIpcArgs(aReader.SubSessionHandle(), aMode));
#else
TInt p[4];
p[0] = (TInt)aReader.SubSessionHandle();
p[1] = aMode;
return SendReceive(EIoEndPointAttachReader, &p[0]);
#endif
}
EXPORT_C void RIoEndPoint::AttachL(RIoReadHandle& aReader, TReadMode aMode)
{
User::LeaveIfError(Attach(aReader, aMode));
}
EXPORT_C TInt RIoEndPoint::Attach(RIoWriteHandle& aWriter)
{
#ifdef EKA2
return SendReceive(EIoEndPointAttachWriter, TIpcArgs(aWriter.SubSessionHandle()));
#else
TInt p[4];
p[0] = (TInt)aWriter.SubSessionHandle();
return SendReceive(EIoEndPointAttachWriter, &p[0]);
#endif
}
EXPORT_C void RIoEndPoint::AttachL(RIoWriteHandle& aWriter)
{
User::LeaveIfError(Attach(aWriter));
}
EXPORT_C TInt RIoEndPoint::SetForegroundReadHandle(RIoReadHandle& aReader)
{
#ifdef EKA2
return SendReceive(EIoEndPointSetForegroundReadHandle, TIpcArgs(aReader.SubSessionHandle()));
#else
TInt p[4];
p[0] = (TInt)aReader.SubSessionHandle();
return SendReceive(EIoEndPointSetForegroundReadHandle, &p[0]);
#endif
}
EXPORT_C void RIoEndPoint::SetForegroundReadHandleL(RIoReadHandle& aReader)
{
User::LeaveIfError(SetForegroundReadHandle(aReader));
}
EXPORT_C RIoEndPoint::RIoEndPoint()
{
}
//
// RIoPipe.
//
EXPORT_C TInt RIoPipe::Create(RIoSession& aSession)
{
#ifdef EKA2
return CreateSubSession(aSession, EIoCreatePipe);
#else
return CreateSubSession(aSession, EIoCreatePipe, NULL);
#endif
}
EXPORT_C void RIoPipe::CreateL(RIoSession& aSession)
{
User::LeaveIfError(Create(aSession));
}
//
// RIoConsole.
//
EXPORT_C TInt RIoConsole::Create(RIoSession& aSession, const TDesC& aTitle, const TSize& aSize, TUint aOptions)
{
return Create(aSession, KNullDesC, aTitle, aSize, aOptions);
}
EXPORT_C void RIoConsole::CreateL(RIoSession& aSession, const TDesC& aTitle, const TSize& aSize, TUint aOptions)
{
User::LeaveIfError(Create(aSession, aTitle, aSize, aOptions));
}
EXPORT_C TInt RIoConsole::Create(RIoSession& aSession, const TDesC& aImplementation, const TDesC& aTitle, const TSize& aSize, TUint aOptions)
{
TConsoleCreateParams params;
params.iSize = aSize;
params.iUnderlyingConsoleHandle = KNullHandle;
params.iOptions = aOptions;
TPckg<TConsoleCreateParams> paramsPckg(params);
#ifdef EKA2
return CreateSubSession(aSession, EIoCreateConsole, TIpcArgs(&aTitle, ¶msPckg, &aImplementation));
#else
TInt p[4];
p[0] = (TInt)&aTitle;
p[1] = (TInt)¶msPckg;
p[2] = (TInt)&aImplementation;
return CreateSubSession(aSession, EIoCreateConsole, &p[0]);
#endif
}
EXPORT_C TInt RIoConsole::Create(RIoSession& aSession, const TDesC& aImplementation, RIoConsole& aUnderlyingConsole, const TDesC& aTitle, const TSize& aSize, TUint aOptions)
{
TConsoleCreateParams params;
params.iSize = aSize;
params.iUnderlyingConsoleHandle = aUnderlyingConsole.SubSessionHandle();
params.iOptions = aOptions;
TPckg<TConsoleCreateParams> paramsPckg(params);
#ifdef EKA2
return CreateSubSession(aSession, EIoCreateConsole, TIpcArgs(&aTitle, ¶msPckg, &aImplementation));
#else
TInt p[4];
p[0] = (TInt)&aTitle;
p[1] = (TInt)¶msPckg;
p[2] = (TInt)&aImplementation;
return CreateSubSession(aSession, EIoCreateConsole, &p[0]);
#endif
}
EXPORT_C void RIoConsole::CreateL(RIoSession& aSession, const TDesC& aImplementation, const TDesC& aTitle, const TSize& aSize, TUint aOptions)
{
User::LeaveIfError(Create(aSession, aImplementation, aTitle, aSize, aOptions));
}
EXPORT_C void RIoConsole::CreateL(RIoSession& aSession, const TDesC& aImplementation, RIoConsole& aUnderlyingConsole, const TDesC& aTitle, const TSize& aSize, TUint aOptions)
{
User::LeaveIfError(Create(aSession, aImplementation, aUnderlyingConsole, aTitle, aSize, aOptions));
}
EXPORT_C TInt RIoConsole::Open(RIoSession& aSession, RIoHandle& aHandle)
{
#ifdef EKA2
return CreateSubSession(aSession, EIoOpenConsole, TIpcArgs(aHandle.SubSessionHandle()));
#else
TInt p[4];
p[0] = aHandle.SubSessionHandle();
return CreateSubSession(aSession, EIoOpenConsole, &p[0]);
#endif
}
EXPORT_C void RIoConsole::OpenL(RIoSession& aSession, RIoHandle& aHandle)
{
User::LeaveIfError(Open(aSession, aHandle));
}
EXPORT_C TInt RIoConsole::Implementation(TDes& aDes) const
{
#ifdef EKA2
return SendReceive(EIoConsoleImplementation, TIpcArgs(&aDes));
#else
TInt p[4];
p[0] = (TInt)&aDes;
return SendReceive(EIoConsoleImplementation, &p[0]);
#endif
}
EXPORT_C void RIoConsole::ImplementationL(TDes& aDes) const
{
User::LeaveIfError(Implementation(aDes));
}
//
// RIoPersistentConsole.
//
EXPORT_C TInt RIoPersistentConsole::Create(RIoSession& aSession, const TDesC& aName, const TDesC& aTitle)
{
#ifdef EKA2
return CreateSubSession(aSession, EIoCreatePersistentConsole, TIpcArgs(&aName, &aTitle));
#else
TInt p[4];
p[0] = (TInt)&aName;
p[1] = (TInt)&aTitle;
return CreateSubSession(aSession, EIoCreatePersistentConsole, &p[0]);
#endif
}
EXPORT_C void RIoPersistentConsole::CreateL(RIoSession& aSession, const TDesC& aName, const TDesC& aTitle)
{
User::LeaveIfError(Create(aSession, aName, aTitle));
}
EXPORT_C TInt RIoPersistentConsole::OpenByName(RIoSession& aSession, const TDesC& aName)
{
#ifdef EKA2
return CreateSubSession(aSession, EIoOpenPersistentConsoleByName, TIpcArgs(&aName));
#else
TInt p[4];
p[0] = (TInt)&aTitle;
return CreateSubSession(aSession, EIoOpenPersistentConsoleByName, &p[0]);
#endif
}
EXPORT_C void RIoPersistentConsole::OpenByNameL(RIoSession& aSession, const TDesC& aName)
{
User::LeaveIfError(OpenByName(aSession, aName));
}
EXPORT_C TInt RIoPersistentConsole::AttachReader(RIoEndPoint& aEndPoint, TCloseBehaviour aCloseBehaviour)
{
#ifdef EKA2
return SendReceive(EIoPersistentConsoleAttachReadEndPoint, TIpcArgs(aEndPoint.SubSessionHandle(), aCloseBehaviour));
#else
TInt p[4];
p[0] = aEndPoint.Handle();
p[1] = aCloseBehaviour;
return SendReceive(EIoPersistentConsoleAttachReadEndPoint, &p[0]);
#endif
}
EXPORT_C void RIoPersistentConsole::AttachReaderL(RIoEndPoint& aEndPoint, TCloseBehaviour aCloseBehaviour)
{
User::LeaveIfError(AttachReader(aEndPoint, aCloseBehaviour));
}
EXPORT_C void RIoPersistentConsole::DetachReader()
{
#ifdef EKA2
SendReceive(EIoPersistentConsoleDetachReadEndPoint, TIpcArgs());
#else
TInt p[4];
SendReceive(EIoPersistentConsoleDetachReadEndPoint, &p[0]);
#endif
}
EXPORT_C void RIoPersistentConsole::NotifyReaderDetach(TRequestStatus& aStatus)
{
SendReceive(EIoPersistentConsoleNotifyReadDetach, aStatus);
}
EXPORT_C void RIoPersistentConsole::CancelNotifyReaderDetach(TRequestStatus& aStatus)
{
#ifdef EKA2
SendReceive(EIoPersistentConsoleCancelNotifyReadDetach, TIpcArgs(&aStatus));
#else
TInt p[4];
p[0] = (TInt)&aStatus;
SendReceive(EIoPersistentConsoleCancelNotifyReadDetach, &p[0]);
#endif
}
EXPORT_C TInt RIoPersistentConsole::AttachWriter(RIoEndPoint& aEndPoint, TCloseBehaviour aCloseBehaviour)
{
#ifdef EKA2
return SendReceive(EIoPersistentConsoleAttachWriteEndPoint, TIpcArgs(aEndPoint.SubSessionHandle(), aCloseBehaviour));
#else
TInt p[4];
p[0] = aEndPoint.Handle();
p[1] = aCloseBehaviour;
return SendReceive(EIoPersistentConsoleAttachWriteEndPoint, &p[0]);
#endif
}
EXPORT_C void RIoPersistentConsole::AttachWriterL(RIoEndPoint& aEndPoint, TCloseBehaviour aCloseBehaviour)
{
User::LeaveIfError(AttachWriter(aEndPoint, aCloseBehaviour));
}
EXPORT_C void RIoPersistentConsole::DetachWriter()
{
#ifdef EKA2
SendReceive(EIoPersistentConsoleDetachWriteEndPoint, TIpcArgs());
#else
TInt p[4];
SendReceive(EIoPersistentConsoleDetachWriteEndPoint, &p[0]);
#endif
}
EXPORT_C void RIoPersistentConsole::NotifyWriterDetach(TRequestStatus& aStatus)
{
SendReceive(EIoPersistentConsoleNotifyWriteDetach, aStatus);
}
EXPORT_C void RIoPersistentConsole::CancelNotifyWriterDetach(TRequestStatus& aStatus)
{
#ifdef EKA2
SendReceive(EIoPersistentConsoleCancelNotifyWriteDetach, TIpcArgs(&aStatus));
#else
TInt p[4];
p[0] = &aStatus;
SendReceive(EIoPersistentConsoleCancelNotifyWriteDetach, &p[0]);
#endif
}
EXPORT_C TInt RIoPersistentConsole::GetAttachedReaderAndWriterNames(TName& aReaderName, TName& aWriterName)
{
#ifdef EKA2
return SendReceive(EIoPersistentConsoleGetAttachedNames, TIpcArgs(&aReaderName, &aWriterName));
#else
TInt p[4];
p[0] = &aReaderName;
p[1] = &aWriterName;
return SendReceive(EIoPersistentConsoleGetAttachedNames, &p[0]);
#endif
}
EXPORT_C void RIoPersistentConsole::GetAttachedReaderAndWriterNamesL(TName& aReaderName, TName& aWriterName)
{
User::LeaveIfError(GetAttachedReaderAndWriterNames(aReaderName, aWriterName));
}
EXPORT_C TInt RIoPersistentConsole::GetCreator(TThreadId& aThreadId)
{
TPckg<TThreadId> theadPckg(aThreadId);
#ifdef EKA2
return SendReceive(EIoPersistentConsoleGetCreatorThreadId, TIpcArgs(&theadPckg));
#else
TInt p[4];
p[0] = &theadPckg;
return SendReceive(EIoPersistentConsoleGetCreatorThreadId, &p[0]);
#endif
}
EXPORT_C TThreadId RIoPersistentConsole::GetCreatorL()
{
TThreadId id;
User::LeaveIfError(GetCreator(id));
return id;
}
//
// RIoFile.
//
EXPORT_C TInt RIoFile::Create(RIoSession& aSession, const TDesC& aFileName, TMode aMode)
{
#ifdef EKA2
return CreateSubSession(aSession, EIoCreateFile, TIpcArgs(&aFileName, (TInt)aMode));
#else
TInt p[4];
p[0] = (TInt)&aFileName;
p[1] = (TInt)aMode;
return CreateSubSession(aSession, EIoCreateFile, &p[0]);
#endif
}
EXPORT_C void RIoFile::CreateL(RIoSession& aSession, const TDesC& aFileName, TMode aMode)
{
User::LeaveIfError(Create(aSession, aFileName,aMode));
}
//
// RIoNull.
//
EXPORT_C TInt RIoNull::Create(RIoSession& aSession)
{
#ifdef EKA2
return CreateSubSession(aSession, EIoCreateNull);
#else
return CreateSubSession(aSession, EIoCreateNull, NULL);
#endif
}
EXPORT_C void RIoNull::CreateL(RIoSession& aSession)
{
User::LeaveIfError(Create(aSession));
}
//
// TIoHandleSet
//
EXPORT_C TIoHandleSet::TIoHandleSet(RIoSession& aIoSession, RIoReadHandle& aStdin, RIoWriteHandle& aStdout, RIoWriteHandle& aStderr)
: iIoSession(aIoSession), iStdin(aStdin), iStdout(aStdout), iStderr(aStderr), iSpare(0)
{
}
EXPORT_C RIoSession& TIoHandleSet::IoSession() const
{
return iIoSession;
}
EXPORT_C RIoReadHandle& TIoHandleSet::Stdin() const
{
return iStdin;
}
EXPORT_C RIoWriteHandle& TIoHandleSet::Stdout() const
{
return iStdout;
}
EXPORT_C RIoWriteHandle& TIoHandleSet::Stderr() const
{
return iStderr;
}