1 // Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // e32\ewsrv\ws_main.cpp

    15 // 

    16 //

    17 

    18 #include "ws_std.h"

    19 #include <e32hal.h>

    20 #include <hal.h>

    21 #include <e32math.h>

    22 #include <domainmanager.h>

    23 #ifdef __WINS__

    24 #include <e32wins.h>

    25 #endif

    26 

    27 GLREF_D CKeyTranslator *KeyTranslator;

    28 GLREF_D CKeyRepeat* KeyRepeat;

    29 

    30 // password notifier support functions

    31 LOCAL_C void RenderPassword(RConsole *aCon, TInt aPWLeft, const TDesC& aPW);

    32 

    33 _LIT(KShellProcessName, "ESHELL");

    34 _LIT(KShellCommandLine, "/p");

    35 

    36 //

    37 // class CKeyRepeat

    38 //

    39 

    40 CKeyRepeat::CKeyRepeat(TInt aPriority) : CTimer(aPriority)

    41 //

    42 // Constructor. Set default repeat delay and rate

    43 //

    44     {

    45     iDelay=EDefaultKeyRepeatDelay;

    46     iRate=EDefaultKeyRepeatRate;

    47     }

    48 

    49 void CKeyRepeat::ConstructL()

    50     {

    51 

    52     CTimer::ConstructL();

    53     CActiveScheduler::Add(this);

    54     }

    55 

    56 void CKeyRepeat::RunL()

    57 //

    58 // Send a repeat keypress to the window

    59 //

    60     {

    61 

    62     After(iRate);

    63 	CWsWindow::KeyPress(iKeyData);

    64     }

    65 

    66 void CKeyRepeat::Request(TKeyData& aKeyData)

    67 //

    68 // Request a repeat event

    69 //

    70     {

    71 

    72     iKeyData=aKeyData;

    73 	Cancel();

    74     After(iDelay);

    75     }

    76 

    77 void CKeyRepeat::SetRepeatTime(TInt aDelay,TInt aRate)

    78     {

    79 

    80     iDelay=aDelay;

    81     iRate=aRate;

    82     }

    83 

    84 void CKeyRepeat::RepeatTime(TInt& aDelay,TInt& aRate)

    85     {

    86 

    87     aDelay=iDelay;

    88     aRate=iRate;

    89     }

    90 

    91 //

    92 // class CWsSession

    93 //

    94 

    95 CWsSession::CWsSession()

    96 	{

    97 	iTestFast = (UserSvr::DebugMask(2)&0x00000002) ? 1 : 0;

    98 	}

    99 

   100 CWsSession::~CWsSession()

   101 //

   102 // Destructor

   103 //

   104 	{

   105 

   106 	delete iWindow;

   107 	}

   108 

   109 //

   110 // class CWsServer

   111 //

   112 

   113 void CWsServer::New()

   114 //

   115 // Create a new CWsServer.

   116 //

   117 	{

   118 

   119 	CWsServer *pS=new CWsServer(EPriority);

   120 	__ASSERT_ALWAYS(pS!=NULL,Fault(ECreateServer));

   121 	pS->SetPinClientDescriptors(EFalse); // don't pin because client interface can't cope with errors if pin fails under real or simulated OOM

   122 	TInt r=pS->Start(KE32WindowServer);

   123 	__ASSERT_ALWAYS(r==KErrNone,Fault(EStartServer));

   124 	RProcess::Rendezvous(KErrNone);

   125 

   126 	}

   127 

   128 CWsServer::CWsServer(TInt aPriority)

   129 //

   130 // Constructor.

   131 //

   132 	: CServer2(aPriority)

   133 	{

   134 	}

   135 

   136 CSession2* CWsServer::NewSessionL(const TVersion& aVersion,const RMessage2&) const

   137 //

   138 // Create a new client for this server.

   139 //

   140 	{

   141 

   142 	TVersion v(KW32MajorVersionNumber,KW32MinorVersionNumber,KE32BuildVersionNumber);

   143 	TBool r=User::QueryVersionSupported(v,aVersion);

   144 	if (!r)

   145 		User::Leave(KErrNotSupported);

   146 	return new(ELeave) CWsSession;

   147 	}

   148 

   149 void CWsSession::ServiceL(const RMessage2& aMessage)

   150 //									    

   151 // Handle messages for this session.

   152 //

   153 	{

   154 

   155 	iCurMsg = aMessage;

   156 	CWsWindow::WaitOnService();

   157 	CWsWindow* pW=iWindow;

   158 	TInt r=EPrematureOperation;

   159 	TBool delayCompletion=EFalse;

   160 	switch (aMessage.Function())

   161 		{

   162 	case EConsoleCreate:

   163 		{

   164 		if (pW)

   165 			{

   166 			delete pW;

   167 			iWindow=NULL;

   168 			}

   169 		pW=new CWsWindow;

   170 		if (!pW)

   171 			{ 

   172 			r=EWindowOutOfMemory;

   173 			break;

   174 			}

   175 		iWindow=pW;

   176 		pW->iAllowResize=ETrue;

   177 		pW->iIsVisible=ETrue;

   178 		pW->iOnTop=EFalse;

   179 		pW->SetCursorHeight(50);

   180 		pW->iKQueue.SetOffset(_FOFF(SWsKey,iLink));

   181 		break;

   182 		}

   183 	case EConsoleSet:

   184 		{

   185 		if (!pW)

   186 			{

   187 			pW=new(ELeave) CWsWindow;

   188 			iWindow=pW;

   189 			pW->iAllowResize=ETrue;

   190 			pW->iIsVisible=ETrue;

   191 			pW->iOnTop=EFalse;

   192 			pW->SetCursorHeight(50);

   193 			pW->iKQueue.SetOffset(_FOFF(SWsKey,iLink));

   194 			}

   195 		pW->iAllowSlide=ETrue;

   196 		TFileName name;

   197 		iCurMsg.ReadL(0, name);

   198 		pW->iTitle=name;

   199 		TPckgBuf<TSize> size;

   200 		iCurMsg.ReadL(1, size);

   201 		TRAP(r,pW->CreateL(size()));

   202 		if (r != KErrNone)

   203 			{

   204 			delete pW;

   205 			iWindow=NULL;			

   206 			}

   207 		break;

   208 		}

   209 	case EConsoleClearScreen:

   210 		{

   211 		if (pW)

   212 			{

   213 			pW->Clear();

   214 			r=KErrNone;

   215 			}

   216 		break;

   217 		}

   218 	case EConsoleClearToEndOfLine:

   219 		{

   220 		if (pW)

   221 			{

   222 			pW->ClearToEndOfLine();

   223 			r=KErrNone;

   224 			}

   225 		break;

   226 		}

   227 	case EConsoleSetTitle:

   228 		{

   229 		if (pW)

   230 			{

   231 			TFileName name;

   232 			iCurMsg.ReadL(0, name);

   233 			pW->SetTitle(name);

   234 			r=KErrNone;

   235 			}

   236 		break;

   237 		}

   238 	case EConsoleSetSize:

   239 		{

   240 		if (pW)

   241 			{

   242 			TPckgBuf<TSize> size;

   243 			iCurMsg.ReadL(0, size);

   244 //			pW->SetSize(size());

   245 //			r=KErrNone;

   246 			r=KErrNotSupported;

   247 			}

   248 		break;

   249 		}

   250 	case EConsoleSetWindowPosAbs:

   251 		{

   252 		if (pW)

   253 			{

   254 			TPckgBuf<TPoint> point;

   255 			iCurMsg.ReadL(0, point);

   256 			pW->SetWindowPosAbs(point());

   257 			r=KErrNone;

   258 			}

   259 		break;

   260 		}

   261 	case EConsoleSetCursorHeight:

   262 		{

   263 		if (pW)

   264 			{

   265 			pW->SetCursorHeight(aMessage.Int0());

   266 			r=KErrNone;

   267 			}

   268 		break;

   269 		}

   270 	case EConsoleSetCursorPosAbs:

   271 		{

   272 		if (pW)

   273 			{

   274 			TPckgBuf<TPoint> point;

   275 			iCurMsg.ReadL(0, point);

   276 			pW->SetCursorPosAbs(point());

   277 			r=KErrNone;

   278 			}

   279 		break;

   280 		}

   281 	case EConsoleSetCursorPosRel:

   282 		{

   283 		if (pW)

   284 			{

   285 			TPckgBuf<TPoint> point;

   286 			iCurMsg.ReadL(0, point);

   287 			pW->SetCursorPosRel(point());

   288 			r=KErrNone;

   289 			}

   290 		break;

   291 		}

   292 	case EConsoleCursorPos:

   293 		{

   294 		if (pW)

   295 			{

   296 			TPckgBuf<TPoint> point;

   297 			point()=pW->CursorPosition();

   298 			aMessage.WriteL(0,point);

   299 			r=KErrNone;

   300 			}

   301 		break;

   302 		}

   303 	case EConsoleSize:

   304 		{

   305 		if (pW)

   306 			{

   307 			TPckgBuf<TSize> size;

   308 			size()=pW->Size();

   309 			aMessage.WriteL(0,size);

   310 			r=KErrNone;

   311 			}

   312 		break;

   313 		}

   314 	case EConsoleScreenSize:

   315 		{

   316 		if (pW)

   317 			{

   318 			TPckgBuf<TSize> size;

   319 			size()=CWsWindow::ScreenSize;

   320 			aMessage.WriteL(0,size);

   321 			r=KErrNone;

   322 			}

   323 		break;

   324 		}

   325 	case EConsoleControl:

   326 		{

   327 		if (pW)

   328 			{

   329 			TBool indicator=ETrue;

   330 			TInt offset=0;

   331 			TBuf<0x100> b;

   332 			do

   333 				{

   334 				iCurMsg.ReadL(0,b,offset);

   335 				for (const TText* pB=b.Ptr();pB<b.Ptr()+b.Length();pB++)

   336 					{

   337 					switch(*pB)

   338 						{

   339 					case '+':

   340 

   341 						indicator=ETrue;

   342 						break;

   343 					case '-':

   344 						indicator=EFalse;

   345 						break;

   346 					case 'S':

   347 						pW->ControlScrollBars(indicator);

   348 						break;

   349 					case 'W':

   350 						pW->ControlWrapLock(indicator);

   351 						break;

   352                     case 'P':

   353                         pW->ControlPointerEvents(indicator);

   354                         break;

   355 					case 'L':

   356 						pW->ControlScrollLock(indicator);

   357 						break;

   358 					case 'V':

   359 						pW->ControlVisibility(indicator);

   360 						break;

   361 					case 'C':

   362 						pW->ControlCursorRequired(indicator);

   363 						break;

   364 					case 'M':

   365 						pW->ControlMaximised(indicator);

   366 						break;

   367 					case 'N':

   368 						pW->ControlNewLineMode(indicator);

   369 						break;

   370                     case 'O':

   371 						pW->ControlOnTop(indicator);

   372 						break;

   373 					case 'I':

   374                         pW->ControlInformAllMouse(indicator);

   375                         break;

   376                     case 'R':

   377                         pW->ControlRawEventMode(indicator);

   378                         break;

   379 					case 'A':

   380 						pW->ControlAllowResize(indicator);

   381 						}

   382 					}

   383 				offset+=b.Length();

   384 				}

   385 			while (b.Length()==b.MaxLength());

   386 			r=KErrNone;

   387 			}

   388 		break;

   389 		}

   390 	case EConsoleWrite:

   391 		{

   392 		if (pW)

   393 			{

   394 			switch(iTestFast)

   395 				{

   396 			case 0:

   397 				{

   398 				TInt offset=0;

   399 				TBuf<0x100> b;

   400 				do

   401 					{

   402 					iCurMsg.ReadL(0,b,offset);

   403 					pW->Write(b);

   404 					offset+=b.Length();

   405 					}

   406 				while (b.Length()==b.MaxLength());

   407 				pW->WriteDone();

   408 				}

   409 				r=KErrNone;

   410 				break;

   411 

   412 			case 1:

   413 				{

   414 				pW->Write(_L("Output suppressed because TESTFAST mode is set..."));

   415 				pW->WriteDone();

   416 				++iTestFast;

   417 				}

   418 				r=KErrNone;

   419 				break;

   420 

   421 			default:

   422 				r=KErrNone;

   423 				break;

   424 				}

   425 			}

   426 		break;

   427 		}

   428 	case EConsoleRead:

   429 		{

   430 		if (pW)

   431 			{

   432 			if (pW->EnqueReadRequest(aMessage))

   433 				{

   434 				delayCompletion=ETrue;

   435 				r=KErrNone;

   436 				}

   437 			else

   438 				r=EDoubleReadRequest;

   439 			}

   440 		break;

   441 		}

   442 	case EConsoleReadCancel:

   443 		{

   444 		if (pW)

   445 			{

   446 			pW->DequeReadRequest();

   447 			r=KErrNone;

   448 			}

   449 		break;

   450 		}

   451 	case EConsoleDestroy:

   452 		{

   453 		if (pW)

   454 			{

   455 			delete pW;

   456 			iWindow=NULL;

   457 			r=KErrNone;

   458 			}

   459 		break;

   460 		}

   461 	case EConsoleSetMode:

   462 		{

   463 		r=CWsWindow::SetMode((TVideoMode)aMessage.Int0());		

   464 		break;

   465 		}

   466 	case EConsoleSetPaletteEntry:

   467 		{

   468 		CWsWindow::ScreenDriver->SetPaletteEntry((TColorIndex)aMessage.Int0(),(TUint8)aMessage.Int1(),(TUint8)aMessage.Int2(),(TUint8)aMessage.Int3());

   469 		pW->Redraw();

   470 		r=KErrNone;

   471 		break;

   472 		}

   473 	case EConsoleGetPaletteEntry:

   474 		{

   475 		TUint8 r,g,b;

   476 		TPckgBuf<TUint8> red,green,blue;

   477 		CWsWindow::ScreenDriver->GetPaletteEntry((TColorIndex)aMessage.Int0(),r,g,b);

   478 		red()=r; green()=g; blue()=b;

   479 		aMessage.WriteL(1,red);

   480 		aMessage.WriteL(2,green);

   481 		aMessage.WriteL(3,blue);

   482 		}

   483 		r=KErrNone;

   484 		break;

   485 	case EConsoleSetTextColors:

   486 		{

   487 		if(pW)

   488 			{

   489 			pW->iFgColor=(TColorIndex)aMessage.Int0();

   490 			pW->iBgColor=(TColorIndex)aMessage.Int1();

   491 			}		

   492 		r=KErrNone;

   493 		break;

   494 		}

   495 	case EConsoleSetUIColors:

   496 		{

   497 		CWsWindow::WindowBgColor=(TColorIndex)aMessage.Int0();

   498 		CWsWindow::BorderColor=(TColorIndex)aMessage.Int1();

   499 		CWsWindow::ScreenColor=(TColorIndex)aMessage.Int2();

   500 		CWsWindow::ChangeUIColors();

   501 		r=KErrNone;

   502 		break;

   503 		}

   504 	case EConsoleSetTextAttribute:

   505 		{

   506 		if(pW)

   507 			pW->SetTextAttribute((TTextAttribute)aMessage.Int0());		

   508 		r=KErrNone;

   509 		break;

   510 		}

   511 	default:

   512 		r=KErrNotSupported;

   513 		}

   514 	if (!delayCompletion)

   515 		aMessage.Complete(r);

   516 	CWsWindow::SignalService();

   517 	}

   518 

   519 void CWsSession::ServiceError(const RMessage2& aMessage,TInt aError)

   520 	{

   521 	if (!aMessage.IsNull())

   522 		{

   523 		if (aError>0)

   524 			{

   525 			aMessage.Panic(_L("WServ panic"),aError);

   526 			}

   527 		else

   528 			{

   529 			aMessage.Complete(aError);

   530 			}

   531 		}

   532 	}

   533 

   534 CWsServer::~CWsServer()

   535 //

   536 // Destructor

   537 //

   538 	{

   539 	}

   540 

   541 //

   542 // class CEvent

   543 //

   544 

   545 void CEvent::New()

   546 //

   547 // Create the CEvent active object.

   548 //

   549 	{

   550 

   551 	CEvent *pE=new CEvent(EPriority);

   552 	__ASSERT_ALWAYS(pE!=NULL,Fault(ECreateEvent));

   553 	pE->CaptureKeys=new CCaptureKeys();

   554 	__ASSERT_ALWAYS(pE->CaptureKeys!=NULL,Fault(ECreateEvent));

   555 

   556 	pE->CaptureKeys->Construct();

   557 

   558 	CActiveScheduler::Add(pE);

   559 	UserSvr::CaptureEventHook();

   560 	pE->Request();

   561 	}

   562 

   563 CEvent::~CEvent()

   564 //

   565 // Destroy the CEvent active object

   566 //

   567 	{

   568 

   569 	Cancel();

   570 	}

   571 

   572 #pragma warning( disable : 4705 )	// statement has no effect

   573 CEvent::CEvent(TInt aPriority)

   574 //

   575 // Constructor

   576 //

   577 	: CActive(aPriority)

   578 	{

   579 	}

   580 #pragma warning( default : 4705 )

   581 

   582 void CEvent::Request()

   583 //

   584 // Issue a request for the next event.

   585 //

   586 	{

   587 

   588 	UserSvr::RequestEvent(iEvent,iStatus);

   589 	SetActive();

   590 	}

   591 

   592 void CEvent::DoCancel()

   593 //

   594 // Cancel a pending event.

   595 //

   596 	{

   597 

   598 	UserSvr::RequestEventCancel();

   599 	}

   600 

   601 void CEvent::RunL()

   602 //

   603 // Event has completed.

   604 //

   605 	{

   606 

   607     if (CWsWindow::RawEventMode())

   608         {

   609         KeyRepeat->Cancel();

   610         CWsWindow::QueueRawEvent(iEvent.Event());

   611         Request();

   612         return;

   613         }

   614 	switch(iEvent.Event().Type())

   615 		{

   616 	case TRawEvent::ERedraw:

   617 		CWsWindow::Redraw();

   618 		break;

   619 	case TRawEvent::EButton1Down:

   620         if(!CWsWindow::MouseIsCaptured)

   621             {

   622       		CWsWindow::MouseMove(iEvent.Event().Pos());

   623   	    	CWsWindow::MouseLeftButton();

   624             }

   625         else

   626             CWsWindow::InformTopMouse(iEvent.Event().Pos());

   627 		break;

   628 	case TRawEvent::EButton1Up:

   629 		if(!CWsWindow::MouseIsCaptured)

   630 			{

   631 			CWsWindow::MouseMove(iEvent.Event().Pos());

   632 			CWsWindow::MouseLeftButtonUp();

   633 			}

   634 		break;

   635 	case TRawEvent::EButton2Down:

   636 		break;

   637 	case TRawEvent::EButton2Up:

   638 		break;

   639 	case TRawEvent::EButton3Down:

   640 		break;

   641 	case TRawEvent::EButton3Up:

   642 		break;

   643 	case TRawEvent::EPointerMove:

   644 		CWsWindow::MouseMove(iEvent.Event().Pos());

   645 		break;

   646 	case TRawEvent::EInactive:

   647         KeyRepeat->Cancel();

   648         break;

   649     case TRawEvent::EActive:

   650         break;

   651     case TRawEvent::EUpdateModifiers:

   652         KeyTranslator->UpdateModifiers(iEvent.Event().Modifiers());

   653         break;

   654 	case TRawEvent::EKeyDown:

   655 		{

   656 		TKeyData keyData;

   657 		if (KeyTranslator->TranslateKey(iEvent.Event().ScanCode(), EFalse,*CaptureKeys,keyData))

   658 			CWsWindow::KeyPress(keyData);

   659 		if (keyData.iModifiers&EModifierAutorepeatable)

   660 			KeyRepeat->Request(keyData);

   661 		break;

   662 		}

   663 	case TRawEvent::EKeyUp:

   664 		{

   665 		TKeyData keyData;

   666 		KeyRepeat->Cancel();

   667 		if (KeyTranslator->TranslateKey(iEvent.Event().ScanCode(), ETrue,*CaptureKeys,keyData))

   668 			CWsWindow::KeyPress(keyData);

   669 		break;

   670 		}

   671 	case TRawEvent::ESwitchOn:

   672 	case TRawEvent::ECaseOpen:

   673 		HAL::Set(HAL::EDisplayState, 1);

   674 			{

   675 			RDmDomainManager mgr; 

   676 			TInt r = mgr.Connect();

   677 			if (r != KErrNone)

   678 				User::Panic(_L("EWSRV SwitchOn0"), r);

   679 			TRequestStatus status;

   680 			mgr.RequestDomainTransition(KDmIdUiApps, EPwActive, status);

   681 			User::WaitForRequest(status);

   682 			if (status.Int() != KErrNone)

   683 				User::Panic(_L("EWSRV SwitchOn1"), status.Int());

   684 			mgr.Close();

   685 			}

   686 		break;

   687 	case TRawEvent::EPointerSwitchOn:

   688 #if defined(_DEBUG)

   689     	User::Beep(440,250000);

   690 #endif

   691 		break;

   692 	case TRawEvent::ESwitchOff:

   693 			{

   694 			RDmDomainManager mgr; 

   695 			TInt r = mgr.Connect();

   696 			if (r != KErrNone)

   697 				User::Panic(_L("EWSRV SwitchOff0"), r);

   698 			TRequestStatus status;

   699 			mgr.RequestSystemTransition(EPwStandby, status);

   700 			User::WaitForRequest(status);

   701 			if (status.Int() != KErrNone)

   702 				User::Panic(_L("EWSRV SwitchOff1"), status.Int());

   703 			mgr.Close();

   704 			}

   705 		break;

   706 	case TRawEvent::ECaseClose:

   707 			{

   708 			RDmDomainManager mgr; 

   709 			TInt r = mgr.Connect();

   710 			if (r != KErrNone)

   711 				User::Panic(_L("EWSRV CaseClosed"), r);

   712 			TRequestStatus status;

   713 			mgr.RequestDomainTransition(KDmIdUiApps, EPwStandby, status);

   714 			User::WaitForRequest(status);

   715 			if (status.Int() != KErrNone)

   716 				User::Panic(_L("EWSRV CaseClosed1"), status.Int());

   717 			mgr.Close();

   718 			}

   719 		HAL::Set(HAL::EDisplayState, 0);

   720 		break;

   721 	case TRawEvent::ENone:

   722 		break;

   723 	default:

   724 		break;

   725 		}                                       

   726 	Request();

   727 	}

   728 

   729 LOCAL_C void RenderPassword(RConsole *aCon, TInt aPWLeft, const TDesC& aPW)

   730 // pre:		aCon points to a console being used to read a password.

   731 //			aPWLeft is the column number from which the left brace should be drawn.

   732 //			aPasswd is a valid password.

   733 // post:	the password is rendered onto the console and followed by a '#' and

   734 //			padding spaces.  Everything is enclosed in a pair of square brackets.

   735 	{

   736 	aCon->SetCursorPosAbs(TPoint(aPWLeft, 3));

   737 	aCon->Write(_L("["));

   738 	aCon->Write(aPW);

   739 	aCon->Write(_L("#"));

   740 

   741 	TInt i;

   742 	for (i = 0; i < KMaxMediaPassword - aPW.Length(); i++)

   743 		{

   744 		aCon->Write(_L(" "));

   745 		}

   746 

   747 	aCon->Write(_L("]"));

   748 	}

   749 

   750 

   751 void CNotifierSession::RunPasswordWindowL(const RMessage2 &aMsg)

   752 //

   753 // Eight unicode chars are mapped to (up to) sixteen bytes.  Remainder of array is

   754 // zeroed.  Message is completed in CNotifierSession::ServiceL().

   755 // 

   756 	{

   757 	// local copies of dialog data, 5 * (8 + 32 * 2) bytes

   758 	TBuf<0x20> line1, line2, unlockBtn, storeBtn, cancelBtn;

   759 	line1.Copy(_L("Password notifier"));

   760 	line2.Copy(_L("Enter password"));

   761 	unlockBtn.Copy(_L("Unlock"));

   762 	storeBtn.Copy(_L("Store"));

   763 	cancelBtn.Copy(_L("Cancel"));

   764 

   765 	TPckgBuf<TMediaPswdReplyNotifyInfoV1> reply;

   766 

   767 	// Format the console window.

   768 

   769 	const TInt KPasswordBarLen(1 + KMaxMediaPassword + 1 + 1);

   770 	const TInt KButtonBarLen(

   771 				1 + unlockBtn.Length() + 1

   772 		+ 1 +	1 + cancelBtn.Length() + 1

   773 		+ 1 +	1 + storeBtn.Length() + 1);

   774 

   775 	// Work out width of window.

   776 	// (Buttons are enclosed by angle brackets and separted by a space.)

   777 	// (Password is followed by '#' and delimited by square brackets.)

   778 	// If KButtonBarLen is at least as long as any other line then it will write

   779 	// to the bottom right corner and cause the console to scroll.  To counter

   780 	// this, an extra padding character is added if necessary.

   781 

   782 	TInt width;

   783 	width = Max(line1.Length(), line2.Length());

   784 	width = Max(width, KPasswordBarLen);

   785 	width = KButtonBarLen >= width ? KButtonBarLen + 1: width;

   786 

   787 	// Create the window and render its contents.

   788 

   789 	RConsole con;

   790 	con.Create();

   791 	con.Control(_L("-Visible"));

   792 	TInt r = con.Init(_L(""), TSize(width, 2 + 1 + 1 + 1 + 1));

   793 	if (KErrNone != r)

   794 		{

   795 		PanicClient(aMsg, ENotifierPanicPasswordWindow);

   796 		User::Leave(KErrGeneral);

   797 		}

   798 	con.Control(_L("+Max -Cursor -AllowResize +OnTop"));

   799 

   800 	con.SetCursorPosAbs(TPoint(0, 0));

   801 	con.Write(line1);

   802 	con.SetCursorPosAbs(TPoint(0, 1));

   803 	con.Write(line2);

   804 	const TInt KPasswordLeft((width - KPasswordBarLen) / 2);

   805 	con.SetCursorPosAbs(TPoint(KPasswordLeft, 3));

   806 	con.Write(_L("[#                ]"));

   807 	con.SetCursorPosAbs(TPoint((width - KButtonBarLen) / 2, 5));

   808 	con.Write(_L("<"));

   809 	con.Write(unlockBtn);

   810 	con.Write(_L("> <"));

   811 	con.Write(storeBtn);

   812 	con.Write(_L("> <"));

   813 	con.Write(cancelBtn);

   814 	con.Write(_L(">"));

   815 

   816 	// Allow the user to edit the password until they either press enter or escape.

   817 

   818 	TBool done(EFalse);

   819 	TBuf<KMaxMediaPassword> pw;

   820 	pw.Zero();

   821 	TMediaPswdNotifyExitMode em(EMPEMUnlock);	// avoid VC warning C4701 (used w/o init).

   822 

   823 	const TInt sendInfoLen = User::LeaveIfError(aMsg.GetDesLength(1));

   824 

   825 	if (sendInfoLen == sizeof(TMediaPswdSendNotifyInfoV1Debug))

   826 		{

   827 		// debug mode - wait for specified period and close notifier

   828 

   829 		TPckgBuf<TMediaPswdSendNotifyInfoV1Debug> sendDbg;

   830 		aMsg.ReadL(1, sendDbg);

   831 		if (sendDbg().iSleepPeriod >= 0)

   832 			User::After(sendDbg().iSleepPeriod);

   833 		else

   834 			{

   835 			TTime now;

   836 			now.HomeTime();

   837 			TInt64 seed = now.Int64();

   838 			User::After(Math::Rand(seed) % -(sendDbg().iSleepPeriod));

   839 			}

   840 

   841 		reply().iEM = sendDbg().iEM;

   842 		Mem::Copy(reply().iPW, sendDbg().iPW, KMaxMediaPassword);

   843 		}

   844 	else

   845 		{

   846 		RenderPassword(&con, KPasswordLeft, pw);

   847 		do

   848 			{

   849 			TConsoleKey key;

   850 

   851 			con.Read(key);

   852 			TInt keyCode = key.Code();

   853 

   854 			switch (keyCode)

   855 				{

   856 				case EKeyEscape:

   857 					em = EMPEMCancel;

   858 					done = ETrue;

   859 					break;

   860 

   861 				case EKeyEnter:

   862 					em = EMPEMUnlock;

   863 					done = ETrue;

   864 					break;

   865 				

   866 				case EKeySpace:

   867 					em = EMPEMUnlockAndStore;

   868 					done = ETrue;

   869 					break;

   870 				

   871 				case EKeyBackspace:

   872 					if (pw.Length() > 0)

   873 						{

   874 						pw.SetLength(pw.Length() - 1);

   875 						RenderPassword(&con, KPasswordLeft, pw);

   876 						}

   877 					break;

   878 

   879 				default:							// interpret other keys as pw contents

   880 					TChar ch(keyCode);

   881 					// unicode encoding, so number of password characters is half byte length

   882 					if (ch.IsPrint() && pw.Length() < KMaxMediaPassword / 2)

   883 						{

   884 						pw.Append(ch);

   885 						RenderPassword(&con, KPasswordLeft, pw);

   886 						}

   887 					break;

   888 				}

   889 			} while (! done);

   890 

   891 		// Fill the TMediaPswdReplyNotifyInfoV1 structure.

   892 

   893 		if (em == EMPEMUnlock || em == EMPEMUnlockAndStore)

   894 			{

   895 			const TInt byteLen = pw.Length() * 2;

   896 

   897 			// zero entire array; and then copy in valid section of TMediaPassword,

   898 			// not converting Unicode to ASCII.

   899 			TPtr8 pt8(reply().iPW, KMaxMediaPassword);	// length = 0

   900 			pt8.FillZ(KMaxMediaPassword);				// length = KMaxMediaPassword

   901 			pt8.Zero();									// length = 0

   902 														// length = byteLen

   903 			pt8.Copy(reinterpret_cast<const TUint8 *>(pw.Ptr()), byteLen);

   904 			}

   905 		

   906 		// Set exit mode to tell user how dialog handled.

   907 

   908 		reply().iEM = em;

   909 		}	// else (sendInfoLen == sizeof(TMediaPswdSendNotifyInfoV1Debug))

   910 	

   911 	con.Destroy();

   912 

   913 	aMsg.WriteL(2, reply);

   914 	}

   915 

   916 //

   917 // class MNotifierBase2

   918 //

   919 

   920 void MNotifierBase2::SetManager(MNotifierManager* aManager)

   921 	{

   922 	iManager=aManager;

   923 	}

   924 

   925 //

   926 // class CNotifierServer

   927 //

   928 

   929 _LIT(__NOTIFIER_SERVER,"TextNotifierSrvr");

   930 

   931 CNotifierServer* CNotifierServer::NewL()

   932 	{

   933 	CNotifierServer* server=new(ELeave) CNotifierServer(200);

   934 	CleanupStack::PushL(server);

   935 	server->ConstructL();

   936 	server->StartL(__NOTIFIER_NAME);

   937 	CleanupStack::Pop(); // server

   938 	return server;

   939 	}

   940 

   941 CNotifierServer::~CNotifierServer()

   942 	{

   943 	SetIsExiting();

   944 	delete iManager;

   945 	}

   946 

   947 void CNotifierServer::SetIsExiting()

   948 	{

   949 	iExiting=ETrue;

   950 	}

   951 

   952 TBool CNotifierServer::IsExiting() const

   953 	{

   954 	return iExiting;

   955 	}

   956 

   957 CNotifierServer::CNotifierServer(TInt aPriority)

   958 	: CServer2(aPriority)

   959 	{}

   960 

   961 void CNotifierServer::ConstructL()

   962 	{

   963 	iManager=CNotifierManager::NewL();

   964 	RFs fs;

   965 	User::LeaveIfError(fs.Connect());

   966 	CleanupClosePushL(fs);

   967 	iManager->RegisterL(fs);

   968 	CleanupStack::PopAndDestroy(); // fs.Close()

   969 	}

   970 

   971 CSession2* CNotifierServer::NewSessionL(const TVersion &aVersion,const RMessage2&) const

   972 	{

   973 	TVersion v(1,0,0); // !! liaise with E32

   974 	if (!User::QueryVersionSupported(v,aVersion))

   975 		User::Leave(KErrNotSupported);

   976 	return new(ELeave) CNotifierSession(*this);

   977 	}

   978 

   979 //

   980 // class CNotifierSession

   981 //

   982 

   983 CNotifierSession::CNotifierSession(const CNotifierServer& aServer)

   984 	{

   985 	iServer=&aServer;

   986 	iClientId=(TInt)this;

   987 	}

   988 

   989 CNotifierSession::~CNotifierSession()

   990 	{

   991 	const CNotifierServer* server=static_cast<const CNotifierServer*>(Server());

   992 	if (!server->IsExiting())

   993 		{

   994 		server->Manager()->HandleClientExit(iClientId);

   995 		}

   996 	}

   997 

   998 void CNotifierSession::ServiceL(const RMessage2 &aMessage)

   999 	{

  1000 	TBool completeMessage=ETrue;

  1001 	switch (aMessage.Function())

  1002 		{

  1003 	case ENotifierNotify:

  1004 		DisplayAlertL(aMessage);

  1005 		break;

  1006 	case ENotifierNotifyCancel:

  1007 		// do nothing - this server doesn't support cancelling RNotifier::Notify - the client will just have to wait

  1008 		break;

  1009 	case ENotifierInfoPrint:

  1010 		DisplayInfoMsgL(aMessage);

  1011 		break;

  1012 	case EStartNotifier:

  1013 		DoStartNotifierL(aMessage);

  1014 		break;

  1015 	case ECancelNotifier:

  1016 		iServer->Manager()->NotifierCancel(TUid::Uid(aMessage.Int0()));

  1017 		break;

  1018 	case EUpdateNotifierAndGetResponse:

  1019 	case EUpdateNotifier:

  1020 		DoUpdateNotifierL(aMessage);

  1021 		break;

  1022 	case EStartNotifierAndGetResponse:

  1023 		{

  1024 		if (aMessage.Int0()==KMediaPasswordNotifyUid)

  1025 			{

  1026 			RunPasswordWindowL(aMessage);

  1027 			}

  1028 		else

  1029 			{

  1030 			TBool cleanupComplete=ETrue;

  1031 			StartNotifierAndGetResponseL(aMessage,cleanupComplete);

  1032 			 // if the plug-in starts successfully, it has

  1033 			 // responsibility for completing the message (either

  1034 			 // synchronously or asynchronously)

  1035 			completeMessage=EFalse;

  1036 			}

  1037 		}

  1038 		break;

  1039 	default:

  1040 		aMessage.Complete(KErrNotSupported);

  1041 		break;

  1042 		}

  1043 	if (completeMessage && !aMessage.IsNull())

  1044 		{

  1045 		aMessage.Complete(KErrNone);

  1046 		}

  1047 	}

  1048 

  1049 void CNotifierSession::DisplayAlertL(const RMessage2& aMessage)

  1050 	{

  1051 	const TInt lengthOfCombinedBuffer=User::LeaveIfError(aMessage.GetDesLength(1));

  1052 	const TInt lengthOfLine1=(STATIC_CAST(TUint,aMessage.Int2())>>16);

  1053 	const TInt lengthOfLine2=(aMessage.Int2()&KMaxTUint16);

  1054 	const TInt lengthOfBut1=(STATIC_CAST(TUint,aMessage.Int3())>>16);

  1055 	const TInt lengthOfBut2=(aMessage.Int3()&KMaxTUint16);

  1056 	if (lengthOfCombinedBuffer!=lengthOfLine1+lengthOfLine2+lengthOfBut1+lengthOfBut2)

  1057 		{

  1058 		PanicClient(aMessage,ENotifierPanicInconsistentDescriptorLengths);

  1059 		return;

  1060 		}

  1061 	HBufC* const combinedBuffer=HBufC::NewLC(lengthOfCombinedBuffer);

  1062 	{TPtr combinedBuffer_asWritable(combinedBuffer->Des());

  1063 	aMessage.ReadL(1,combinedBuffer_asWritable);}

  1064 	const TPtrC line1(combinedBuffer->Left(lengthOfLine1));

  1065 	const TPtrC line2(combinedBuffer->Mid(lengthOfLine1,lengthOfLine2));

  1066 	const TPtrC but1(combinedBuffer->Mid(lengthOfLine1+lengthOfLine2,lengthOfBut1));

  1067 	const TPtrC but2(combinedBuffer->Mid(lengthOfLine1+lengthOfLine2+lengthOfBut1,lengthOfBut2));

  1068 	TInt buttons, len, offset;

  1069 	if (lengthOfBut2==0)

  1070 		{

  1071 		buttons=1;

  1072 		len=lengthOfBut1+2;

  1073 		}

  1074 	else

  1075 		{

  1076 		buttons=2;

  1077 		len=lengthOfBut1+lengthOfBut2+5;

  1078 		}

  1079 	if (lengthOfLine1>len)

  1080 		len=lengthOfLine1;

  1081 	if (lengthOfLine2>len)

  1082 		len=lengthOfLine2;

  1083 	RConsole con;

  1084 	con.Create();

  1085 	TSize scsz;

  1086 	con.ScreenSize(scsz);

  1087 	con.Control(_L("-Visible"));

  1088 	TInt ww=Min(len,scsz.iWidth-4);

  1089 	TInt wh=3;

  1090 	if ((lengthOfBut1+lengthOfBut2+5)>ww)

  1091 		wh++;

  1092 	if (lengthOfLine1>ww)

  1093 		wh++;

  1094 	if (lengthOfLine2>ww)

  1095 		wh++;

  1096 	con.Init(_L(""),TSize(ww,wh));

  1097 	con.Control(_L("+Max -Cursor -Allowresize +Ontop +Wrap"));

  1098 	con.Write(line1);

  1099 	con.SetCursorPosAbs(TPoint(0,1));

  1100 	con.Write(line2);

  1101 	if (buttons==2)

  1102 		offset=(len-lengthOfBut1-lengthOfBut2-5)/2;

  1103 	else

  1104 		offset=(len-lengthOfBut1-2)/2;

  1105 	con.SetCursorPosAbs(TPoint(offset,2));

  1106 	con.Write(_L("<"));

  1107 	con.Write(but1);

  1108 	con.Write(_L(">"));

  1109 	if(buttons==2)

  1110 		{

  1111 		con.Write(_L(" <"));

  1112 		con.Write(but2);

  1113 		con.Write(_L(">"));

  1114 		}

  1115 	

  1116 	TConsoleKey key;

  1117 	TInt keycode;

  1118 	do

  1119 		{

  1120 		con.Read(key);

  1121 		keycode=key.Code();

  1122 		}

  1123 	while((keycode!=EKeyEscape&&keycode!=EKeyEnter&&buttons==2)||(keycode!=EKeyEnter&&buttons==1));

  1124 	if(keycode==EKeyEscape)

  1125 		keycode=0;

  1126 	else

  1127 		keycode=1;

  1128 	con.Destroy();

  1129 	aMessage.WriteL(0,TPckgC<TInt>(keycode));

  1130 	CleanupStack::PopAndDestroy(combinedBuffer);

  1131 	}

  1132 

  1133 TInt CNotifierSession::InfoPrintThread(TAny* aMessage)

  1134 	{

  1135 	TBuf<0x50> des; // 0x50 max size of message