diff -r 000000000000 -r 5d03bc08d59c windowing/windowserver/minigui/src/econswserv.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/windowing/windowserver/minigui/src/econswserv.cpp Tue Feb 02 01:47:50 2010 +0200 @@ -0,0 +1,693 @@ +// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "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: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// + +#include +#include +#include +#include +#include +#include +#include + +const TInt KGroupId = 0x100039e7; + +class CWsConsoleMux; +class CWsConsole; + +// Active object to listen to Wserv events. Only used when +// application thread has installed an active scheduler +// +NONSHARABLE_CLASS(CWsKeyReader): public CActive + { +public: + CWsKeyReader(CWsConsoleMux* aMux); + void MakeRequest(); + +protected: + void RunL(); + void DoCancel(); + +private: + CWsConsoleMux* iMux; //uses + }; + +// Master console to dispatch key events to relevant console in situation where +// a single application thread owns multiple instances of console (CConsoleBase). +// Reference counted as only a single instance of this class will be created +// for each thread. +// +NONSHARABLE_CLASS(CWsConsoleMux): public CBase + { +public: + static TInt Open(); + static void Close(); + static CWsConsoleMux* Static(); + ~CWsConsoleMux(); + + void MakeRequest(CWsConsole* aConsole); + void CancelRequest(CWsConsole* aConsole); + void RequestComplete(); + + inline RWsSession& Session(); + inline RWindowGroup& Group(); + inline CWindowGc& Gc(); + inline CWsScreenDevice& Screen(); + +private: + static CWsConsoleMux* NewL(); + CWsConsoleMux(); + void ConstructL(); + +private: + TInt iRefCount; + RWsSession iWs; + RWindowGroup iGroup; + CWsScreenDevice* iScr; + CWindowGc* iGc; + + CWsConsole* iConsole; + CWsKeyReader* iReader; + }; + +// Console that uses direct Wserv API. Each console will own a window and +// a bitmap for its backing store, but will be sharing Wserv session, window group, +// screen device and window drawing context +// +NONSHARABLE_CLASS(CWsConsole): public CConsoleBase + { + friend class CWsConsoleMux; + +public: + CWsConsole(); + virtual ~CWsConsole(); + + //from CConsoleBase + virtual TInt Create(const TDesC &aTitle,TSize aSize); + virtual void Read(TRequestStatus &aStatus); + virtual void ReadCancel(); + virtual void Write(const TDesC &aDes); + virtual TPoint CursorPos() const; + virtual void SetCursorPosAbs(const TPoint &aPoint); + virtual void SetCursorPosRel(const TPoint &aPoint); + virtual void SetCursorHeight(TInt aPercentage); + virtual void SetTitle(const TDesC &aTitle); + virtual void ClearScreen(); + virtual void ClearToEndOfLine(); + virtual TSize ScreenSize() const; + virtual TKeyCode KeyCode() const; + virtual TUint KeyModifiers() const; + +private: + // for CWsConsoleMux + TRequestStatus* ReadStatus(); + void SetKey(TUint aCode, TUint aModifier); + + // internal + void ConstructL(); + void DrawNow(); + void Scroll(); + TPoint WritePos(); + void CarriageReturn(); + void LineFeed(); + void Left(); + void Right(); + void WriteChar(TText); + +private: + // window stuff + RWindow iWin; + TSize iWindowSize; + + // back buffer + CFbsBitmap* iBitmap; + CFbsBitGc* iBitGc; + CFbsBitmapDevice* iBitDev; + + // console stuff in chars dimension + TPoint iCursorPos; //The position of the cursor is on the baseline + TSize iSizeInChars; + + // font stuff + CFont* iFont; + TSize iCharSize; + TInt iFontAscent; + TInt iFontDescent; + + TKeyCode iKeyCode; + TUint iModifiers; + TTextCursor iTextCursor; + + // master console + CWsConsoleMux* iMux; + TRequestStatus* iReadStatus; + }; + +// +// CWsKeyReader implementation +// +// +// +CWsKeyReader::CWsKeyReader(CWsConsoleMux* aMux): + CActive(CActive::EPriorityStandard), + iMux(aMux) + { + CActiveScheduler::Add(this); + } + +void CWsKeyReader::MakeRequest() + { + SetActive(); + iMux->Session().EventReady(&iStatus); + } + +void CWsKeyReader::RunL() + { + // let master console decide what to do + iMux->RequestComplete(); + } + +void CWsKeyReader::DoCancel() + { + iMux->Session().EventReadyCancel(); + } + +// +// CWsConsoleMux implementation +// +// +// +TInt CWsConsoleMux::Open() + { + CWsConsoleMux* mux = (CWsConsoleMux*)Dll::Tls(); + + // not the first time, simply increment refcount + if (mux) + { + ++mux->iRefCount; + return KErrNone; + } + + // first time, let's create master console and + // stick it to TLS + TRAPD(err, mux = CWsConsoleMux::NewL()); + if (err != KErrNone) + { + return err; + } + + err = Dll::SetTls(mux); + if (err != KErrNone) + { + delete mux; + return err; + } + + ++mux->iRefCount; + return KErrNone; + } + +void CWsConsoleMux::Close() + { + CWsConsoleMux* mux = (CWsConsoleMux*)Dll::Tls(); + if (!mux) + { + return; + } + + // destroy master console if this is the last use from + // this thread and reset TLS + if (--mux->iRefCount == 0) + { + delete mux; + Dll::FreeTls(); + } + } + +CWsConsoleMux* CWsConsoleMux::Static() + { + return (CWsConsoleMux*)Dll::Tls(); + } + +CWsConsoleMux::CWsConsoleMux() + { + } + +CWsConsoleMux::~CWsConsoleMux() + { + delete iReader; + delete iGc; + delete iScr; + iGroup.Close(); + iWs.Close(); + } + +CWsConsoleMux* CWsConsoleMux::NewL() + { + CWsConsoleMux* mux = new(ELeave) CWsConsoleMux; + CleanupStack::PushL(mux); + mux->ConstructL(); + CleanupStack::Pop(mux); + + return mux; + } + +void CWsConsoleMux::ConstructL() + { + TInt err = iWs.Connect(); + User::LeaveIfError(err); + + iScr = new(ELeave) CWsScreenDevice(iWs); + err = iScr->Construct(); + User::LeaveIfError(err); + + iGc = new(ELeave) CWindowGc(iScr); + err = iGc->Construct(); + User::LeaveIfError(err); + + iGroup = RWindowGroup(iWs); + err = iGroup.Construct(KGroupId, ETrue); + User::LeaveIfError(err); + + // we will be using active object to listen to Wserv events + // only if this thread already has active scheduler + // + if (CActiveScheduler::Current()) + { + iReader = new(ELeave) CWsKeyReader(this); + } + } + +RWsSession& CWsConsoleMux::Session() + { + return iWs; + } + +RWindowGroup& CWsConsoleMux::Group() + { + return iGroup; + } + +CWindowGc& CWsConsoleMux::Gc() + { + return *iGc; + } + +CWsScreenDevice& CWsConsoleMux::Screen() + { + return *iScr; + } + +void CWsConsoleMux::MakeRequest(CWsConsole* aConsole) + { + if (!iReader) + { + // client does not have scheduler, ideally we should use + // secondary thread to make this asynchronous. + // + // however, we can get away with this because application + // that doesn't use active scheduler will be calling asynchronous console read + // and immediately followed by WaitForRequest e.g. + // + // while (1) + // { + // ... + // console->Read(status); + // User::WaitForRequest(status); + // ... + // } + // + TWsEvent event; + + // keep going until we got key event + do + { + TRequestStatus s; + s = KRequestPending; + iWs.EventReady(&s); + User::WaitForRequest(s); + + iWs.GetEvent(event); + } + while (event.Type() != EEventKey); + + aConsole->SetKey(event.Key()->iCode, event.Key()->iModifiers); + TRequestStatus* pS = aConsole->ReadStatus(); + User::RequestComplete(pS, KErrNone); + } + else + { + iConsole = aConsole; + iReader->MakeRequest(); + } + } + +// called from key listener RunL +// +void CWsConsoleMux::RequestComplete() + { + TWsEvent event; + iWs.GetEvent(event); + + if (event.Type() == EEventKey) + { + iConsole->SetKey(event.Key()->iCode, event.Key()->iModifiers); + TRequestStatus* pS = iConsole->ReadStatus(); + User::RequestComplete(pS, KErrNone); + iConsole = NULL; + } + else + { + // keep going until we got key event + // + iReader->MakeRequest(); + } + } + +void CWsConsoleMux::CancelRequest(CWsConsole* aConsole) + { + if (iReader && iConsole == aConsole) + { + iReader->Cancel(); + } + } + +// +// CWsConsole implementation +// +// +// +CWsConsole::CWsConsole() + { + } + +CWsConsole::~CWsConsole() + { + if(iBitGc) + { + iBitGc->DiscardFont(); + } + if(iBitDev) + { + iBitDev->ReleaseFont(iFont); + } + + delete iBitGc; + delete iBitDev; + delete iBitmap; + iWin.Close(); + iMux->Session().Flush(); + + CWsConsoleMux::Close(); + } + +TInt CWsConsole::Create(const TDesC& /*aTitle*/, TSize /*aSize*/) + { + // we must not push this object to cleanup stack during construction because + // caller will explicitly call delete on this object when Create() returns error + // + TRAPD(err, ConstructL()); + return err; + } + +void CWsConsole::ConstructL() + { + TInt err = CWsConsoleMux::Open(); + User::LeaveIfError(err); + + iMux = CWsConsoleMux::Static(); + + iWindowSize = iMux->Screen().SizeInPixels(); + + iBitmap = new(ELeave) CFbsBitmap; + err = iBitmap->Create(iWindowSize, EGray2); + User::LeaveIfError(err); + + iBitDev = CFbsBitmapDevice::NewL(iBitmap); + err = iBitDev->CreateContext(iBitGc); + User::LeaveIfError(err); + + iBitGc->SetPenColor(KRgbBlack); + iBitGc->SetBrushStyle(CGraphicsContext::ESolidBrush); + iBitGc->SetBrushColor(KRgbWhite); + iBitGc->Clear(); + + TFontSpec fs(_L("DejaVu Sans Mono"), 12); + err = iBitDev->GetNearestFontToDesignHeightInPixels(iFont, fs); + User::LeaveIfError(err); + + iBitGc->UseFont(iFont); + + // uses monospace font to get uniform glpyh size + iCharSize.iHeight = iFont->FontMaxAscent() + iFont->FontMaxDescent(); + iCharSize.iWidth = iFont->MaxCharWidthInPixels(); + iFontAscent = iFont->FontMaxAscent(); + iFontDescent= iFont->FontMaxDescent(); + + // cursor represent char position in character-based area + // eshell is using 0,0 based + iCursorPos = TPoint(1,1); + // console size in number of characters and lines + iSizeInChars.iWidth = iWindowSize.iWidth / iCharSize.iWidth; + iSizeInChars.iHeight = iWindowSize.iHeight / iCharSize.iHeight; + + iTextCursor.iType = TTextCursor::ETypeRectangle; + iTextCursor.iHeight = iCharSize.iHeight; + iTextCursor.iAscent = iFontAscent; + iTextCursor.iWidth = iCharSize.iWidth; + iTextCursor.iFlags = 0; + iTextCursor.iColor = KRgbWhite; + + + iWin = RWindow(iMux->Session()); + err = iWin.Construct(iMux->Group(), (TInt)this); + User::LeaveIfError(err); + + iWin.Activate(); + iMux->Session().Flush(); + } + +TRequestStatus* CWsConsole::ReadStatus() + { + return iReadStatus; + } + +void CWsConsole::SetKey(TUint aCode, TUint aModifier) + { + iKeyCode = (TKeyCode)aCode; + iModifiers = aModifier; + } + +TPoint CWsConsole::WritePos() + { + return TPoint((iCursorPos.iX - 1) * iCharSize.iWidth, (iCursorPos.iY - 1) * iCharSize.iHeight + iFontAscent); + } + +void CWsConsole::Read(TRequestStatus &aStatus) + { + iReadStatus = &aStatus; + *iReadStatus = KRequestPending; + iMux->MakeRequest(this); + } + +void CWsConsole::ReadCancel() + { + iMux->CancelRequest(this); + iReadStatus = NULL; + } + +void CWsConsole::CarriageReturn() + { + iCursorPos.iX = 1; + } + +void CWsConsole::LineFeed() + { + CarriageReturn(); + if (iCursorPos.iY < iSizeInChars.iHeight) + { + ++iCursorPos.iY; + } + else + { + Scroll(); + } + } + +void CWsConsole::Left() + { + if (iCursorPos != TPoint(1,1)) + { + if (iCursorPos.iX == 1) + { + iCursorPos.iX += iSizeInChars.iWidth; + --iCursorPos.iY; + } + --iCursorPos.iX; + } + } + +void CWsConsole::Right() + { + ++iCursorPos.iX; + if (iCursorPos.iX > iSizeInChars.iWidth) + { + LineFeed(); + } + } + +void CWsConsole::Write(const TDesC& aDes) + { + const TInt length = aDes.Length(); + if (length == 0) + { + return; + } + + for (TInt i=0; i s; + s.Append(aChar); + // use draw text box to clear the glpyh box + TPoint writePos = WritePos(); + TRect r(writePos.iX, writePos.iY-iFontAscent,writePos.iX+iCharSize.iWidth, writePos.iY+iFontDescent); + iBitGc->DrawText(s, r, iFontAscent); + Right(); + } + +TPoint CWsConsole::CursorPos() const + { + // eshell is using 0,0 based + return iCursorPos - TPoint(1,1); + } + +void CWsConsole::SetCursorPosAbs(const TPoint& aPoint) + { + // eshell is using 0,0 based + iCursorPos = aPoint + TPoint(1,1); + iMux->Group().SetTextCursor(iWin, WritePos(), iTextCursor); + } + +void CWsConsole::SetCursorPosRel(const TPoint& aPoint) + { + iCursorPos += aPoint; + iMux->Group().SetTextCursor(iWin, WritePos(), iTextCursor); + } + +void CWsConsole::SetCursorHeight(TInt aPercentage) + { + if (aPercentage == 0) + { + // none + iTextCursor.iHeight = 0; + } + else if (aPercentage == 100) + { + // insert + iTextCursor.iHeight = iCharSize.iHeight; + iTextCursor.iAscent = iFontAscent; + } + else + { + // normal + iTextCursor.iHeight = 1; + iTextCursor.iAscent = 0; + } + + iMux->Group().SetTextCursor(iWin, WritePos(), iTextCursor); + } + +void CWsConsole::SetTitle(const TDesC& /*aTitle*/) + { + } + +void CWsConsole::ClearScreen() + { + iBitGc->Clear(); + iCursorPos.iX = iCursorPos.iY = 1; + DrawNow(); + } + +void CWsConsole::ClearToEndOfLine() + { + iMux->Group().CancelTextCursor(); + TPoint writePos = WritePos(); + TRect r(writePos.iX, writePos.iY-iFontAscent, iWindowSize.iWidth, writePos.iY+iFontDescent); + iBitGc->Clear(r); + DrawNow(); + iMux->Group().SetTextCursor(iWin, WritePos(), iTextCursor); + } + +TSize CWsConsole::ScreenSize() const + { + return iSizeInChars; + } + +TKeyCode CWsConsole::KeyCode() const + { + return iKeyCode; + } + +TUint CWsConsole::KeyModifiers() const + { + return iModifiers; + } + +void CWsConsole::DrawNow() + { + iWin.Invalidate(); + iWin.BeginRedraw(); + iMux->Gc().Activate(iWin); + iMux->Gc().BitBlt(TPoint(0,0), iBitmap); + iMux->Gc().Deactivate(); + iWin.EndRedraw(); + iMux->Session().Flush(); + } + +void CWsConsole::Scroll() + { + TRect r(0, iCharSize.iHeight, iWindowSize.iWidth, iSizeInChars.iHeight * iCharSize.iHeight); + + iBitGc->CopyRect(TPoint(0, -iCharSize.iHeight), r); + // clear last line + TRect rect(0, WritePos().iY-iFontAscent, iWindowSize.iWidth, iWindowSize.iHeight); + iBitGc->Clear(rect); + } + +extern "C" EXPORT_C TAny *NewConsole() + { + return new CWsConsole; + }