diff -r 48060abbbeaf -r b3cee849fa46 memspyui/ui/avkon/src/MemSpyAppUi.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/memspyui/ui/avkon/src/MemSpyAppUi.cpp Tue Aug 31 15:15:20 2010 +0300 @@ -0,0 +1,763 @@ +/* +* Copyright (c) 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 "MemSpyAppUi.h" + +// System includes +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// Engine includes +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +//cigasto +#include + +// User includes +#include "MemSpyContainer.h" +#include "MemSpyDocument.h" +#include "MemSpySettings.h" +#include "MemSpyDeviceWideOperationDialog.h" +#include "MemSpyViewRAMInfo.h" // for aknicon config check +#include "MemSpyExportBitmapsToMemoryCardDialog.h" +#include "MemSpy.hrh" +#include "viewcli.h" + +// Constants +const TInt KMemSpyDefaultAutoCaptureTimerPeriod = 60; +const TUint32 KMemSpyEikSrvSID = 0x10003a4a; + +/* +CMemSpyAppUi::CMemSpyAppUi( CMemSpyEngine& aEngine ) +: iEngine( aEngine ), iAutoCaptureTimerPeriod( KMemSpyDefaultAutoCaptureTimerPeriod ), iAutoCaptureOperationType( CMemSpyDeviceWideOperations::EPerEntityHeapInfo ) + { + iEngine.SetObserver( this ); + } +*/ +CMemSpyAppUi::CMemSpyAppUi( RMemSpySession &aSession ) +: iMemSpySession( aSession ), iAutoCaptureTimerPeriod( KMemSpyDefaultAutoCaptureTimerPeriod ), iAutoCaptureOperationType( CMemSpyDeviceWideOperations::EPerEntityHeapInfo ) + { + //iEngine.SetObserver( this ); + } + +CMemSpyAppUi::~CMemSpyAppUi() + { + RDebug::Printf( "[MemSpy] MemSpy is now closing." ); + // + delete iAutoCaptureTimer; + // + if (iAppContainer) + { + RemoveFromStack( iAppContainer ); + delete iAppContainer; + } + // + //iEngine.SetObserver( NULL ); + SetViewServerTimeOutStatus( ETrue ); + } + + +void CMemSpyAppUi::ConstructL() + { + BaseConstructL( EAknEnableSkin ); + // + //iAppContainer = new (ELeave) CMemSpyContainer( iEngine, *this ); + iAppContainer = new (ELeave) CMemSpyContainer( iMemSpySession, *this ); + iAppContainer->SetMopParent(this); + iAppContainer->ConstructL( ClientRect() ); + iAppContainer->SetObserver( this ); + iAppContainer->SetFocus( ETrue ); + AddToStackL( iAppContainer ); + // + iAutoCaptureTimer = CPeriodic::NewL( CActive::EPriorityIdle ); + // + iEikonEnv->SetSystem( ETrue ); + // + SetViewServerTimeOutStatus( EFalse ); + } + + +CMemSpyDocument& CMemSpyAppUi::MemSpyDocument() + { + CMemSpyDocument* doc = static_cast< CMemSpyDocument* >( Document() ); + return *doc; + } + + +const CMemSpyDocument& CMemSpyAppUi::MemSpyDocument() const + { + const CMemSpyDocument* doc = static_cast< const CMemSpyDocument* >( Document() ); + return *doc; + } + + +void CMemSpyAppUi::HandleStatusPaneSizeChange() + { + iAppContainer->SetRect( ClientRect() ); + } + + +void CMemSpyAppUi::HandleControlEventL( CCoeControl* aControl, TCoeEvent /*aEventType*/ ) + { + if ( aControl == iAppContainer ) + { + UpdateCBAL(); + } + } + + +void CMemSpyAppUi::DynInitMenuPaneL( TInt aResourceId, CEikMenuPane* aMenuPane ) + { + CMemSpyViewBase& view = iAppContainer->ActiveView(); + const TMemSpyViewType viewType = iAppContainer->ActiveViewType(); + // + const TBool openableView = MemSpyViewTypeUtils::IsOpenableItem( viewType ); + const TBool exitable = MemSpyViewTypeUtils::IsExitableView( viewType ); + // +#ifdef _DEBUG + RDebug::Printf( "[MemSpy] CMemSpyAppUi::DynInitMenuPaneL() - START - aResourceId: 0x%08x (%8d), iAutoCaptureOperationType: %d, iAutoCaptureTimer is active: %d, viewType: %d, openableView: %d, exitable: %d", aResourceId, aResourceId, iAutoCaptureOperationType, iAutoCaptureTimer->IsActive(), viewType, openableView, exitable ); +#endif + // + if ( aResourceId == R_MEMSPY_MENUPANE ) + { + const TInt count = aMenuPane->NumberOfItemsInPane(); + for( TInt i=0; iItemDataByIndexL( i ); + + // If the command is inside the view-specific range then we'll hide it + // unless the view and command id matches. + const TBool isViewSpecific = ( menuPaneMetaData.iCommandId >= KMemSpyMenuCommandViewSpecific ); + if ( isViewSpecific ) + { + // Check whether this view requires this command item. + dimItem = ( view.MenuCascadeCommandId() != menuPaneMetaData.iCommandId ); + } + + aMenuPane->SetItemDimmed( menuPaneMetaData.iCommandId, dimItem ); + } + + aMenuPane->SetItemDimmed( EMemSpyCmdOpen, !openableView ); + aMenuPane->SetItemDimmed( EAknSoftkeyBack, exitable ); + aMenuPane->SetItemDimmed( EAknCmdExit, !exitable ); + } + else if ( aResourceId == R_MEMSPY_MENUPANE_TOOLS ) + { + const TBool inOpenFilesView = ( viewType == EMemSpyViewTypeOpenFiles ); + aMenuPane->SetItemDimmed( EMemSpyCmdToolsListOpenFiles, !inOpenFilesView ); + } + else if ( aResourceId == R_MEMSPY_MENUPANE_VIEW ) + { + // Hide the refresh item when in the thread info container view + aMenuPane->SetItemDimmed( EMemSpyCmdViewRefresh, viewType == EMemSpyViewTypeThreadInfoItemList ); + aMenuPane->SetItemDimmed( EMemSpyCmdViewOutputToSink, viewType == EMemSpyViewTypeThreadInfoItemList ); + } + else if ( aResourceId == R_MEMSPY_MENUPANE_OUTPUT ) + { + /* TODO + //const TMemSpySinkType currentSink = iEngine.SinkType(); + const TMemSpySinkType currentSink = iMemSpySession.GetSinkType(); + aMenuPane->SetItemDimmed( EMemSpyCmdOutputToDebug, currentSink == ESinkTypeDebug ); + aMenuPane->SetItemDimmed( EMemSpyCmdOutputToFile, currentSink == ESinkTypeFile ); + */ + } + else if ( aResourceId == R_MEMSPY_MENUPANE_AUTO_CAPTURE ) + { + // Change the auto-capture toggle caption appropriately... + TInt resId = R_MEMSPY_AUTO_CAPTURE_ENABLE; + if ( iAutoCaptureTimer->IsActive() ) + { + resId = R_MEMSPY_AUTO_CAPTURE_DISABLE; + } + aMenuPane->SetItemTextL( EMemSpyCmdAutoCaptureToggle, resId ); + } + +#ifdef _DEBUG + RDebug::Printf( "[MemSpy] CMemSpyAppUi::DynInitMenuPaneL() - sending to view..." ); +#endif + + view.DynInitMenuPaneL( aResourceId, aMenuPane ); + +#ifdef _DEBUG + RDebug::Printf( "[MemSpy] CMemSpyAppUi::DynInitMenuPaneL() - END - aResourceId: 0x%08x (%8d), iAutoCaptureOperationType: %d, iAutoCaptureTimer is active: %d, viewType: %d, openableView: %d, exitable: %d", aResourceId, aResourceId, iAutoCaptureOperationType, iAutoCaptureTimer->IsActive(), viewType, openableView, exitable ); +#endif + } + + +TKeyResponse CMemSpyAppUi::HandleKeyEventL( const TKeyEvent& /*aKeyEvent*/, TEventCode /*aType*/ ) + { + return EKeyWasNotConsumed; + } + + +void CMemSpyAppUi::HandleCommandL( TInt aCommand ) + { +#ifdef _DEBUG + RDebug::Printf( "[MemSpy] CMemSpyAppUi::HandleCommandL() - START - aCommand: %8d, iAutoCaptureOperationType: %d, iAutoCaptureTimer is active: %d", aCommand, iAutoCaptureOperationType, iAutoCaptureTimer->IsActive() ); +#endif + + switch ( aCommand ) + { + case EAknSoftkeyBack: + OnCmdBackL(); + break; + + case EEikCmdExit: + case EAknCmdExit: + case EAknSoftkeyExit: + OnCmdExitL(); + break; + + case EMemSpyCmdOpen: + OnCmdOpenL(); + break; + + case EMemSpyCmdOutputToDebug: + OnCmdOutputToDebugL(); + break; + case EMemSpyCmdOutputToFile: + OnCmdOutputToFileL(); + break; + + case EMemSpyCmdToolsAbout: + OnCmdAboutL(); + break; + // + case EMemSpyCmdPhoneInfoGeneralSummary: + //OnCmdPhoneInformationOperationL( CMemSpyDeviceWideOperations::EPerEntityGeneralSummary ); + OnCmdPhoneInformationOperationL( OutputPhoneInfo ); + break; + case EMemSpyCmdPhoneInfoGeneralDetailed: + //OnCmdPhoneInformationOperationL( CMemSpyDeviceWideOperations::EPerEntityGeneralDetailed ); + OnCmdPhoneInformationOperationL( OutputDetailedPhoneInfo ); + break; + /* + case EMemSpyCmdPhoneInfoGeneralHandles: + OnCmdPhoneInformationOperationL( CMemSpyDeviceWideOperations::EPerEntityGeneralHandles ); + break; + case EMemSpyCmdPhoneInfoGeneralKernelContainers: + OnCmdPhoneInformationOperationKernelContainersL(); + break; + // + */ + case EMemSpyCmdPhoneInfoHeapInfoSummary: + //OnCmdPhoneInformationOperationL( CMemSpyDeviceWideOperations::EPerEntityHeapInfo ); + OnCmdPhoneInformationOperationL (OutputHeapInfo ); + break; + case EMemSpyCmdPhoneInfoHeapInfoCompact: + //OnCmdPhoneInformationOperationL( CMemSpyDeviceWideOperations::EEntireDeviceHeapInfoCompact ); + OnCmdPhoneInformationOperationL( OutputCompactHeapInfo ); + break; + case EMemSpyCmdPhoneInfoHeapCellListing: + //OnCmdPhoneInformationOperationL( CMemSpyDeviceWideOperations::EPerEntityHeapCellListing ); + OnCmdPhoneInformationOperationL( OutputHeapCellListing ); + break; + + case EMemSpyCmdPhoneInfoHeapDump: + //OnCmdPhoneInformationOperationL( CMemSpyDeviceWideOperations::EPerEntityHeapData ); + OnCmdPhoneInformationOperationL( OutputHeapData ); + break; + // + case EMemSpyCmdPhoneInfoStackInfo: + //OnCmdPhoneInformationOperationL( CMemSpyDeviceWideOperations::EPerEntityStackInfo ); + OnCmdPhoneInformationOperationL( OutputStackInfo ); + break; + case EMemSpyCmdPhoneInfoStackInfoCompact: + //OnCmdPhoneInformationOperationL( CMemSpyDeviceWideOperations::EEntireDeviceStackInfoCompact ); + OnCmdPhoneInformationOperationL( OutputCompactStackInfo ); + break; + case EMemSpyCmdPhoneInfoStackDumpUser: + //OnCmdPhoneInformationOperationL( CMemSpyDeviceWideOperations::EPerEntityStackDataUser ); + OnCmdPhoneInformationOperationL( OutputUserStackData ); + break; + case EMemSpyCmdPhoneInfoStackDumpKernel: + //OnCmdPhoneInformationOperationL( CMemSpyDeviceWideOperations::EPerEntityStackDataKernel ); + OnCmdPhoneInformationOperationL( OutputKernelStackData ); + break; + + case EMemSpyCmdAutoCaptureToggle: + OnCmdAutoCaptureToggleL(); + break; + case EMemSpyCmdAutoCaptureRetryTime: + OnCmdAutoCaptureRetryTimeL(); + break; + case EMemSpyCmdAutoCaptureOperationType: + OnCmdAutoCaptureOperationTypeL(); + break; + + default: + iAppContainer->HandleCommandL( aCommand ); + break; + } + +#ifdef _DEBUG + RDebug::Printf( "[MemSpy] CMemSpyAppUi::HandleCommandL() - END - aCommand: %8d, iAutoCaptureOperationType: %d, iAutoCaptureTimer is active: %d", aCommand, iAutoCaptureOperationType, iAutoCaptureTimer->IsActive() ); +#endif + } + + +void CMemSpyAppUi::HandleForegroundEventL( TBool aForeground) + { + // Refresh the container when coming to the foreground + if ( aForeground ) + { + iAppContainer->OnCmdViewRefreshL(); + } + } + + +void CMemSpyAppUi::HandleThreadSelectedL( const CMemSpyThread& /*aThread*/ ) + { + MEikAppUiFactory* appUiFactory = (iEikonEnv)->AppUiFactory(); + appUiFactory->MenuBar()->TryDisplayMenuBarL(); + } + + +void CMemSpyAppUi::HandleMemSpyEngineEventL( MMemSpyEngineObserver::TEvent aEvent, TAny* aContext ) + { + if ( aEvent == MMemSpyEngineObserver::EHandleThreadsOrProcessesChanged ) + { + // Get the original container + const CMemSpyEngineObjectContainer& oldContainer = *reinterpret_cast< CMemSpyEngineObjectContainer* >( aContext ); + (void) oldContainer; + + // Refresh the container + iAppContainer->OnCmdViewRefreshL(); + } + else if ( aEvent == MMemSpyEngineObserver::EHandleClientServerOperationRequest ) + { + const TInt function = reinterpret_cast( aContext ); + InitiateMemSpyClientServerOperationL( function ); + } + } + + +void CMemSpyAppUi::DWOperationStarted() + { +#ifdef _DEBUG + RDebug::Printf( "[MemSpy] CMemSpyAppUi::DWOperationStarted() - START - iRunningDeviceWideOperation: %d, iAutoCaptureTimer is active: %d", iRunningDeviceWideOperation, iAutoCaptureTimer->IsActive() ); +#endif + + iRunningDeviceWideOperation = ETrue; + +#ifdef _DEBUG + RDebug::Printf( "[MemSpy] CMemSpyAppUi::DWOperationStarted() - END - iRunningDeviceWideOperation: %d, iAutoCaptureTimer is active: %d", iRunningDeviceWideOperation, iAutoCaptureTimer->IsActive() ); +#endif + } + + +void CMemSpyAppUi::DWOperationCancelled() + { +#ifdef _DEBUG + RDebug::Printf( "[MemSpy] CMemSpyAppUi::DWOperationCancelled() - START - iRunningDeviceWideOperation: %d, iAutoCaptureTimer is active: %d", iRunningDeviceWideOperation, iAutoCaptureTimer->IsActive() ); +#endif + + iAutoCaptureTimer->Cancel(); + +#ifdef _DEBUG + RDebug::Printf( "[MemSpy] CMemSpyAppUi::DWOperationCancelled() - END - iRunningDeviceWideOperation: %d, iAutoCaptureTimer is active: %d", iRunningDeviceWideOperation, iAutoCaptureTimer->IsActive() ); +#endif + } + + +void CMemSpyAppUi::DWOperationCompleted() + { +#ifdef _DEBUG + RDebug::Printf( "[MemSpy] CMemSpyAppUi::DWOperationCompleted() - START - iRunningDeviceWideOperation: %d, iAutoCaptureTimer is active: %d", iRunningDeviceWideOperation, iAutoCaptureTimer->IsActive() ); +#endif + + iRunningDeviceWideOperation = EFalse; + +#ifdef _DEBUG + RDebug::Printf( "[MemSpy] CMemSpyAppUi::DWOperationCompleted() - END - iAutoCaptureTimer is active: %d", iAutoCaptureTimer->IsActive() ); +#endif + } + + +void CMemSpyAppUi::UpdateCBAL() + { + CEikButtonGroupContainer* cba = CEikButtonGroupContainer::Current(); + const TMemSpyViewType viewType = iAppContainer->ActiveViewType(); + // + if ( MemSpyViewTypeUtils::IsExitableView( viewType ) ) + { + cba->SetCommandSetL( R_AVKON_SOFTKEYS_OPTIONS_EXIT ); + } + else + { + cba->SetCommandSetL( R_AVKON_SOFTKEYS_OPTIONS_BACK ); + } + + cba->MakeVisible( ETrue ); + cba->DrawNow(); + } + + +void CMemSpyAppUi::InitiateMemSpyClientServerOperationL( TInt aOpCode ) + { +#ifdef _DEBUG + RDebug::Printf( "[MemSpy] CMemSpyAppUi::InitiateMemSpyClientServerOperationL() - START - aOpCode: %d", aOpCode ); +#endif + + switch( aOpCode ) + { + case EMemSpyClientServerOpSummaryInfo: + HandleCommandL( EMemSpyCmdPhoneInfoGeneralSummary ); + break; + case EMemSpyClientServerOpSummaryInfoDetailed: + HandleCommandL( EMemSpyCmdPhoneInfoGeneralDetailed ); + break; + // + case EMemSpyClientServerOpHeapInfo: + HandleCommandL( EMemSpyCmdPhoneInfoHeapInfoSummary ); + break; + case EMemSpyClientServerOpHeapCellListing: + HandleCommandL( EMemSpyCmdPhoneInfoHeapCellListing ); + break; + case EMemSpyClientServerOpHeapData: + HandleCommandL( EMemSpyCmdPhoneInfoHeapDump ); + break; + // + case EMemSpyClientServerOpStackInfo: + HandleCommandL( EMemSpyCmdPhoneInfoStackInfo ); + break; + case EMemSpyClientServerOpStackDataUser: + HandleCommandL( EMemSpyCmdPhoneInfoStackDumpUser ); + break; + case EMemSpyClientServerOpStackDataKernel: + HandleCommandL( EMemSpyCmdPhoneInfoStackDumpKernel ); + break; + // + case EMemSpyClientServerOpBitmapsSave: + OnCmdToolsBitmapsSaveToMemoryCardL(); + break; + case EMemSpyClientServerOpSendToBackground: + OnCmdToolsSendToBackgroundL(); + break; + case EMemSpyClientServerOpBringToForeground: + OnCmdToolsBringToForegroundL(); + break; + case EMemSpyClientServerOpExit: + OnCmdExitL(); + break; + // + default: + User::Leave( KErrNotSupported ); + break; + } + +#ifdef _DEBUG + RDebug::Printf( "[MemSpy] CMemSpyAppUi::InitiateMemSpyClientServerOperationL() - END - aOpCode: %d", aOpCode ); +#endif + } + + +void CMemSpyAppUi::SetViewServerTimeOutStatus( TBool aEnabled ) + { + /* TODO + iMemSpySession.SetServerTimeOutStatus( KMemSpyEikSrvSID, aEnabled ); + */ + /* + TRAP_IGNORE( + iEngine.HelperProcess().ImpersonateL( KMemSpyEikSrvSID ); + // + CVwsSessionWrapper* ses = CVwsSessionWrapper::NewLC(); + ses->EnableServerEventTimeOut( aEnabled ); + CleanupStack::PopAndDestroy( ses ); + // + iEngine.HelperProcess().ImpersonateL( 0 ); + ); + */ + } + + +void CMemSpyAppUi::OnCmdBackL() + { + const TMemSpyViewType viewType = iAppContainer->ActiveViewType(); + // + if ( !MemSpyViewTypeUtils::IsExitableView( viewType ) ) + { + // Should go back one view + iAppContainer->NavigateToParentViewL(); + } + } + + +void CMemSpyAppUi::OnCmdExitL() + { + Exit(); + } + + +void CMemSpyAppUi::OnCmdOpenL() + { + const TMemSpyViewType viewType = iAppContainer->ActiveViewType(); + // + if ( !MemSpyViewTypeUtils::IsOpenableItem( viewType ) ) + { + // Should go back one view + iAppContainer->NavigateToChildViewL(); + } + } + + +void CMemSpyAppUi::OnCmdPhoneInformationOperationL( TDeviceWideOperation aOperation ) + { + // + //CMemSpyDeviceWideOperationDialog::ExecuteLD( iMemSpySession, aOperation ); + CMemSpyDwoTracker* tracker = CMemSpyDeviceWideOperationDialog::CreateDeviceWideOperation( iMemSpySession, aOperation ); + tracker->Start(); + /* +#ifdef _DEBUG + RDebug::Printf( "[MemSpy] CMemSpyAppUi::OnCmdPhoneInformationOperationL() - START - aOp: %d, iRunningDeviceWideOperation: %d, iAutoCaptureTimer is active: %d", aOp, iRunningDeviceWideOperation, iAutoCaptureTimer->IsActive() ); +#endif + + if ( !iRunningDeviceWideOperation ) + { + CMemSpyDeviceWideOperationDialog::ExecuteLD( iMemSpySession, *this, aOp ); + } + +#ifdef _DEBUG + RDebug::Printf( "[MemSpy] CMemSpyAppUi::OnCmdPhoneInformationOperationL() - END - aOp: %d, iRunningDeviceWideOperation: %d, iAutoCaptureTimer is active: %d", aOp, iRunningDeviceWideOperation, iAutoCaptureTimer->IsActive() ); +#endif + */ + } + + +void CMemSpyAppUi::OnCmdPhoneInformationOperationKernelContainersL() + { + /* TODO + iMemSpySession.OutputKernelObjects(); + */ + /* + CMemSpyEngineGenericKernelObjectContainer* list = iEngine.HelperKernelContainers().ObjectsAllL(); + CleanupStack::PushL( list ); + iEngine.HelperKernelContainers().OutputL( *list ); + CleanupStack::PopAndDestroy( list ); + */ + } + + + + + + + + + + + + + + + + + + + + + + +void CMemSpyAppUi::OnCmdAutoCaptureToggleL() + { +#ifdef _DEBUG + RDebug::Printf( "[MemSpy] CMemSpyAppUi::OnCmdAutoCaptureToggleL() - START - iAutoCaptureOperationType: %d, iAutoCaptureTimer is active: %d", iAutoCaptureOperationType, iAutoCaptureTimer->IsActive() ); +#endif + + if ( iAutoCaptureTimer->IsActive() ) + { + iAutoCaptureTimer->Cancel(); + } + else + { + iAutoCaptureTimer->Cancel(); + // + const TTimeIntervalMicroSeconds32 interval( iAutoCaptureTimerPeriod * 1000000 ); + iAutoCaptureTimer->Start( 0, interval, TCallBack(AutoCaptureCallBack, this) ); + } + +#ifdef _DEBUG + RDebug::Printf( "[MemSpy] CMemSpyAppUi::OnCmdAutoCaptureToggleL() - START - iAutoCaptureOperationType: %d, iAutoCaptureTimer is active: %d", iAutoCaptureOperationType, iAutoCaptureTimer->IsActive() ); +#endif + } + + +void CMemSpyAppUi::OnCmdAutoCaptureRetryTimeL() + { + CAknNumberQueryDialog* dialog = new(ELeave) CAknNumberQueryDialog( iAutoCaptureTimerPeriod ); + dialog->ExecuteLD( R_MEMSPY_DEVICE_WIDE_SETTINGS ); + } + + +void CMemSpyAppUi::OnCmdAutoCaptureOperationTypeL() + { + CDesCArrayFlat* items = iCoeEnv->ReadDesC16ArrayResourceL( R_MEMSPY_AUTO_CAPTURE_OPERATION_TYPES ); + CleanupStack::PushL(items); + // + TInt currentItem = iAutoCaptureOperationType; + // + CAknRadioButtonSettingPage* dialog = new(ELeave) CAknRadioButtonSettingPage( R_MEMSPY_AUTO_CAPTURE_OPERATION_TYPES_SETTINGS_PAGE, currentItem, items ); + if ( dialog->ExecuteLD( CAknSettingPage::EUpdateWhenAccepted ) ) + { + iAutoCaptureOperationType = static_cast< CMemSpyDeviceWideOperations::TOperation >( currentItem ); + } + // + CleanupStack::PopAndDestroy( items ); + } + + +TInt CMemSpyAppUi::AutoCaptureCallBack( TAny* aSelf ) + { + CMemSpyAppUi* self = reinterpret_cast< CMemSpyAppUi* >( aSelf ); + TRAPD( err, self->AutoCaptureCallBackL() ); + // + const TBool callMeBackAgain = ( err == KErrNone ); + return callMeBackAgain; + } + + +void CMemSpyAppUi::AutoCaptureCallBackL() + { +#ifdef _DEBUG + RDebug::Printf( "[MemSpy] CMemSpyAppUi::AutoCaptureCallBackL() - START - iAutoCaptureOperationType: %d, iAutoCaptureTimer is active: %d", iAutoCaptureOperationType, iAutoCaptureTimer->IsActive() ); +#endif + + // OnCmdPhoneInformationOperationL( iAutoCaptureOperationType ); + +#ifdef _DEBUG + RDebug::Printf( "[MemSpy] CMemSpyAppUi::AutoCaptureCallBackL() - END - iAutoCaptureOperationType: %d, iAutoCaptureTimer is active: %d", iAutoCaptureOperationType, iAutoCaptureTimer->IsActive() ); +#endif + } + + + + + + + + + + + + + + + + + + + + + +void CMemSpyAppUi::OnCmdOutputToDebugL() + { + iMemSpySession.SwitchOutputSink( ESinkTypeDebug ); //set in engine + MemSpyDocument().Settings().SetSinkType( ESinkTypeDebug ); //set in settings + } + + +void CMemSpyAppUi::OnCmdOutputToFileL() + { + iMemSpySession.SwitchOutputSink( ESinkTypeFile ); //set in engine + MemSpyDocument().Settings().SetSinkType( ESinkTypeFile ); //set in settings + } + + + + + + + + + + + +void CMemSpyAppUi::OnCmdAboutL() + { + CAknMessageQueryDialog* dialog = new(ELeave) CAknMessageQueryDialog; + dialog->ExecuteLD( R_MEMSPYUI_ABOUT_DIALOG ); + } + + + + + + + + + + + + +void CMemSpyAppUi::OnCmdToolsBitmapsSaveToMemoryCardL() + { + /* TODO + // Get bitmap handles + RArray handles; + CleanupClosePushL( handles ); + iEngine.HelperFbServ().GetArrayOfBitmapHandlesL( handles ); + + // Build bitmap list + CMemSpyEngineFbServBitmapArray* array = CMemSpyEngineFbServBitmapArray::NewL( handles ); + CleanupStack::PopAndDestroy( &handles ); + CleanupStack::PushL( array ); + + // Export... + CMemSpyExportBitmapsToMemoryCardDialog* dialog = CMemSpyExportBitmapsToMemoryCardDialog::NewL( iCoeEnv->FsSession(), *array ); + + // All done + CleanupStack::PopAndDestroy( array ); + */ + } + + +void CMemSpyAppUi::OnCmdToolsSendToBackgroundL() + { + TApaTask task( iCoeEnv->WsSession() ); + task.SendToBackground(); + } + + +void CMemSpyAppUi::OnCmdToolsBringToForegroundL() + { + iCoeEnv->BringOwnerToFront(); + } + + + +