// ----------------------------------------------------------------------------- // CTestSDKQueries::TestLqdlgPublishDialogL // ----------------------------------------------------------------------------- // TInt CTestSDKQueries::TestLqdlgPublishDialogL( CStifItemParser& /*aItem*/ ) { TInt selectedOption( KZero ); CDesCArrayFlat* mArray = new (ELeave) CDesCArrayFlat(KTen); CleanupStack::PushL( mArray ); TBuf< KTen > palabra; for (TInt num = KZero; num< KTen; num++) { palabra.Format(_L("option %d"), num); mArray->AppendL(palabra); } CAknListQueryDialog* dlg = new( ELeave ) CAknListQueryDialog( &selectedOption ); dlg->PrepareLC( R_UPDATE_QUERY_MSG_DIALOG ); dlg->SetItemTextArray( mArray ); dlg->SetOwnershipType( ELbmDoesNotOwnItemArray ); CArrayFixFlat< TInt >* selArray = new( ELeave )CArrayFixFlat< TInt >( KFive ); CleanupStack::PushL( selArray ); selArray->AppendL( KOne ); selArray->AppendL( KThree ); TInt err = KErrNone; TRAP( err, dlg->PublishDialogL( KOne, KNullUid, selArray )); CleanupStack::Pop( KOne ); CleanupStack::PopAndDestroy( KTwo ); return KErrNone; }
// ----------------------------------------------------------------------------- // CTestSDKQueries::TestLqdlgConstructorLL // ----------------------------------------------------------------------------- // TInt CTestSDKQueries::TestLqdlgConstructorLL( CStifItemParser& /*aItem*/ ) { CArrayFixFlat< TInt >* selArray = new( ELeave )CArrayFixFlat< TInt >( KFive ); CleanupStack::PushL( selArray ); selArray->AppendL( KOne ); selArray->AppendL( KThree ); CAknListQueryDialog* dlg = new( ELeave ) CAknListQueryDialog( selArray ); CleanupStack::PushL( dlg ); STIF_ASSERT_NOT_NULL( dlg ); CleanupStack::PopAndDestroy( dlg ); CleanupStack::Pop( selArray ); return KErrNone; }
void CContextMediaArrayImpl::PostEvent(CCMPost* aParent, CCMPost* aChild, TEvent aEvent) { CALLSTACKITEM_N(_CL("CContextMediaArrayImpl"), _CL("PostEvent")); if (aParent != iParentPost) return; if (aEvent==EChildAdded) { iPostIdArray->AppendL(aChild->iPostId()); iPostArray->AppendL(0); iObserver.PostEvent(aParent, aChild, aEvent); } if (aEvent==EPlaceholderFilled) { TInt i; for (i=0; i<iPostIdArray->Count();i++) { if (iPostIdArray->At(i) == aChild->iPostId()) { CC_TRAPD(ignore, iStorage.Release(iPostArray->At(i), 0)); iPostArray->At(i) = 0; iObserver.PostEvent(aParent, aChild, aEvent); return; } } } if (aEvent==EPostHidden) { ReadFromStorage(); iObserver.PostEvent(aParent, aChild, aEvent); } if (aEvent==EPostVisible) { ReadFromStorage(); iObserver.PostEvent(aParent, aChild, aEvent); } if (aEvent==EPostUpdated) { iObserver.PostEvent(aParent, aChild, aEvent); } if ((aEvent==EThumbnailLoaded) || (aEvent==EUnreadChanged)) { iObserver.PostEvent(aParent, aChild, aEvent); } if (aEvent==ELastPostChanged) { iObserver.PostEvent(aParent, aChild, aEvent); } //do nothing for: // EMediaLoaded, // EErrorUpdated, }
CArrayFix<TCoeHelpContext>* CMobileOfficeAppUi::HelpContextL() const { CArrayFixFlat<TCoeHelpContext>* array = new(ELeave)CArrayFixFlat<TCoeHelpContext>(1); CleanupStack::PushL(array); array->AppendL(TCoeHelpContext(KUidMobileOffice, _L("Introduction"))); CleanupStack::Pop(array); return array; }
void CFMSServer::CreateScheduledReminderL() { FLOG(_L("CFMSServer::CreateScheduledReminderL ()")); _LIT(KFotaScheduleExe, "Z:\\sys\\bin\\fotaschedulehandler.exe"); RScheduler scheduler; TTsTime startTime; TTime time; time.HomeTime(); time = time + (TTimeIntervalHours(1)); startTime.SetLocalTime(time); User::LeaveIfError(scheduler.Connect()); CleanupClosePushL(scheduler); //Creating a persistent daily schedule TSchedulerItemRef persistentScheduleItem; CArrayFixFlat<TScheduleEntryInfo2>* entries = new CArrayFixFlat<TScheduleEntryInfo2> (1); CleanupStack::PushL(entries); persistentScheduleItem.iName = TUid::Uid(KFMSServerUid).Name(); //TScheduleEntryInfo2 scentry1(startTime, EDaily, 1, 1); TScheduleEntryInfo2 scentry1; scentry1.SetStartTime(startTime); scentry1.SetInterval(1); scentry1.SetIntervalType(TIntervalType(EHourly)); scentry1.SetValidityPeriod((TTimeIntervalMinutes) 1440); //1440 min = 24 hrs or 1 day entries->AppendL(scentry1); scheduler.Register(TFileName( KFotaScheduleExe ), 0 ); TInt ret = scheduler.CreatePersistentSchedule(persistentScheduleItem, *entries); FLOG(_L("created schedule %d %d:%d"), persistentScheduleItem.iHandle, time.DateTime().Hour(), time.DateTime().Minute()); if (ret == KErrNone) { TTaskInfo taskInfo; taskInfo.iName = TUid::Uid(KFMSServerUid).Name(); taskInfo.iRepeat = 1; //Repeat once taskInfo.iPriority = 1; TFotaScheduledUpdate fotareminder(-1, -1); TPckg<TFotaScheduledUpdate> fotareminderpkg(fotareminder); HBufC* data = HBufC::NewLC(fotareminderpkg.Length()); data->Des().Copy(fotareminderpkg); TInt err = scheduler.ScheduleTask(taskInfo, *data, persistentScheduleItem.iHandle); FLOG(_L("Schedule creation error %d"), err); CleanupStack::PopAndDestroy(data); } CleanupStack::PopAndDestroy(entries); CleanupStack::PopAndDestroy(&scheduler); // xx }
void CContextMediaArrayImpl::ReadFromStorage() { CALLSTACKITEM_N(_CL("CContextMediaArrayImpl"), _CL("ReadFromStorage")); iPostIdArray->Reset(); ReleasePosts(); iPostArray->Reset(); TBool ok = iStorage.FirstL(iNode, iSort, CPostStorage::EAscending, EFalse); while (ok) { TInt64 id = iStorage.GetCurrentIdL(); iPostIdArray->AppendL(id); iPostArray->AppendL(0); ok = iStorage.NextL(); } if (iStandAlone && iNode==iStorage.RootId()) { iPostIdArray->AppendL(iStorage.RootId()); iPostArray->AppendL(0); } }
/** This method should only be used by CImapAtomParser. During parsing, a ReAllocL() may be required on the heap buffer that this atom and its descendants' string data descriptor points at. This happens when the heap buffer needs to be expanded. If this causes the heap buffer's address to change, then this atom and its descendants' pointer descriptors need updating. @param The address of the new heap buffer @param The address of the data within the heap buffer before the ReAllocL took place. */ void CImapAtom::FixupL(const HBufC8 *aNewBuffer, const TText8 *aOldBuffer) { // Fixup descriptor pointers CArrayFixFlat<CImapAtom*>* atomStack = new (ELeave) CArrayFixFlat<CImapAtom*>(10); CleanupStack::PushL(atomStack); atomStack->AppendL(this); CImapAtom* currentAtom; while (atomStack->Count() != 0) { // Pop the top atom off of the stack currentAtom = (*atomStack)[atomStack->Count() - 1]; atomStack->ResizeL(atomStack->Count() - 1); // Fix up the current atom if (currentAtom->iAtom.Length()>0) { // Find offset from start of old buffer TInt start=(currentAtom->iAtom.Ptr()-aOldBuffer); // Make new descriptor & assign it TPtrC8 bufptr(aNewBuffer->Ptr()+start,currentAtom->iAtom.Length()); currentAtom->iAtom.Set(bufptr); // Note that we are setting the real iAtom not the copy returned by Atom() } // Add the first sibling to the stack, // subsequent siblings are added when this sibling is visited CImapAtom* siblingAtom = currentAtom->Next(); if (siblingAtom) { atomStack->AppendL(siblingAtom); } // Add child to the stack CImapAtom* childAtom = currentAtom->Child(); if (childAtom) { atomStack->AppendL(childAtom); } } CleanupStack::PopAndDestroy(atomStack); }
// --------------------------------------------------------------------------- // Get an array of image quality levels that are in use with the current // product with given Camera/Display ID. If the ID is zero, then all levels // dispite of the ID value are returned. // --------------------------------------------------------------------------- // TInt CImagingConfigManager::GetImageQualityLevelsL( CArrayFixFlat<TUint>& aLevels, TUint /*aCameraDisplayID*/ ) { aLevels.Reset(); for( TInt i = 0 ; i < NumberOfImageQualityLevels() ; i++ ) { aLevels.AppendL( iImageQualitySets->At( i ).iImageQualitySetLevel ); } return KErrNone; }
CArrayFix<TCoeHelpContext>* CPodcastAppUi::HelpContextL() const { CArrayFixFlat<TCoeHelpContext>* array = new(ELeave)CArrayFixFlat<TCoeHelpContext>(1); CleanupStack::PushL(array); if (iFeedView->IsVisible()) { array->AppendL(TCoeHelpContext(KUidPodcast,KContextFeedsView)); } else if (iShowsView->IsVisible()) { array->AppendL(TCoeHelpContext(KUidPodcast,KContextShowsView)); } else if (iSearchView->IsVisible()) { array->AppendL(TCoeHelpContext(KUidPodcast,KContextSearch)); } else if (iQueueView->IsVisible()) { array->AppendL(TCoeHelpContext(KUidPodcast,KContextDownloadQueue)); } else { array->AppendL(TCoeHelpContext(KUidPodcast,KContextSettings)); } CleanupStack::Pop(array); return array; }
//Puts the existing settings and some new settings in the list of settings //Now both will be deleted on exit. void CPigeonScheduledSend::PopulateSettingsL() { delete iSettings; iSettings = NULL; //Make some shiny new settings instead iSettings = CMsvScheduleSettings::NewL(); iSettings->SetShortInterval(KShortInterval); iSettings->SetLongInterval(KLongInterval); CArrayFixFlat<TTimeIntervalSeconds>* intervals = new(ELeave)CArrayFixFlat<TTimeIntervalSeconds>(20); CleanupStack::PushL(intervals); intervals->AppendL(KFirstInterval); intervals->AppendL(KSecondInterval); intervals->AppendL(KThirdInterval); iSettings->SetVariableIntervalsL(*intervals); // copies intervals CleanupStack::PopAndDestroy(); //intervals // iSettingsList->AppendL(custom); }
CArrayFix<TCoeHelpContext>* CRhodesAppUi::HelpContextL() const { #warning "Please see comment about help and UID3..." // Note: Help will not work if the application uid3 is not in the // protected range. The default uid3 range for projects created // from this template (0xE0000000 - 0xEFFFFFFF) are not in the protected range so that they // can be self signed and installed on the device during testing. // Once you get your official uid3 from Symbian Ltd. and find/replace // all occurrences of uid3 in your project, the context help will // work. CArrayFixFlat<TCoeHelpContext>* array = new(ELeave)CArrayFixFlat<TCoeHelpContext>(1); CleanupStack::PushL(array); array->AppendL(TCoeHelpContext(KUidRhodesApp, KGeneral_Information)); CleanupStack::Pop(array); return array; }
CArrayFix<TCoeHelpContext>* CHelloS60AppUi::HelpContextL() const { #warning "Please see comment about help and UID3..." // Note: Help will not work if the application uid3 is not in the // protected range. The default uid3 range for projects created // from this template (0xE0000000 - 0xEFFFFFFF) are not in the protected range so that they // can be self signed and installed on the device during testing. // Once you get your official uid3 from Symbian Ltd. and find/replace // all occurrences of uid3 in your project, the context help will // work. Alternatively, a patch now exists for the versions of // HTML help compiler in SDKs and can be found here along with an FAQ: // http://www3.symbian.com/faq.nsf/AllByDate/E9DF3257FD565A658025733900805EA2?OpenDocument CArrayFixFlat<TCoeHelpContext>* array = new (ELeave) CArrayFixFlat< TCoeHelpContext> (1); CleanupStack::PushL(array); array->AppendL(TCoeHelpContext(KUidHelloS60App, KGeneral_Information)); CleanupStack::Pop(array); return array; }
CArrayFixFlat<TPtrC>* CKeytoolFileView::ReadArrayArgumentsLC(TInt cmdIndex) { CArrayFixFlat<TPtrC>* currentCmd = new (ELeave) CArrayFixFlat<TPtrC> (10); CleanupStack::PushL(currentCmd); TPtr cmd = iArgs[cmdIndex]->Des(); cmd.Trim(); TLex arguments(cmd); while(!arguments.Eos()) { TPtrC token = arguments.NextToken(); currentCmd->AppendL(token); } TBuf<150> string; string.Format(_L("Command : %S\noutput :"), &cmd); KeyToolUtils::PrintInfoL(_L("================================================")); KeyToolUtils::PrintInfoL(_L("================================================\n")); DisplayErrorL(string, 0); return currentCmd; }
/*! * Store contact */ CArrayFixFlat<TUid>* CNsmlContactsDataStoreExtensionPrivate::ImportContactsL( const TDesC8 &contactbufbase ) { _DBG_FILE("CNsmlContactsDataStoreExtensionPrivate::ImportContactsL: BEGIN"); DBG_DUMP((void*)contactbufbase.Ptr(), contactbufbase.Length(), _S8("CNsmlContactsDataStoreExtensionPrivate::ImportContactsL: To DB :")); TBool ret( ETrue ); CArrayFixFlat<TUid>* contactItems = new(ELeave) CArrayFixFlat<TUid>(4); QBuffer contactsbuf; contactsbuf.open(QBuffer::ReadWrite); QByteArray bytearray((char*)contactbufbase.Ptr()); contactsbuf.write(bytearray); contactsbuf.seek(0); mReader->setDevice(&contactsbuf); if (mReader->startReading() && mReader->waitForFinished()) { DBG_ARGS(_S("CNsmlContactsDataStoreExtensionPrivate::Buffer Count: %d"), mReader->results().count() ); QList<QContact> contacts; if ( mImporter->importDocuments( mReader->results() ) ) { contacts = mImporter->contacts(); QMap<int, QContactManager::Error> errorMap; ret = mContactManager->saveContacts( &contacts, &errorMap ); DBG_ARGS(_S("CNsmlContactsDataStoreExtensionPrivate::Import Status: %d"), ret ); } if( ret ) { foreach (QContact contact, contacts ) { TUint contactid = contact.id().localId(); DBG_ARGS(_S("CNsmlContactsDataStoreExtensionPrivate::Contact ID: %d"), contactid ); contactItems->AppendL( TUid::Uid( contactid ) ); } }
void CMsvScheduleSend::PopulateScheduleConditionsL(CArrayFixFlat<TTaskSchedulerCondition>& aSchConditions) { aSchConditions.Reset(); TInt count = iAgentActions->Count(); TTaskSchedulerCondition condition; // All system agent condition have a UID of KUidSystemCategory. condition.iCategory = KUidSystemCategory; for( TInt i = 0; i < count; ++i ) { TMsvCondition agentCondition = iAgentActions->At(i).iCondition; condition.iKey = agentCondition.iVariable.iUid; condition.iState = agentCondition.iState; switch( agentCondition.iType ) { case TMsvCondition::EMsvSchSendEquals: condition.iType = TTaskSchedulerCondition::EEquals; break; case TMsvCondition::EMsvSchSendNotEquals: condition.iType = TTaskSchedulerCondition::ENotEquals; break; case TMsvCondition::EMsvSchSendGreaterThan: condition.iType = TTaskSchedulerCondition::EGreaterThan; break; case TMsvCondition::EMsvSchSendLessThan: condition.iType = TTaskSchedulerCondition::ELessThan; break; default: User::Invariant(); break; } aSchConditions.AppendL(condition); } }
/** Creates a new schedule on the task scheduler with which each message can be associated. The schedule is triggered by a start time being reached. @see RScheduler::CreatePersistentSchedule @param aScheduler Handle to scheduler to update. @param aSettings Scheduler settings. @param aStartTime Schedule start time. @param aValidityPeriod Schedule validity period. @param aRef On return, the new schedule. */ EXPORT_C void CMsvScheduleSend::CreateScheduleL(RScheduler& aScheduler, const CMsvScheduleSettings& aSettings, const TTime& aStartTime, const TTimeIntervalMinutes& aValidityPeriod, TSchedulerItemRef& aRef) { //Determine the new schedule entry TScheduleEntryInfo2 taskInfo; taskInfo.SetIntervalType(aSettings.IntervalType()); taskInfo.SetInterval(1); TTsTime startTime(aStartTime,ETrue); taskInfo.SetStartTime(startTime); taskInfo.SetValidityPeriod(aValidityPeriod); //Create the TScheduleEntryInfo arrag that is required by CreatePersistentSchedule CArrayFixFlat<TScheduleEntryInfo2>* entryInfos = new (ELeave) CArrayFixFlat<TScheduleEntryInfo2>(1); CleanupStack::PushL(entryInfos); //Append the new schedule entry entryInfos->AppendL(taskInfo); //Create the schedule User::LeaveIfError(aScheduler.CreatePersistentSchedule(aRef, *entryInfos)); CleanupStack::PopAndDestroy(entryInfos); }
/** Provides conversion between view indexes and contact IDs. @param aMessage.Int0() Buffer size (from client). @param aMessage.Ptr1() Descriptor containing indices (from client). @param aMessage.Ptr2() Descriptor containing contact IDs (to client). */ void CViewSubSessionBase::GetContactIdsL(const RMessage2& aMessage) { TPckgBuf<TInt> size; aMessage.ReadL(0,size); const TInt bufferSize = size(); CBufFlat* buffer = CBufFlat::NewL(bufferSize); CleanupStack::PushL(buffer); buffer->ExpandL(0,bufferSize); TPtr8 des(buffer->Ptr(0)); aMessage.ReadL(1,des); RBufReadStream readStream(*buffer); CleanupClosePushL(readStream); const TInt count = readStream.ReadUint32L(); CArrayFixFlat<TInt>* indexes = new(ELeave) CArrayFixFlat<TInt>(8); CleanupStack::PushL(indexes); for (TInt i=0; i<count; ++i) { TInt index = readStream.ReadUint32L(); indexes->AppendL(index); } CContactIdArray* array = CContactIdArray::NewLC(); iView->GetContactIdsL(*indexes, *array); HBufC8* buf=HBufC8::NewLC(bufferSize); TPtr8 bufPtr(buf->Des()); RDesWriteStream writeStream(bufPtr); CleanupClosePushL(writeStream); writeStream << *array; bufPtr.SetLength(bufferSize); aMessage.WriteL(2,*buf); CleanupStack::PopAndDestroy(6, buffer); // &writeStream, buf, array, indexes, &readStream, buffer }
void CIpsecTest4_1::TestOomPolicyListL() /** * OOM helper function - implements normal usage of PolicyListL method */ { TInt ret; TIPSecPolicy pol; CIPSecAPI* api = CIPSecAPI::NewL(); CleanupStack::PushL(api); CArrayFixFlat<TIPSecPolicy>* list = new (ELeave) CArrayFixFlat<TIPSecPolicy>(5); CleanupStack::PushL(list); list->AppendL(pol); ret = api->PolicyListL(*list); (void)ret; // to remove compiler warning TEST(api!=NULL); CleanupStack::PopAndDestroy(list); CleanupStack::PopAndDestroy(api); }
// --------------------------------------------------------------------------- // CAknDiscreetPopupDrawer::WrapTitleTextL // Wraps long text to two lines. // --------------------------------------------------------------------------- // void CAknDiscreetPopupDrawer::WrapTitleTextL() { CArrayFixFlat<TInt>* lineWidths = new ( ELeave ) CArrayFixFlat<TInt>( KMaxNumOfLines ); CleanupStack::PushL( lineWidths ); CArrayFixFlat<TPtrC>* wrappedArray = new ( ELeave ) CArrayFixFlat<TPtrC>( KMaxNumOfLines ); CleanupStack::PushL( wrappedArray ); for ( TInt i = 0; i < KMaxNumOfLines; i++ ) { lineWidths->AppendL( iTitleTextData.iTextRect.Width() ); } HBufC* visualBuffer = HBufC::NewLC( iTitleText->Length() + KMaxNumOfLines * KAknBidiExtraSpacePerLine ); *visualBuffer = *iTitleText; TPtr ptr( visualBuffer->Des() ); AknBidiTextUtils::ConvertToVisualAndWrapToArrayL( ptr, *lineWidths, *iTitleTextData.iTextFont, *wrappedArray, ETrue ); if ( wrappedArray->Count() && wrappedArray->At( 1 ) != KNullDesC ) { delete iTitleText; iTitleText = NULL; delete iBodyText; iBodyText = NULL; iTitleText = wrappedArray->At( 0 ).AllocL(); iBodyText = wrappedArray->At( 1 ).AllocL(); } CleanupStack::PopAndDestroy( visualBuffer ); CleanupStack::PopAndDestroy( wrappedArray ); CleanupStack::PopAndDestroy( lineWidths ); }
TBool CTCMBufferModeWrapper::DoCommandL( const TTEFFunction& /*aCommand*/, const TTEFSectionName& /*aSection*/, const TInt /*aAsyncErrorIndex*/) { if(BlockResult()==EPass) { // ************** Delete the Block, the block start **************** const TInt ECircular=0;//C.A. added because TBuffermode enum doesnt exist in old ulogger api: const TInt EStraight=1;//C.A. as above: TInt result=0; INFO_PRINTF1(_L("About to test buffer Mode")); //Block start RULogger logger; result=logger.Connect(); INFO_PRINTF2(_L("Connection to Ulogger: %d, attempt: 1"), result); if (result!=KErrNone) { INFO_PRINTF1(_L("Connection to Ulogger failed. Will try to connect max. 10 times")); for (TInt i=2; i<12;i++) { User::After(1000); result = logger.Connect(); INFO_PRINTF3(_L("Connection to Ulogger: %d, attempt: %d"), result, i); if (result==KErrNone) { break; } } } CClearConfig configIni; configIni.ClearL(logger); logger.SetSecondaryFilteringEnabled(EFalse);//C.A. previously:logger.DisableModuleUidFiltering(); // C.A. previously: /* TBufferMode bufferCircular = ECircular; TBufferMode bufferStraight = EStraight; TBufferMode getBuffer = ECircular; */ TInt bufferCircular = ECircular; TInt bufferStraight = EStraight; TInt getBuffer = ECircular; CArrayFixFlat<TUint8> *setprimfilter = new (ELeave)CArrayFixFlat<TUint8>(1); setprimfilter->AppendL(KGroupId); setprimfilter->AppendL((TGroupId) (192)); RArray<TUint32> setsecondfilter; setsecondfilter.Append((TUint32) KComponentId); logger.SetPrimaryFiltersEnabled(*setprimfilter,ETrue);//C.A. previously:logger.EnableClassifications(*setprimfilter); //logger.EnableModuleUids(setsecondfilter); SetBlockResult(EPass); if(result==0) { INFO_PRINTF1(_L("BTrace to File plugin added")); _LIT8(KTextmedia,"uloggerfileplugin"); const TPtrC8 mediaptr(KTextmedia); result=logger.ActivateOutputPlugin(mediaptr);//C.A. previously:Result=logger.SetActiveOutputPlugin(mediaptr); // write to a small circular buffer with a tight loop logger.SetBufferSize(4); logger.SetNotificationSize(3.9); result=logger.SetBufferMode(bufferCircular); if(result==KErrNone) { INFO_PRINTF1(_L("Buffer mode set without error")); logger.GetBufferMode(getBuffer); if(getBuffer==bufferCircular) INFO_PRINTF1(_L("Circular Buffer mode got correctly")); else { INFO_PRINTF1(_L("get buffer mode different from set circular - FAIL")); SetBlockResult(EFail); } } else { INFO_PRINTF2(_L("Buffer mode set failed with error %d"), result); SetBlockResult(EFail); } _LIT(KTextvalue1, "C:\\logs\\ULoggerBuffer4kDNS4kCircular.utf"); const TPtrC valueptr1(KTextvalue1); INFO_PRINTF3(_L("Writing to buffer... Buffer size: %d, DNS: %d"),4,4); writeToBuffer(valueptr1, Ost_Count, &logger); // write to a small straight buffer with a tight loop result=logger.SetBufferMode(bufferStraight); if(result==KErrNone) { INFO_PRINTF1(_L("Buffer mode set without error")); logger.GetBufferMode(getBuffer); if(getBuffer==bufferStraight) INFO_PRINTF1(_L("Straight Buffer mode got correctly")); else { INFO_PRINTF1(_L("get buffer mode different from set straight - FAIL")); SetBlockResult(EFail); } } else { INFO_PRINTF2(_L("Buffer mode set failed with error %d"), result); SetBlockResult(EFail); } _LIT(KTextvalue2, "C:\\logs\\ULoggerBuffer4kDNS4kStraight.utf"); const TPtrC valueptr2(KTextvalue2); INFO_PRINTF3(_L("Writing to buffer... Buffer size: %d, DNS: %d"),4,4); writeToBuffer(valueptr2, Ost_Count, &logger); // write to a large circular buffer with a tight loop logger.SetBufferSize(100); logger.SetNotificationSize(4); result=logger.SetBufferMode(bufferCircular); if(result==KErrNone) { INFO_PRINTF1(_L("Buffer mode set without error")); logger.GetBufferMode(getBuffer); if(getBuffer==bufferCircular) INFO_PRINTF1(_L("Circular Buffer mode got correctly")); else { INFO_PRINTF1(_L("get buffer mode different from set circular - FAIL")); SetBlockResult(EFail); } } else { INFO_PRINTF2(_L("Buffer mode set failed with error %d"), result); SetBlockResult(EFail); } _LIT(KTextvalue5, "C:\\logs\\ULoggerBuffer100kDNS4kCircular.utf"); const TPtrC valueptr5(KTextvalue5); INFO_PRINTF3(_L("Writing to buffer... Buffer size: %d, DNS: %d"),100,4); writeToBuffer(valueptr5, Ost_Count, &logger); // write to a large straight buffer with a tight loop result=logger.SetBufferMode(bufferStraight); if(result==KErrNone) { INFO_PRINTF1(_L("Buffer mode set without error")); logger.GetBufferMode(getBuffer); if(getBuffer==bufferStraight) INFO_PRINTF1(_L("Straight Buffer mode got correctly")); else { INFO_PRINTF1(_L("get buffer mode different from set Straight - FAIL")); SetBlockResult(EFail); } } else { INFO_PRINTF2(_L("Buffer mode set failed with error %d"), result); SetBlockResult(EFail); } _LIT(KTextvalue6, "C:\\logs\\ULoggerBuffer100kDNS4kStraight.utf"); const TPtrC valueptr6(KTextvalue6); INFO_PRINTF3(_L("Writing to buffer... Buffer size: %d, DNS: %d"),100,4); writeToBuffer(valueptr6, Ost_Count, &logger); } else { INFO_PRINTF1(_L("File Plugin error when added")); SetBlockResult(EFail); } logger.Close(); INFO_PRINTF1(_L("Buffer Mode tests complete!")); // ************** Block end **************** } return ETrue; }
TBool CTCMSerialPluginWrapper::DoCommandL( const TTEFFunction& /*aCommand*/, const TTEFSectionName& /*aSection*/, const TInt /*aAsyncErrorIndex*/) { if (BlockResult()==EPass) { // ************** Delete the Block, the block start **************** TInt Result=0; SetBlockResult(EPass); INFO_PRINTF1(_L("About to test serial plugin")); //Block start RULogger logger; Result = logger.Connect(); INFO_PRINTF2(_L("Connection to Ulogger: %d, attempt: 1"), Result); if (Result!=KErrNone) { INFO_PRINTF1(_L("Connection to Ulogger failed. Will try to connect max. 10 times")); for (TInt i=2; i<12;i++) { User::After(1000); Result = logger.Connect(); INFO_PRINTF3(_L("Connection to Ulogger: %d, attempt: %d"), Result, i); if (Result==KErrNone) { break; } } } CClearConfig configIni; configIni.ClearL(logger); CArrayFixFlat<TUint8> *setprimfilter = new (ELeave)CArrayFixFlat<TUint8>(1); setprimfilter->AppendL(KGroupId); RArray<TUint32> setsecondfilter; setsecondfilter.Append((TUint32) KComponentId); logger.SetPrimaryFiltersEnabled(*setprimfilter,ETrue);//C.A. previously:logger.EnableClassifications(*setprimfilter); logger.SetSecondaryFiltersEnabled(setsecondfilter,ETrue);//C.A. previously:logger.EnableModuleUids(setsecondfilter); _LIT8(KTextmedia,"uloggerserialplugin"); const TPtrC8 mediaptr(KTextmedia); // test the plugin can be activated Result=logger.ActivateOutputPlugin(mediaptr);//C.A. previously:Result=logger.SetActiveOutputPlugin(mediaptr); if(Result==0||Result==-11) { INFO_PRINTF1(_L("Serial Plugin active")); _LIT(KTextsetting, "output_port"); _LIT(KTextvalue, "3"); // test setting the plugin settings TPluginConfiguration pluginConfig; pluginConfig.SetKey(KTextsetting); pluginConfig.SetValue(KTextvalue); Result=logger.SetPluginConfigurations(mediaptr,pluginConfig); if(Result==KErrNone) { INFO_PRINTF1(_L("Setting Serial Plugin Settings returns KErrNone but verify set correctly in next step")); // test that the plugging settings can be retrieved RPointerArray<TPluginConfiguration> getPluginConfigs; if(Result==KErrNone) { INFO_PRINTF1(_L("Getting Serial Plugin Settings returns KErrNone but verify got correctly in next step")); Result=logger.GetPluginConfigurations(mediaptr, getPluginConfigs); _LIT(KTextChecksetting, "output_port"); _LIT(KTextCheckValue, "3"); // test that the plugging settings retrieved are correct if(getPluginConfigs.Count()>0) { if (!getPluginConfigs[0]->Key().Compare(KTextChecksetting) && !getPluginConfigs[0]->Value().Compare(KTextCheckValue)) { INFO_PRINTF1(_L("Retrieved serial plugin settings are correct")); } else { INFO_PRINTF1(_L("Retrieved serial plugin settings are incorrect")); SetBlockResult(EFail); } Result=logger.Start();//C.A. previously:Result=logger.StartOutputting(); INFO_PRINTF2(_L("ulogger start returns error %d"), Result); TBool OstStatus=0; #ifndef __WINSCW__ #ifdef TE_UPT_TRACE_ENABLED OstStatus = 1; INFO_PRINTF1(_L("TRACING HAS BEEN ENABLED!")); #else OstStatus = 0; INFO_PRINTF1(_L("TRACING HAS BEEN DISABLED! All Log files should be empty/not exist")); #endif // trace enabled TTraceContext attrs(KComponentId, KGroupId, KContextId, KPc); if(!OstTrace(attrs, KInitialClientFormat, KAny16)&&OstStatus) { INFO_PRINTF1(_L("Ost first trace via serial plugin failed")); SetBlockResult(EFail); } TTraceContext attrs1(KComponentId, KGroupId, KContextId, KPc); if(!OstTrace(attrs1, KInitialClientFormat, KAny16)&&OstStatus) { INFO_PRINTF1(_L("Ost second trace writing via serial plugin failed")); SetBlockResult(EFail); } #endif //winscw logger.Stop();//C.A. previously:logger.StopOutputting(); } else { INFO_PRINTF1(_L("Either SetPluginConfiguration failed or GetPluginConfiguration failed as returned a zero size array")); SetBlockResult(EFail); } } else { INFO_PRINTF1(_L("Failed to get serial Plugin Settings")); SetBlockResult(EFail); } getPluginConfigs.ResetAndDestroy(); } else { INFO_PRINTF1(_L("Serial Plugin Settings error")); SetBlockResult(EFail); } } else { INFO_PRINTF1(_L("Serial Plugin error when activated")); SetBlockResult(EFail); } TBuf8<32>activeplugins; _LIT8(KTextmedia1,"uloggerserialplugin"); TBuf8<32> checkplugins(KTextmedia1); // test the active plugin name can be retrieved logger.GetActiveOutputPlugin(activeplugins);//C.A. previously:logger.ActiveOutputPlugin(activeplugins); if (activeplugins.Compare(checkplugins)==0) INFO_PRINTF1(_L("Got correct active serial plugin")); else { INFO_PRINTF1(_L("Got incorrect active serial plugin")); SetBlockResult(EFail); } // test activating the second plugin _LIT8(KTextmedia2,"te_fileplugin"); const TPtrC8 mediaptr2(KTextmedia2); Result=logger.ActivateOutputPlugin(mediaptr2); //C.A. previously:Result=logger.SetActiveOutputPlugin(mediaptr2); if(Result==0) INFO_PRINTF1(_L("Second plugin activated correctly")); else { INFO_PRINTF1(_L("Second plugin activation error")); SetBlockResult(EFail); } // test the first plugin can now be removed as it is no longer the active plugin Result=logger.RemovePluginConfigurations(mediaptr); if(Result==0) { INFO_PRINTF1(_L("Removed serial Plugin correctly")); } else { INFO_PRINTF1(_L("Failed to remove serial Plugin")); SetBlockResult(EFail); } logger.Stop();//C.A. previously:logger.StopOutputting(); logger.Close(); INFO_PRINTF1(_L("serial plugin tests complete!")); // ************** Block end **************** } return ETrue; }
/** This user-side method configures the passed ULogger session to output to the passed plugin (with configurations) and with filter settings as specified by the user and starts the session in order to output trace points. @param aLogger is ULogger session being passed to the routine to be configured and started @param aPluginName is the TPtrC8 passed, identifying which ULogger plugin to output to @param aPluginConfiguration is the TPluginConfiguration passed, indicating the hardware configurations for the specified plugin @param aTestUTraceULoggerMatch is the user-defined boolean specifying whether the Ulogger filter settings should match the (test-specific) trace points or not @return KErrNone if command was prepared correctly and a system wide error code otherwise. */ TInt CUptULogger::StartGeneralL(RULogger& aLogger, const TPtrC8& aPluginName, const TPluginConfiguration& aPluginConfiguration, const TBool& aGroupIdFiltering, const TBool& aComponentIdFiltering, const TBool& aGroupIdFilterMatch, const TBool& aComponentIdFilterMatch) { TInt err=0; //connect to the ULogger session err=aLogger.Connect(); if (err!=KErrNone) { for (TInt i=2; i<12;i++) { User::After(1000); err = aLogger.Connect(); if (err==KErrNone) { break; } } } //clear any configurations stored in the ULogger configuration file CClearConfig configIni; configIni.ClearL(aLogger); //prepare arrays for storing the filter settings to configure ULogger (and push any heap objects on the cleanup stack) CArrayFixFlat<TUint8> *setPrimFilter = new (ELeave)CArrayFixFlat<TUint8>(256); CleanupStack::PushL(setPrimFilter); RArray<TUint32> setSecondFilter; CleanupClosePushL(setSecondFilter); //now configure the filtering and filter match options according to the passed parameters: //aGroupIdFiltering aComponentIdFiltering aGroupIdFilterMatch aComponentIdFilterMatch if(aGroupIdFiltering==1) { //We might have previously "disabled" primary filtering by enabling all filter //values, we'll disable them all here initially and then enable what we want below TInt i; for (i=0;i<=255;i++) { setPrimFilter->AppendL((TUint8)i); } TInt err=aLogger.SetPrimaryFiltersEnabled(*setPrimFilter,EFalse); setPrimFilter->Delete(0,setPrimFilter->Count()); } //C.A. previously this but done by default:err=aLogger.EnableGroupIdFiltering(); else //C.A. previously:err=aLogger.DisableClassificationFiltering(); //C.A.: just enable all classifications so all is allowed through { TInt i; for (i=0;i<=255;i++) { setPrimFilter->AppendL((TUint8)i); } TInt err=aLogger.SetPrimaryFiltersEnabled(*setPrimFilter,ETrue); setPrimFilter->Delete(0,setPrimFilter->Count()); } err=aLogger.SetSecondaryFilteringEnabled(aComponentIdFiltering); // C.A. previously /* if(aComponentIdFiltering==1) err=aLogger.EnableModuleUidFiltering(); else err=aLogger.DisableModuleUidFiltering();*/ if(aGroupIdFilterMatch==1) { //if the user specifies that ULogger should have classifiaction filter settings which match the test trace points, then fill the filter arrays with the test trace point identifiers accordingly SetFilterL(setPrimFilter); } else { //if the user specifies that ULogger should have classifciation filter settings which dont match the test trace points, then fill the filter arrays with the trace point identifiers which differ from the test trace point identifiers setPrimFilter->AppendL((TGroupId)(KGroupId+1)); } if(aComponentIdFilterMatch==1) { //if the user specifies that ULogger should have module id filter settings which match the test trace points, then fill the filter arrays with the test trace point identifiers accordingly setSecondFilter.Append((TComponentId) KComponentId); } else { //if the user specifies that ULogger should have module id settings which dont match the test trace points, then fill the filter arrays with the trace point identifiers which differ from the test trace point identifiers setSecondFilter.Append((TComponentId) (KComponentId+1)); } //set the filter settings in ULogger according to the above defined filter arrays err=aLogger.SetPrimaryFiltersEnabled(*setPrimFilter,ETrue);//C.A. previously:err=aLogger.EnableClassifications(*setPrimFilter); if(err==0) err=aLogger.SetSecondaryFiltersEnabled(setSecondFilter,ETrue);//C.A. previously:err=aLogger.EnableModuleUids(setSecondFilter); if(err==0) { //now set the ULogger session to output to the specified plugin and configuration err=aLogger.ActivateOutputPlugin(aPluginName);//C.A. previously:err=aLogger.SetActiveOutputPlugin(aPluginName); if((err == KErrNone)/*Added*/||(err == KErrAlreadyExists))//C.A. have to add cuz old api returns -11 if plugin already activated { err=aLogger.SetPluginConfigurations(aPluginName, aPluginConfiguration); if(err==0) { //given the ULogger session has successfully been configured to output to the default file, start the session err=aLogger.Start();//C.A. previously:err=aLogger.StartOutputting(); } } } //cleanup any heap objects CleanupStack::PopAndDestroy(&setSecondFilter); CleanupStack::PopAndDestroy(setPrimFilter); return err; }
// ----------------------------------------------------------------------------- // SetInfoPopupWindowLayoutL // // ----------------------------------------------------------------------------- // void CAknInfoPopupNote::SetInfoPopupWindowLayoutL() { // Get parameter and table limits for popup preview text window TAknLayoutScalableParameterLimits limits = AknLayoutScalable_Avkon::popup_preview_text_window_ParamLimits(); TAknLayoutScalableTableLimits tableLimits = AknLayoutScalable_Avkon::popup_preview_text_window_t_Limits(); // Get layout rects TRect rectScreen = iAvkonAppUi->ApplicationRect(); TInt mainPaneVariety = Layout_Meta_Data::IsLandscapeOrientation() ? 4 : 1; TRect rectMainPane = RectFromLayout( rectScreen, AknLayoutScalable_Avkon::main_pane( mainPaneVariety ) ); // Use first variety to be able to get the font for text parsing TInt firstVariety = SelectWindowVariety( 1, limits ); TRect rectPopupWindow = RectFromLayout( rectMainPane, AknLayoutScalable_Avkon::popup_preview_text_window( firstVariety ) ); TInt firstIndex = tableLimits.FirstIndex(); TInt firstLineVariety = AknLayoutScalable_Avkon:: popup_preview_text_window_t_ParamLimits( firstIndex ).FirstVariety(); TAknTextLineLayout popupTextLayout = AknLayoutScalable_Avkon::popup_preview_text_window_t( firstIndex, firstLineVariety ); TAknLayoutText layoutText; layoutText.LayoutText( rectPopupWindow, popupTextLayout ); TRect rectText = layoutText.TextRect(); // Prepare text parsing const CFont *font = layoutText.Font(); CArrayFixFlat<TInt>* lineWidths = new ( ELeave ) CArrayFixFlat<TInt>( KMaxNumOfLines ); CleanupStack::PushL( lineWidths ); for ( TInt i = 0; i < KMaxNumOfLines; i++ ) { lineWidths->AppendL( rectText.Width() ); } // Parse text iText->ParseTextL( font, lineWidths ); TInt numberOfLines = iText->NumberOfLines(); CleanupStack::PopAndDestroy( lineWidths ); // Select the variety index depending on the number of lines TInt windowVariety = SelectWindowVariety( numberOfLines, limits ); // Set layouts for window and text lines AknLayoutUtils::LayoutControl( this, rectMainPane, AknLayoutScalable_Avkon::popup_preview_text_window( windowVariety ) ); rectPopupWindow = Rect(); iText->SetRect( rectPopupWindow ); for ( TInt lineIndex = tableLimits.FirstIndex(), ii = 0; ( lineIndex <= tableLimits.LastIndex() ) && ( ii < numberOfLines ); ++lineIndex, ++ii ) { // Select the variety index depending on the number of lines TInt lineVariety = SelectLineVariety( numberOfLines, AknLayoutScalable_Avkon::popup_preview_text_window_t_ParamLimits( lineIndex ) ); popupTextLayout = AknLayoutScalable_Avkon::popup_preview_text_window_t( lineIndex, lineVariety ); AknLayoutUtils::LayoutLabel( iText->Line( ii ), rectPopupWindow, popupTextLayout, font ); } // Override text color TRgb textColor = KRgbBlack; AknsUtils::GetCachedColor( AknsUtils::SkinInstance(), textColor, KAknsIIDQsnTextColors, EAknsCIQsnTextColorsCG55 ); AknLayoutUtils::OverrideControlColorL( *iText, EColorLabelText, textColor ); // Move pop-up note to right location if ( IsVisible() ) { Relocate(); } }
// ----------------------------------------------------------------------------- // SetTooltipWindowLayoutL // // ----------------------------------------------------------------------------- // void CAknInfoPopupNote::SetTooltipWindowLayoutL() { // Get parameter and table limits for popup preview text window TAknLayoutScalableParameterLimits limits = AknLayoutScalable_Avkon::popup_preview_text_window_ParamLimits(); TAknLayoutScalableTableLimits tableLimits = AknLayoutScalable_Avkon::popup_preview_text_window_t_Limits(); // Get layout rects const TRect rectScreen = iAvkonAppUi->ApplicationRect(); const TRect rectMainPane = rectScreen; // Set pop-up to contain only one line of text const TInt numberOfLines = 1; TInt windowVariety = SelectWindowVariety( numberOfLines, limits ); TInt lineVariety = SelectLineVariety( numberOfLines, AknLayoutScalable_Avkon:: popup_preview_text_window_t_ParamLimits( tableLimits.FirstIndex() ) ); // Get the font for the text TRect rectPopupWindow = RectFromLayout( rectMainPane, AknLayoutScalable_Avkon::popup_preview_text_window( windowVariety ) ); TAknTextComponentLayout popupTextLayout = AknLayoutScalable_Avkon::popup_preview_text_window_t( tableLimits.FirstIndex(), lineVariety ); TAknLayoutText layoutText; layoutText.LayoutText( rectPopupWindow, popupTextLayout ); const CFont *font = layoutText.Font(); TInt maxLineWidth = ( rectMainPane.Width() - popupTextLayout.l() ) - popupTextLayout.r(); TInt textWidth = font->TextWidthInPixels( iText->Text() ); textWidth = Min( textWidth, maxLineWidth ); // Parse text CArrayFixFlat<TInt>* lineWidths = new ( ELeave ) CArrayFixFlat<TInt>( numberOfLines ); CleanupStack::PushL( lineWidths ); lineWidths->AppendL( textWidth ); iText->ParseTextL( font, lineWidths ); CleanupStack::PopAndDestroy( lineWidths ); // Set layout for window rectPopupWindow = RectFromLayout( rectMainPane, AknLayoutScalable_Avkon::popup_preview_text_window( windowVariety ) ); // Adjust window size depending on text length SetSize( TSize( textWidth + popupTextLayout.l() + popupTextLayout.r(), rectPopupWindow.Height() ) ); // Set layout for text lines rectPopupWindow = Rect(); iText->SetRect( rectPopupWindow ); for ( TInt lineIndex = tableLimits.FirstIndex(), ii = 0; ( lineIndex <= tableLimits.LastIndex() ) && ( ii < numberOfLines ); ++lineIndex, ++ii ) { popupTextLayout = AknLayoutScalable_Avkon::popup_preview_text_window_t( lineIndex, lineVariety ); AknLayoutUtils::LayoutLabel( iText->Line( ii ), rectPopupWindow, popupTextLayout, font ); } // Override text color TRgb textColor = KRgbBlack; AknsUtils::GetCachedColor( AknsUtils::SkinInstance(), textColor, KAknsIIDQsnTextColors, EAknsCIQsnTextColorsCG55 ); AknLayoutUtils::OverrideControlColorL( *iText, EColorLabelText, textColor ); // Move tooltip to right location if ( IsVisible() ) { Relocate(); } }
QT_BEGIN_NAMESPACE QColor launchSymbianColorDialog(QColor initial) { QColor currentColor = QColor::Invalid; #ifdef Q_WS_S60 QT_TRAP_THROWING( CArrayFixFlat<TRgb>* array = new( ELeave ) CArrayFixFlat<TRgb>(17); CleanupStack::PushL(array); array->AppendL(KRgbBlack); array->AppendL(KRgbDarkGray); array->AppendL(KRgbDarkRed); array->AppendL(KRgbDarkGreen); array->AppendL(KRgbDarkYellow); array->AppendL(KRgbDarkBlue); array->AppendL(KRgbDarkMagenta); array->AppendL(KRgbDarkCyan); array->AppendL(KRgbRed); array->AppendL(KRgbGreen); array->AppendL(KRgbYellow); array->AppendL(KRgbBlue); array->AppendL(KRgbMagenta); array->AppendL(KRgbCyan); array->AppendL(KRgbGray); array->AppendL(KRgbWhite); TRgb initialColour(initial.red(), initial.green(), initial.blue(), initial.alpha()); TBool noneChosen = EFalse; // If true shows the default colour button CAknColourSelectionGrid* colourSelectionGrid = CAknColourSelectionGrid::NewL(array, EFalse, noneChosen, initialColour); CleanupStack::PushL(colourSelectionGrid); if (colourSelectionGrid->ExecuteLD()) { currentColor.setRgb(initialColour.Red(), initialColour.Green(), initialColour.Blue(), initialColour.Alpha()); } CleanupStack::Pop(colourSelectionGrid); CleanupStack::PopAndDestroy(array); );
/** Persist the items belonging to curent group into group table @param aGroup referece to a contact group */ void CPplGroupsTable::WriteGroupMembersL(const CContactItem& aGroup) { if (aGroup.Type() != KUidContactGroup) { return; } const TContactItemId KGroupId(aGroup.Id() ); // make sure we clear out any previous, out-of-date data TBool lowDiskErr(EFalse); DeleteItemL(KGroupId, lowDiskErr); if (lowDiskErr) { User::Leave(KErrDiskFull); } // build the RSqlStatement RSqlStatement stmnt; CleanupClosePushL(stmnt); stmnt.PrepareL(iDatabase, iInsertStmnt->SqlStringL() ); const TInt KGroupIdIndex(KFirstIndex); // first parameter in query... const TInt KMemberIdIndex(KGroupIdIndex + 1); // ...and the second parameter // copy and sort the member id array so we can see if there are duplicates const CContactIdArray* contactIdArray = static_cast<const CContactGroup&>(aGroup).ItemsContained(); //does not take the ownership const TInt arrayCount = contactIdArray->Count(); CArrayFixFlat<TContactItemId>* sortedList = new(ELeave) CArrayFixFlat<TContactItemId>(KArrayGranularity); CleanupStack::PushL(sortedList); for(TInt loop = 0;loop < arrayCount; ++loop) { sortedList->AppendL((*contactIdArray)[loop]); } TKeyArrayFix key(0,ECmpTInt); sortedList->Sort(key); // insert the group-member relationships const TInt KCountStmntParamIndex(KFirstIndex); // first and only parameter in query const TInt listLen(sortedList->Count() ); TInt lastId(0); for (TInt i = 0; i < listLen; ++i) { TInt itemId((*sortedList)[i]); //check if a contact item with itemId id really exists in contact database RSqlStatement countStmnt; CleanupClosePushL(countStmnt); countStmnt.PrepareL(iDatabase, iCountContactsStmnt->SqlStringL() ); User::LeaveIfError(countStmnt.BindInt(KCountStmntParamIndex, itemId) ); TInt count = 0; TInt err = KErrNone; if((err = countStmnt.Next() ) == KSqlAtRow) { count = countStmnt.ColumnInt(iCountContactsStmnt->ParameterIndex(KSqlCount) ); } else { User::LeaveIfError(err); } if(count == 0) { User::Leave(KErrNotFound); } CleanupStack::PopAndDestroy(&countStmnt); // only insert this if we haven't already seen it if (itemId != lastId || i == 0) { User::LeaveIfError(stmnt.BindInt(KGroupIdIndex, KGroupId) ); User::LeaveIfError(stmnt.BindInt(KMemberIdIndex, itemId) ); User::LeaveIfError(stmnt.Exec() ); User::LeaveIfError(stmnt.Reset() ); } lastId = itemId; } CleanupStack::PopAndDestroy(2, &stmnt); // and sortedList }
TInt CTelephonyFunctions::GetCallInfoL(TDes8& aCallSelect, TDes8& aCallInfo, TDes8& aRemoteInfo) /** Get the current call information. */ { CTelephony::TCallSelectionV1& CallSelectionV1 = reinterpret_cast<CTelephony::TCallSelectionV1&> ( const_cast<TUint8&> ( *aCallSelect.Ptr() ) ); if(CallSelectionV1.iLine != CTelephony::EVoiceLine) { return KErrAccessDenied; } if(IsFlightModeOn()) { return KErrAccessDenied; } CTelephony::TCallInfoV1& CallInfoV1 = reinterpret_cast<CTelephony::TCallInfoV1&> ( const_cast<TUint8&> ( *aCallInfo.Ptr() ) ); CTelephony::TRemotePartyInfoV1& RemotePartyInfoV1 = reinterpret_cast<CTelephony::TRemotePartyInfoV1&> ( const_cast<TUint8&> ( *aRemoteInfo.Ptr() ) ); TPtr8* callInfoPkgPtr; RMobileCall::TMobileCallInfoV1* callInfoObjPtr; if(iTsyVersion == KNoMultimodeTsy) { return KErrNotSupported; } else if(iTsyVersion==KETelExtMultimodeV1 || iTsyVersion==KETelExtMultimodeV2) { RMobileCall::TMobileCallInfoV1* callInfoV1 = new(ELeave) RMobileCall::TMobileCallInfoV1; CleanupStack::PushL(callInfoV1); RMobileCall::TMobileCallInfoV1Pckg* callInfoV1Pckg = new(ELeave) RMobileCall::TMobileCallInfoV1Pckg(*callInfoV1); CleanupStack::PushL(callInfoV1Pckg); callInfoPkgPtr = callInfoV1Pckg; callInfoObjPtr = callInfoV1; } else //TSY v3 { RMobileCall::TMobileCallInfoV3* callInfoV3 = new(ELeave) RMobileCall::TMobileCallInfoV3; CleanupStack::PushL(callInfoV3); RMobileCall::TMobileCallInfoV3Pckg* callInfoV3Pckg = new(ELeave) RMobileCall::TMobileCallInfoV3Pckg(*callInfoV3); CleanupStack::PushL(callInfoV3Pckg); callInfoPkgPtr = callInfoV3Pckg; callInfoObjPtr = callInfoV3; } TInt numOfCalls=0; User::LeaveIfError(iLineVoice.EnumerateCall(numOfCalls)); if (numOfCalls==0) { User::Leave(KErrNotFound); } CArrayFixFlat<RMobileCall>* tempCallArray = new (ELeave) CArrayFixFlat<RMobileCall>(numOfCalls); CleanupStack::PushL(TCleanupItem(CloseArrayOfCallObjects, tempCallArray)); TInt i; RLine::TCallInfo callinfo; RMobileCall::TMobileCallStatus callStatus; TBool callFound=EFalse; for(i=0; i<numOfCalls; i++) { User::LeaveIfError(iLineVoice.GetCallInfo(i,callinfo)); RMobileCall tempCall; tempCallArray->AppendL(tempCall); User::LeaveIfError(tempCallArray->At(i).OpenExistingCall(iLineVoice,callinfo.iCallName)); User::LeaveIfError(tempCallArray->At(i).GetMobileCallStatus(callStatus)); if((callStatus==RMobileCall::EStatusConnected) && (CallSelectionV1.iSelect==CTelephony::EActiveCall)) { User::LeaveIfError(tempCallArray->At(i).GetMobileCallInfo(*callInfoPkgPtr)); callFound=ETrue; break; } else if((callStatus==RMobileCall::EStatusHold) && (CallSelectionV1.iSelect==CTelephony::EHeldCall)) { User::LeaveIfError(tempCallArray->At(i).GetMobileCallInfo(*callInfoPkgPtr)); callFound=ETrue; break; } else if(((callStatus==RMobileCall::EStatusDialling) || (callStatus==RMobileCall::EStatusRinging) || (callStatus==RMobileCall::EStatusAnswering) || (callStatus==RMobileCall::EStatusConnecting) || (callStatus==RMobileCall::EStatusReconnectPending) || (callStatus==RMobileCall::EStatusDisconnecting) || (callStatus==RMobileCall::EStatusDisconnectingWithInband) || (callStatus==RMobileCall::EStatusTransferring) || (callStatus==RMobileCall:: EStatusTransferAlerting) ) && (CallSelectionV1.iSelect==CTelephony::EInProgressCall)) { User::LeaveIfError(tempCallArray->At(i).GetMobileCallInfo(*callInfoPkgPtr)); callFound=ETrue; break; } } CleanupStack::PopAndDestroy(tempCallArray); //tempCallArray if(!callFound) { CleanupStack::PopAndDestroy(2); //(callInfoV1Pckg or callInfoV3Pckg) AND (callInfoV1 or callInfoV3) return KErrNotFound; } GetCallStatus(callInfoObjPtr->iStatus, CallInfoV1.iStatus); if (callInfoObjPtr->iValid & RMobileCall::KCallSecurity) { if(callInfoObjPtr->ExtensionId() == KETelExtMultimodeV3) { RMobileCall::TMobileCallInfoV3* callInfoV3Ptr = reinterpret_cast<RMobileCall::TMobileCallInfoV3*>(callInfoObjPtr); switch(callInfoV3Ptr->iSecurity) { case RMobilePhone::ECipheringGSM: CallInfoV1.iSecurity = CTelephony::ECipheringGSM; break; case RMobilePhone::ECipheringWCDMA: CallInfoV1.iSecurity = CTelephony::ECipheringWCDMA; break; case RMobilePhone::ECipheringOff: default: CallInfoV1.iSecurity = CTelephony::ECipheringOff; break; } } else CallInfoV1.iSecurity = CTelephony::ECipheringOff; } else { CallInfoV1.iSecurity = CTelephony::TPhoneNetworkSecurity(); } if (callInfoObjPtr->iValid & RMobileCall::KCallStartTime) { CallInfoV1.iStartTime = callInfoObjPtr->iStartTime; } else { CallInfoV1.iStartTime = TDateTime(); } if (callInfoObjPtr->iValid & RMobileCall::KCallDuration) { CallInfoV1.iDuration = callInfoObjPtr->iDuration; } else { CallInfoV1.iDuration = 0; } if (callInfoObjPtr->iValid & RMobileCall::KCallExitCode) { CallInfoV1.iExitCode = callInfoObjPtr->iExitCode; } else { CallInfoV1.iExitCode = 0; } if (callInfoObjPtr->iValid & RMobileCall::KCallDialledParty) { CopyTelAddress(callInfoObjPtr->iDialledParty, CallInfoV1.iDialledParty); } else { CallInfoV1.iDialledParty = CTelephony::TTelAddress(); } //see whether we have an existing handle on the call CallInfoV1.iCallId = -1; RMobileCall* poolCall=NULL; RMobileCall::TMobileCallInfoV1 poolCallInfoV1; RMobileCall::TMobileCallInfoV1Pckg poolCallInfoV1Pckg(poolCallInfoV1); TInt err; for(int k=0;k<CTelephony::EISVMaxNumOfCalls;k++) { //get RMobileCall object if((poolCall = Call((CTelephony::TCallId)k)) != NULL) { //get call name err = poolCall->GetMobileCallInfo(poolCallInfoV1Pckg); if(err ==KErrNone) { //compare call names if(poolCallInfoV1.iCallName.MatchF(callinfo.iCallName)==0) { CallInfoV1.iCallId = k; break; } } } } //fill TRemotePartyInfoV1 RMobileCall::TMobileCallRemotePartyInfoV1& mobileRemoteParty = callInfoObjPtr->iRemoteParty; switch(mobileRemoteParty.iRemoteIdStatus) { case RMobileCall::ERemoteIdentityAvailable: RemotePartyInfoV1.iRemoteIdStatus = CTelephony::ERemoteIdentityAvailable; break; case RMobileCall::ERemoteIdentitySuppressed: RemotePartyInfoV1.iRemoteIdStatus = CTelephony::ERemoteIdentitySuppressed; break; case RMobileCall::ERemoteIdentityUnknown: default: RemotePartyInfoV1.iRemoteIdStatus = CTelephony::ERemoteIdentityUnknown; break; } RemotePartyInfoV1.iCallingName.Copy(mobileRemoteParty.iCallingName); CopyTelAddress(mobileRemoteParty.iRemoteNumber, RemotePartyInfoV1.iRemoteNumber); switch(mobileRemoteParty.iDirection) { case RMobileCall::EMobileOriginated: RemotePartyInfoV1.iDirection = CTelephony::EMobileOriginated; break; case RMobileCall::EMobileTerminated: RemotePartyInfoV1.iDirection = CTelephony::EMobileTerminated; break; case RMobileCall::EDirectionUnknown: default: RemotePartyInfoV1.iDirection = CTelephony::EDirectionUnknown; break; } CleanupStack::PopAndDestroy(2); //(callInfoV1Pckg or callInfoV3Pckg) AND (callInfoV1 or callInfoV3) return KErrNone; }
/* ----------------------------------------------------------------------------- ----------------------------------------------------------------------------- */ TBool CMainContainer::HandlePopUpMenuSelectionL(TInt& aCommand) { TBool ret(EFalse); TBool isEnable(EFalse),isDisable(EFalse),isRemove(EFalse),isaPreview(EFalse); ShowMenuItemsL(isEnable,isDisable,isRemove,isaPreview); if(!isRemove && !isaPreview){ ret = ETrue; aCommand = EProfModify; }else{ TBuf<100> hjelpper; CAknSinglePopupMenuStyleListBox* list = new(ELeave) CAknSinglePopupMenuStyleListBox; CleanupStack::PushL(list); CAknPopupList* popupList = CAknPopupList::NewL(list,R_AVKON_SOFTKEYS_OK_CANCEL); CleanupStack::PushL(popupList); list->ConstructL(popupList, CEikListBox::ELeftDownInViewRect); list->CreateScrollBarFrameL(ETrue); list->ScrollBarFrame()->SetScrollBarVisibilityL(CEikScrollBarFrame::EOff,CEikScrollBarFrame::EAuto); CArrayFixFlat<TInt>* cmdArray = new (ELeave) CArrayFixFlat<TInt>(5); CleanupStack::PushL(cmdArray); CDesCArrayFlat* Array = new (ELeave) CDesCArrayFlat(5); CleanupStack::PushL(Array); if(isEnable){ StringLoader::Load(hjelpper,R_CMD_ENABLE); Array->AppendL(hjelpper); cmdArray->AppendL(EProfEnable); }else if(isDisable){ StringLoader::Load(hjelpper,R_CMD_DISABLE); Array->AppendL(hjelpper); cmdArray->AppendL(EProfDisable); } if(isaPreview && !iDimPreview){ StringLoader::Load(hjelpper,R_CMD_MODIFY); Array->AppendL(hjelpper); cmdArray->AppendL(EProfModify); StringLoader::Load(hjelpper,R_CMD_PREVIEW); Array->AppendL(hjelpper); cmdArray->AppendL(EProfTest); } if(isRemove){ StringLoader::Load(hjelpper,R_CMD_DELETE); Array->AppendL(hjelpper); cmdArray->AppendL(EProfRemove); } list->Model()->SetItemTextArray(Array); CleanupStack::Pop();//Array list->Model()->SetOwnershipType(ELbmOwnsItemArray); if (popupList->ExecuteLD()) { TInt Selected = list->CurrentItemIndex(); if(Selected >= 0 && Selected < cmdArray->Count()) { ret = ETrue; aCommand = cmdArray->At(Selected); } } CleanupStack::PopAndDestroy(1); // cmdArray CleanupStack::Pop(); // popuplist CleanupStack::PopAndDestroy(1); // list } return ret; }
void CVoIPForm::ProcessCommandL(TInt aCommandId) { CAknForm::ProcessCommandL(aCommandId); switch (aCommandId) { case EVoIPEditMenuItemCommand: { CAknForm::ProcessCommandL(EAknFormCmdEdit); break; } case EVoIPAddMenuItemCommand: { CAknForm::ProcessCommandL(EAknFormCmdAdd); CVoIPAppUi* iAppUi = static_cast<CVoIPAppUi*> (iEikonEnv->EikAppUi()); const CPbkFieldsInfo& fieldsInfo = iAppUi->GetPhoneBook()->GetFieldsInfo(); const TInt count = fieldsInfo.Count(); CDesCArray* list = new (ELeave) CDesCArrayFlat(count); CleanupStack::PushL(list); CArrayFixFlat<TInt>* correspondence = new (ELeave) CArrayFixFlat< TInt> (count); CleanupStack::PushL(correspondence); for (TInt i = 0; i < count; ++i) { CPbkFieldInfo* fieldInfo = fieldsInfo[i]; const TDesC* fieldName = &(fieldInfo->FieldName()); if (fieldName->Length() > 0) { _LIT(KFormat, "\t%S"); TBuf<256> fieldStr; fieldStr.Format(KFormat, fieldName); list->AppendL(fieldStr); correspondence->AppendL(i); } } TInt selectedIndex; CAknSelectionListDialog* dialog = CAknSelectionListDialog::NewL( selectedIndex, list, 0); if (dialog->ExecuteLD(R_LIST_DIALOG)) { CPbkFieldInfo* fieldInfo = fieldsInfo[(*correspondence)[selectedIndex]]; const TDesC& fieldName = fieldInfo->FieldName(); TInt id = fieldInfo->FieldId(); TInt pageId = ActivePageId(); TAny* unused = 0; if (fieldInfo->EditMode() == EPbkFieldEditModeAlpha) { TInt type = EEikCtEdwin; CEikEdwin* editor = (CEikEdwin*) CreateLineByTypeL( fieldName, pageId, id, type, unused); editor->ConstructL(EEikEdwinNoHorizScrolling | EEikEdwinResizable, 10, 100, 1); } else if (fieldInfo->EditMode() == EPbkFieldEditModeNumeric) { TInt type = EEikCtEdwin; CEikEdwin* editor = (CEikEdwin*) CreateLineByTypeL( fieldName, pageId, id, type, unused); editor->SetAknEditorInputMode(EAknEditorNumericInputMode); editor->SetAknEditorAllowedInputModes( EAknEditorNumericInputMode); editor->ConstructL(EEikEdwinNoHorizScrolling | EEikEdwinResizable, 10, 100, 1); } else if (fieldInfo->EditMode() == EPbkFieldEditModeDate) { TInt type = EEikCtDateEditor; CEikDateEditor* editor = (CEikDateEditor*) CreateLineByTypeL(fieldName, pageId, id, type, unused); editor->ConstructL(TTime(mindateTime), TTime(maxdateTime), TTime(nowdateTime), ETrue); } Line(id)->ActivateL(); SetChangesPending(ETrue); UpdatePageL(ETrue); } CleanupStack::PopAndDestroy(2); // list, correspondence break; } default: { CVoIPAppUi* iAppUi = static_cast<CVoIPAppUi*> (iEikonEnv->EikAppUi()); CVoIPListBoxView* iView = static_cast<CVoIPListBoxView*> (iAppUi->View(TUid::Uid( EVoIPListBoxViewId))); iView->HandleCommandL(aCommandId); break; } } }
void CLinePaginatorTest::StorePageBreakL(TInt aDocPos) { iNumPages++; iTestChars->AppendL(aDocPos); }