void CGlobalSettings::SetScreenNoL(TInt aScreenNo) { RWsSession session; ASSERT_EQUALS(session.Connect(), KErrNone); TInt maxScreens=session.NumberOfScreens(); if (maxScreens>aScreenNo) { INFO_PRINTF2(_L("New screen number for all output selected: %i"),aScreenNo); { CWsScreenDevice screen(session); screen.Construct(aScreenNo); screen.SetCurrentRotations(0,CFbsBitGc::TGraphicsOrientation(0)); screen.SetScreenMode(0); screen.SetAppScreenMode(0); } settings_instance.iScreen=aScreenNo; session.Flush(); session.Close(); } else { INFO_PRINTF1(_L("**************************")); INFO_PRINTF1(_L("")); INFO_PRINTF3(_L("Can't set screen output to %i. Only got %i screens"),aScreenNo,maxScreens); INFO_PRINTF2(_L("Screen number for all output remains at: %i"),settings_instance.iScreen); INFO_PRINTF1(_L("")); INFO_PRINTF1(_L("**************************")); session.Flush(); session.Close(); User::Leave(KErrTEFUnitFail); } }
void CMultipleSurfacesAppUi::BringToFront() { RWindow window = iAppView->Window(); RWsSession wsSession = iAppView->ControlEnv()->WsSession(); wsSession.SetWindowGroupOrdinalPosition(window.WindowGroupId(), 0); wsSession.Flush(); wsSession.Finish(); }
/** Draws a stretched bitmap with or without a mask. @param aUseMask set to ETrue to use a alpha mask. Normally used for 16MU display modes that do not store the alpha. @param aSrcMode is the source display mode @param aDstMode is the destination display mode @param aSession is the windows server session @param aWindow is a reference to the window @param aGc is the graphics context of the window @param aNumIterations is the number of iterations to run the test */ void CAlphaBlendTest::DoDrawBitmapL(TBool aUseMask, TDisplayMode aSrcMode, TDisplayMode aDstMode, RWsSession& aSession, RWindow& aWindow, CWindowGc* aGc, TInt aNumIterations) { const TSize bitmapSize = aWindow.Size(); // Construct target bitmap. CFbsBitmap* bitmapTarget = CreateSoftwareBitmapLC(bitmapSize, aDstMode); CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL(bitmapTarget); CleanupStack::PushL(bitmapDevice); // Construct GC. CFbsBitGc* bitmapGc = NULL; User::LeaveIfError(bitmapDevice->CreateContext(bitmapGc)); CleanupStack::PushL(bitmapGc); // Construct source bitmap. TSize smallerSize(bitmapSize.iWidth/2, bitmapSize.iHeight/2); CFbsBitmap* source = CreateSoftwareBitmapLC(smallerSize, aSrcMode); VerticalGradientAlphaL(source, TRgb(0x00000000), TRgb(0xffffffff)); CFbsBitmap* sourceAlpha = CreateSoftwareBitmapLC(smallerSize, EGray256); // match size to src VerticalGradientAlphaL(sourceAlpha, TRgb(0x01010101), TRgb(0xfefefefe)); bitmapGc->SetBrushStyle(CGraphicsContext::ENullBrush); bitmapGc->SetBrushColor(TRANSPARENT_BLACK); bitmapGc->Clear(); bitmapGc->SetDrawMode(CGraphicsContext::EDrawModePEN); aGc->Activate(aWindow); TPoint point(0,0); bitmapGc->BitBlt(point, bitmapTarget); aGc->Deactivate(); aSession.Flush(); TBuf <20> testName; if (!aUseMask) { testName=_L("DrawBitmap"); iProfiler->InitResults(); for(int i=0; i<aNumIterations; i++) { bitmapGc->DrawBitmap(TRect(point, bitmapSize), source); iProfiler->MarkResultSetL(); } } else { testName=_L("DrawBitmapMasked"); iProfiler->InitResults(); for(int i=0; i<aNumIterations; i++) { bitmapGc->DrawBitmapMasked(TRect(point, bitmapSize), source,TRect(point, smallerSize), sourceAlpha, EFalse); iProfiler->MarkResultSetL(); } } INFO_PRINTF4(_L("%S(Stretched) with src = %S, dst = %S"), &testName, &ColorModeName(aSrcMode), &ColorModeName(aDstMode)); iProfiler->ResultsAnalysis(testName, 0, aSrcMode, aDstMode, aNumIterations); // copy up to screen for sanity check BitBlt(aSession, aWindow, aGc, *bitmapTarget); CleanupStack::PopAndDestroy(5, bitmapTarget); }
/** BitBlts a bitmap to the windows GC. @param aSession is the windows server session @param aWindow is a reference to the window @param aGc is the graphics context of the window @param aImage is the bitmap to bitblt */ void CAlphaBlendTest::BitBlt(RWsSession& aSession, RWindow& aWindow, CWindowGc* aGc, CFbsBitmap& aImage) { aWindow.Invalidate(); aWindow.BeginRedraw(); aGc->Activate(aWindow); aGc->BitBlt(TPoint(0,0), &aImage); aGc->Deactivate(); aWindow.EndRedraw(); aSession.Flush(); }
// Failures are written to WSERV.log void CWsGraphicShareBase::Test(TInt aCondition) { if(!aCondition) { TLogMessageText buf; _LIT(Fail,"AUTO Failed in WsGraphics Test : DrawSharedGraphic"); buf.Format(Fail); iWs.LogMessage(buf); iWs.Flush(); RProcess().Terminate(KErrTestExeFailure); // terminate this process immediately. Expect TWsGraph test step (TAutoServer.exe) to capture this } }
/** Alpha blends two bitmaps together @param aDisplayMode1 is the source display mode @param aDisplayMode2 is the destination display mode @param aSession is the windows server session @param aWindow is a reference to the window @param aGc is the graphics context of the window @param aNumIterations is the number of iterations to run the test */ void CAlphaBlendTest::DoAlphaBlendBitmapsBitmapTestL(TDisplayMode aSrcMode, TDisplayMode aDstMode, RWsSession& aSession, RWindow& aWindow, CWindowGc* aGc, TInt aNumIterations) { const TSize bitmapSize = aWindow.Size(); CFbsBitmap* bitmapTarget = CreateSoftwareBitmapLC(bitmapSize, aDstMode); CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL(bitmapTarget); CleanupStack::PushL(bitmapDevice); CFbsBitGc* bitmapGc=NULL; User::LeaveIfError(bitmapDevice->CreateContext(bitmapGc)); CleanupStack::PushL(bitmapGc); CFbsBitmap* sourceUnder = CreateSoftwareBitmapLC(bitmapSize, aDstMode); CFbsBitmap* sourceOver = CreateSoftwareBitmapLC(bitmapSize, aSrcMode); CFbsBitmap* sourceAlpha = CreateSoftwareBitmapLC(bitmapSize, EGray256); VerticalGradientAlphaL(sourceAlpha, TRgb(0x01010101), TRgb(0xfefefefe)); VerticalGradientAlphaL(sourceUnder, TRgb(0xff000000), TRgb(0x00ffffff)); VerticalGradientAlphaL(sourceOver, TRgb(0x00ffffff), TRgb(0xff000000)); RDebug::Printf("DABBBT 2"); TPoint point(0,0); TRect rect(bitmapSize); bitmapGc->SetBrushStyle(CGraphicsContext::ENullBrush); bitmapGc->SetBrushColor(TRANSPARENT_BLACK); bitmapGc->SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha); bitmapGc->Clear(); bitmapGc->SetDrawMode(CGraphicsContext::EDrawModePEN); bitmapGc->AlphaBlendBitmaps(point, sourceUnder, sourceOver, rect, point, sourceAlpha, point); aGc->Activate(aWindow); aGc->BitBlt(point, bitmapTarget); aGc->Deactivate(); aSession.Flush(); iProfiler->InitResults(); // blend sourceUnder with sourceOver using alpha mask for(TInt i=0; i<aNumIterations; i++) { bitmapGc->SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha); bitmapGc->Clear(); bitmapGc->SetDrawMode(CGraphicsContext::EDrawModePEN); bitmapGc->AlphaBlendBitmaps(point, sourceUnder, sourceOver, rect, point, sourceAlpha, point); iProfiler->MarkResultSetL(); } iProfiler->ResultsAnalysis(_L("DoAlphaBlendBitmapsBitmapTestL"), 0, aSrcMode, aDstMode, aNumIterations); // copy up to screen for sanity check BitBlt(aSession, aWindow, aGc, *bitmapTarget); CleanupStack::PopAndDestroy(6, bitmapTarget); // sourceAlpha, sourceOver, sourceUnder, bitmapGc, bitmapDevice, bitmapTarget }
/** Clears the window to a colour @param aSession is the windows server session @param aWindow is a reference to the window @param aGc is the graphics context of the window @param aColor is the colour to clear the window with */ void CAlphaBlendTest::ClearWindow(RWsSession& aSession, RWindow& aWindow, CWindowGc* aGc, TRgb aColor) { // clear so we can see bitmap version has completed aWindow.Invalidate(); aWindow.BeginRedraw(); aGc->Activate(aWindow); aGc->SetBrushColor(aColor); aGc->Clear(); aGc->Deactivate(); aWindow.EndRedraw(); aSession.Flush(); }
TInt LoadsOfText(TInt aOwningGroup) { RWsSession ws; ws.Connect(); CWsScreenDevice *device=new(ELeave) CWsScreenDevice(ws); device->Construct(); RWindowGroup group(ws); group.Construct(ENullWsHandle); group.SetOwningWindowGroup(aOwningGroup); TSize scrSize(device->SizeInPixels()); // RWindow window(ws); window.Construct(group,ENullWsHandle); window.SetExtent(TPoint(), scrSize); window.Activate(); // CWindowGc *gc; device->CreateContext(gc); window.BeginRedraw(); gc->Activate(window); gc->Clear(); window.EndRedraw(); TFontSpec fspec(KTestFontTypefaceName,200); CFbsFont *font; User::LeaveIfError(device->GetNearestFontToDesignHeightInTwips((CFont *&)font, fspec)); gc->UseFont(font); TBuf<100> loadsatext(_L("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890zyxwvutsrqponmlkjihgfedcba")); TInt ascent=font->AscentInPixels(); TInt fheight=font->HeightInPixels(); for(TInt nTimes=0;nTimes<10;nTimes++) { TPoint pos; // for(pos.iY=ascent;pos.iY<scrSize.iHeight;pos.iY+=font->HeightInPixels()) // gc->DrawText(loadsatext,pos); for(pos.iY=0;pos.iY<scrSize.iHeight;pos.iY+=fheight) gc->DrawText(loadsatext,TRect(pos,TPoint(scrSize.iWidth,pos.iY+fheight)),ascent); gc->Clear(); } gc->Deactivate(); // ws.Flush(); delete gc; device->ReleaseFont(font); window.Close(); group.Close(); delete device; ws.Close(); return(KErrNone); }
/** * Runs the test in a second thread. * * @param aFunctionIndex The drawing function command to be executed. All commands are defined in TestFunctionIndex. */ TInt CTW32CmdBuf::DoTestCmdBufFunctionL(TTestFunctionIndex aFunctionIndex) { RWsSession session; User::LeaveIfError(session.Connect()); CleanupClosePushL(session); CWsScreenDevice *device = new(ELeave) CWsScreenDevice(session); CleanupStack::PushL(device); User::LeaveIfError(device->Construct(CTestBase::iScreenNo)); CWindowGc* gc; User::LeaveIfError(device->CreateContext(gc)); CleanupStack::PushL(gc); RWindowGroup group(session); User::LeaveIfError(group.Construct(1, EFalse)); CleanupClosePushL(group); RWindow window(session); User::LeaveIfError(window.Construct(group, 2)); CleanupClosePushL(window); window.SetExtent(TPoint(0,0), TSize(200, 200)); User::LeaveIfError(window.SetRequiredDisplayMode(EColor64K)); window.Activate(); gc->Activate(window); session.SetAutoFlush(EFalse); window.Invalidate(); window.BeginRedraw(); for(TInt i=KMinTestIterations; i<KMaxTestIterations; ++i) { for(TInt j=0; j<i; ++j) { gc->Clear(); } CFbsBitmap* bitmap = new(ELeave) CFbsBitmap; CleanupStack::PushL(bitmap); User::LeaveIfError(bitmap->Create(TSize(100, 100), EColor64K)); CFbsBitmap* mask = new(ELeave) CFbsBitmap; CleanupStack::PushL(mask); User::LeaveIfError(mask->Create(TSize(100, 100), EColor64K)); KTestFunctions[aFunctionIndex](gc, bitmap, mask); CleanupStack::PopAndDestroy(2); session.Flush(); } window.EndRedraw(); gc->Deactivate(); CleanupStack::PopAndDestroy(5); return KErrNone; }
void CWsGraphicShareBase::DoTestDrawGraphicCompareL(TPtrC aShare) { // UID of the shared graphic TUid uid1 = {0x12000021}; TWsGraphicId twsGraphicId1(uid1); _LIT8(KTestData,"HelloWorld"); CFbsBitmap bitmap1; CFbsBitmap mask1; TSize screenSize = iScreen->SizeInPixels(); User::LeaveIfError(bitmap1.Load(MY_TEST_BITMAP,0)); mask1.Create(bitmap1.SizeInPixels(),iScreen->DisplayMode()); CWsGraphicBitmap* bTest = CWsGraphicBitmap::NewL(&bitmap1,&mask1); // divide the screen into two equal rectangles TRect position1(0,0,screenSize.iWidth/2,screenSize.iHeight); TRect position2(screenSize.iWidth/2,0,screenSize.iWidth,screenSize.iHeight); // draw the new graphic and attempt to draw the shared graphic iGc->Activate(*iWin); iWin->Invalidate(); iWin->BeginRedraw(); iGc->Clear(position1); iGc->Clear(position2); iGc->DrawWsGraphic(bTest->Id(),position1,KTestData); iGc->DrawWsGraphic(twsGraphicId1.Uid(),position2,KTestData); iGc->Deactivate(); iWin->EndRedraw(); iWs.Flush(); iWs.Finish(); // compare the graphic in both positions if (aShare==_L("false")) Test(!iScreen->RectCompare(position1,position2)); else Test(iScreen->RectCompare(position1,position2)); delete bTest; }
void CWsGraphicShareBase::ConstructL() { User::LeaveIfError(iWs.Connect()); iScreen=new(ELeave) CWsScreenDevice(iWs); User::LeaveIfError(iScreen->Construct(iScreenNumber)); iGc=new(ELeave) CWindowGc(iScreen); User::LeaveIfError(iGc->Construct()); iGroupWin=new(ELeave) RWindowGroup(iWs); iGroupWin->Construct(1); iWin=new(ELeave) RWindow(iWs); iWin->Construct(*iGroupWin,ENullWsHandle); iWin->SetRequiredDisplayMode(EColor256); iWin->SetExtent(TPoint(0,0),iScreen->SizeInPixels()); iWin->Activate(); iWin->BeginRedraw(); iWin->EndRedraw(); iWs.Flush(); }
void CCustomCmdTestDeviceSecurityCheck::SimulatePasswordEntry() { RWsSession wsSession; TInt err = wsSession.Connect(); TEST(KErrNone == err); const TInt okButtonPos1 = 60; //the position of ok button const TInt okButtonPos2 = 600; //the position of ok button //Simulate the key press ,(comma) in to pin notifier dialogue TRawEvent eventDown; TRawEvent eventUp; eventDown.Set(TRawEvent::EKeyDown, EStdKeyComma); UserSvr::AddEvent(eventDown); eventUp.Set(TRawEvent::EKeyUp, EStdKeyComma); UserSvr::AddEvent(eventUp); User::After(100000); //Enter wrong pwd if iWrongPwd is ETrue if(iWrongPwd) { eventDown.Set(TRawEvent::EKeyDown, EStdKeyComma); UserSvr::AddEvent(eventDown); eventUp.Set(TRawEvent::EKeyUp, EStdKeyComma); UserSvr::AddEvent(eventUp); User::After(100000); //Reset it to false as wrong password should be entered only once iWrongPwd = EFalse; } eventDown.Set(TRawEvent::EButton1Down, okButtonPos1,okButtonPos2); UserSvr::AddEvent(eventDown); eventUp.Set(TRawEvent::EButton1Up, okButtonPos1,okButtonPos2); UserSvr::AddEvent(eventUp); User::After(100000); wsSession.Flush(); wsSession.Close(); }
void CTScreenDevice::ConstructL() { //The following is just another test... it doesn't leave any resources for use by the test class AFAICT... RWsSession aSession; CWsScreenDevice *device1; CWsScreenDevice *device2; CWsScreenDevice *device3; aSession.Connect(); device1=new(ELeave) CWsScreenDevice(aSession); device1->Construct(iTest->iScreenNumber); delete device1; device1=new(ELeave) CWsScreenDevice(aSession); device1->Construct(iTest->iScreenNumber); device2=new(ELeave) CWsScreenDevice(aSession); device2->Construct(iTest->iScreenNumber); device3=new(ELeave) CWsScreenDevice(aSession); device3->Construct(iTest->iScreenNumber); delete device3; CFbsFont *font; User::LeaveIfError(device1->GetNearestFontToDesignHeightInTwips((CFont *&)font,TFontSpec())); RWindowGroup group(aSession); group.Construct(777); group.SetOwningWindowGroup(TheClient->iGroup->GroupWin()->Identifier()); RWindow win(aSession); win.Construct(group,77); CWindowGc *gc=new(ELeave) CWindowGc(device1); gc->Construct(); gc->Activate(win); gc->UseFont(font); device1->ReleaseFont(font); aSession.Flush(); delete gc; win.Close(); group.Close(); delete device1; delete device2; aSession.Close(); }
void MainL() { RWsSession ws; ws.Connect(); CWsScreenDevice* scr = new(ELeave) CWsScreenDevice(ws); scr->Construct(); CWindowGc* gc = new(ELeave) CWindowGc(scr); gc->Construct(); RWindowGroup grp(ws); grp.Construct(0xc0decafe, ETrue); RWindow win(ws); win.Construct(grp, 0xbeefcafe); win.SetExtent(TPoint(20,160), TSize(320,240)); win.Activate(); win.Invalidate(); win.BeginRedraw(); gc->Activate(win); gc->SetPenStyle(CGraphicsContext::ENullPen); gc->SetBrushStyle(CGraphicsContext::ESolidBrush); TBool color = EFalse; if (Profiler::Start() == KErrNotFound) { _LIT(KProfiler,"profiler"); _LIT(KStart,"start -noui -drive=S"); RProcess p; if (p.Create(KProfiler,KStart) == KErrNone) { p.Resume(); p.Close(); } } for (TInt col=0; col<KCol; ++col) { color = !color; for (TInt row=0; row<KRow; ++row) { TRect rect; rect.iTl.iX = col * KSize.iWidth; rect.iTl.iY = row * KSize.iHeight; rect.SetSize(KSize); color = !color; gc->SetBrushColor(color? KRgbBlue : KRgbBlack); gc->DrawRect(rect); } } gc->Deactivate(); win.EndRedraw(); ws.Flush(); User::After(3000000); win.Close(); grp.Close(); delete gc; delete scr; ws.Close(); Profiler::Stop(); Profiler::Close(); Profiler::Unload(); }
void CAlphaBlendTest::DoDrawBlendedTestL(TBlendTestFunc aTestFunc, TInt aAlpha, TDisplayMode aDisplayMode, RWsSession& aSession, TInt aNumIterations) { SetScreenModeL(aDisplayMode); const TSize devSize = iScreenDevice->SizeInPixels(); // For fair back to back tests of rotated mode we need graphics clipped to a square test area. // Although if we aren't going to be comparing rotated results against each other it might be better // to allow the tests to use the full available area. TSize testSize; testSize.iWidth=Min(devSize.iWidth,devSize.iHeight); testSize.iHeight=testSize.iWidth; TFontSpec testFontSpec; if (aTestFunc==EBlendTestDrawTextAntiAliased || aTestFunc==EBlendTestDrawTextIType) { testFontSpec.iTypeface.iName=KFontTypeface; if (aTestFunc==EBlendTestDrawTextAntiAliased) { testFontSpec.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap); } else { testFontSpec.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap); testFontSpec.iFontStyle.SetEffects(FontEffect::EDropShadow, ETrue); testFontSpec.iFontStyle.SetEffects(FontEffect::EOutline, ETrue); } } testFontSpec.iHeight=12; // Set bold because sets more pixels, so tests blending code more testFontSpec.iFontStyle.SetStrokeWeight(EStrokeWeightBold); _LIT(KTestBlendTextString,"BLENDTESTWITHBIGSOLIDCHARACTERS0123456789HAVEWERUNOUTOFSCREENYET?OKAFEWMORECHARACTERSJUSTTOMAKESURE"); const TInt maxTextLen=KTestBlendTextString().Length(); // TBool orientations[4]; iGc->OrientationsAvailable(orientations); // Use for loop to test across multiple rotations, however the implementation hardly varies at the moment // so very little point in testing the differences, if in future an optimised route is added for normal // rotation this test would be worth switching back to looping upto EGraphicsOrientationRotated270. // // const TInt KMaxOrientation=CFbsBitGc::EGraphicsOrientationRotated270; const TInt KMaxOrientation=CFbsBitGc::EGraphicsOrientationNormal; for (TInt orient = CFbsBitGc::EGraphicsOrientationNormal; orient <= KMaxOrientation; orient++) { if (orientations[orient]) { iGc->SetOrientation((CFbsBitGc::TGraphicsOrientation)orient); User::After(100000); // Let rotate sort itself out iGc->Reset(); iGc->SetClippingRect(TRect(testSize)); iGc->SetPenStyle(CGraphicsContext::ESolidPen); iGc->SetBrushColor(TRgb(0x80,0x80,0xFF)); iGc->Clear(); iGc->SetBrushColor(TRgb(10,128,240,aAlpha)); iGc->SetPenColor(TRgb(240,128,10,aAlpha)); iGc->SetDrawMode(CGraphicsContext::EDrawModePEN); aSession.Flush(); CFbsFont* font=NULL; TInt fontHeight=0; TInt testParam=0; TSize orientatedTestSize=testSize; TBuf <32> testName; TGlyphBitmapType checkGlyphBitmapType=EDefaultGlyphBitmap; TGlyphBitmapType actualGlyphBitmapType=EDefaultGlyphBitmap; TPtrC textPtr; switch(aTestFunc) { case EBlendTestVerticalLine: _LIT(KDrawRectVerticalLine,"DrawRectVertLine"); testName=KDrawRectVerticalLine; break; case EBlendTestDrawRect: _LIT(KDrawRectAlpha,"DrawRectAlpha"); testName=KDrawRectAlpha; iGc->SetBrushStyle(CGraphicsContext::ESolidBrush); iGc->SetPenStyle(CGraphicsContext::ENullPen); break; case EBlendTestDrawTextIType: _LIT(KDrawTextIType,"DrawTextIT"); testName=KDrawTextIType; testParam=testSize.iHeight; checkGlyphBitmapType=EFourColourBlendGlyphBitmap; goto drawTextTest; case EBlendTestDrawTextAntiAliased: _LIT(KDrawTextAA,"DrawTextAA"); testName=KDrawTextAA; testParam=testSize.iHeight; checkGlyphBitmapType=EAntiAliasedGlyphBitmap; goto drawTextTest; case EBlendTestDrawVerticalText: _LIT(KDrawTextVert,"DrawTextVert"); orientatedTestSize.SetSize(orientatedTestSize.iHeight,orientatedTestSize.iWidth); testName=KDrawTextVert; testParam=testSize.iWidth; checkGlyphBitmapType=EMonochromeGlyphBitmap; goto drawTextTest; case EBlendTestDrawText: _LIT(KDrawText,"DrawText"); testParam=testSize.iHeight; testName=KDrawText; checkGlyphBitmapType=EMonochromeGlyphBitmap; drawTextTest: User::LeaveIfError(iScreenDevice->BitmapDevice().GetNearestFontInPixels((CFont* &)font,testFontSpec)); fontHeight=font->HeightInPixels(); iGc->UseFont(font); actualGlyphBitmapType=font->FontSpecInTwips().iFontStyle.BitmapType(); TInt displayLen=Min(font->TextCount(KTestBlendTextString,orientatedTestSize.iWidth)+1,maxTextLen); textPtr.Set(KTestBlendTextString().Left(displayLen)); iScreenDevice->BitmapDevice().ReleaseFont(font); break; } if (checkGlyphBitmapType!=EDefaultGlyphBitmap) { if (actualGlyphBitmapType!=checkGlyphBitmapType) { INFO_PRINTF3(_L("Failed to load correct glyph type font, wanted %d, got %d"),checkGlyphBitmapType, actualGlyphBitmapType); break; } } _LIT(KAppendAlphaTxt,"[A=0x%02x]"); testName.AppendFormat(KAppendAlphaTxt,aAlpha); iProfiler->InitResults(); for(TInt iter=0; iter<aNumIterations; iter++) { switch(aTestFunc) { case EBlendTestVerticalLine: for(TInt xpos=0; xpos<testSize.iWidth; xpos++) iGc->DrawLine(TPoint(xpos,0),TPoint(xpos,testSize.iHeight)); break; case EBlendTestDrawRect: iGc->DrawRect(TRect(testSize)); break; case EBlendTestDrawText: case EBlendTestDrawVerticalText: case EBlendTestDrawTextAntiAliased: case EBlendTestDrawTextIType: { for(TInt pos=0;pos<testParam;pos+=fontHeight) { if (aTestFunc==EBlendTestDrawVerticalText) iGc->DrawTextVertical(textPtr,TPoint(pos,0),EFalse); else iGc->DrawText(textPtr,TPoint(0,pos)); } break; } } iProfiler->MarkResultSetL(); } INFO_PRINTF3(_L("%S %S"), &testName, &ColorModeName(aDisplayMode)); iProfiler->ResultsAnalysis(testName, orient, aDisplayMode, aDisplayMode, aNumIterations); } } iGc->SetOrientation(CFbsBitGc::EGraphicsOrientationNormal); }
// // LtkUtils::W32CrackL // loads the autometric logging engine, dlogev.dll, into wserv // enabling Autometric to monitor events from within wserv - key/pointer events, text drawn to screen etc // EXPORT_C void LtkUtils::W32CrackL() { #ifndef FSHELL_WSERV_SUPPORT User::Leave(KErrNotSupported); #else // Check if P&S says it's already enabled, if so no need to do anything if (W32CrackIsEnabled()) return; _LIT(KWsIniFile, "z:\\system\\data\\wsini.ini"); _LIT(KCWsIniFile,"c:\\system\\data\\wsini.ini"); _LIT(KLogEv, "LOG EV\r\n"); // Open z file RFs fs; User::LeaveIfError(fs.Connect()); CleanupClosePushL(fs); RFile file; User::LeaveIfError(file.Open(fs, KWsIniFile, EFileRead)); CleanupClosePushL(file); TInt size; User::LeaveIfError(file.Size(size)); RBuf8 buf; buf.CreateL(size + KLogEv().Size()); CleanupClosePushL(buf); User::LeaveIfError(file.Read(buf)); TPtrC16 wptr((TUint16*)buf.Ptr(), buf.Size()/2); buf.Insert(2, TPtrC8((TUint8*)KLogEv().Ptr(), KLogEv().Size())); // +2 to get past the BOM TInt err = KErrNone; err = fs.MkDirAll(KCWsIniFile); // mkdir c:\system\data\ in case it is not exist if((err != KErrNone) && (err != KErrAlreadyExists)) { User::Leave(err); } User::LeaveIfError(file.Replace(fs, KCWsIniFile, EFileWrite)); User::LeaveIfError(file.Write(buf)); CleanupStack::PopAndDestroy(2, &file); // file, buf err = RMemoryAccess::LoadDriver(); if ((err != KErrNone) && (err != KErrAlreadyExists)) { User::Leave(err); } RMemoryAccess memAccess; User::LeaveIfError(memAccess.Open()); CleanupClosePushL(memAccess); RWsSession ws; User::LeaveIfError(ws.Connect(fs)); CleanupClosePushL(ws); #ifdef __WINS__ // On wins the binary isn't renamed _LIT(KWservMatch, "wserv*.exe*"); #else _LIT(KWservMatch, "EwSrv.exe*"); #endif TFindProcess find(KWservMatch); TFullName name; User::LeaveIfError(find.Next(name)); RProcess wservProc; User::LeaveIfError(wservProc.Open(find)); if (wservProc.ExitType() != EExitPending) { // in case wserv kicks off the preferred implementation in a new process then kills itself // (is one retry enough or should we be looping here?) wservProc.Close(); User::LeaveIfError(find.Next(name)); User::LeaveIfError(wservProc.Open(find)); } CleanupClosePushL(wservProc); name = wservProc.FileName(); name[0] = 'c'; TPtrC8 narrowName = name.Collapse(); User::LeaveIfError(memAccess.InPlaceSetProcessFileName(wservProc, narrowName)); // Now tell wserv to reload its wsini.ini and enable logging ws.LogCommand(RWsSession::ELoggingEnable); ws.Flush(); // cleanup CleanupStack::PopAndDestroy(4, &fs); #endif // FSHELL_WSERV_SUPPORT }