C++ CArrayFix::At方法代码示例

// -----------------------------------------------------------------------------
// CPIMEventPropertyConverter::ConvertExceptionDatesL
// Inserts exceptiondates to a parser.
// -----------------------------------------------------------------------------
//
void CPIMEventPropertyConverter::ConvertExceptionDatesL(const CArrayFix<
        TPIMDate>& aDates, CParserVCalEntity& aParser)
{
    JELOG2(EPim);
    TInt exDateCount = aDates.Count();
    if (exDateCount > 0)
    {
        CArrayPtrFlat<TVersitDateTime>* versitExDates =
            new(ELeave) CArrayPtrFlat<TVersitDateTime> (exDateCount);
        CleanupStack::PushL(versitExDates);
        CleanupResetAndDestroyPushL(*versitExDates);
        for (TInt i = 0; i < exDateCount; i++)
        {
            TVersitDateTime
            * versitDateTime =
                new(ELeave) TVersitDateTime(aDates.At(i).DateTime(), TVersitDateTime::EIsUTC);
            CleanupDeletePushL(versitDateTime);
            versitExDates->AppendL(versitDateTime);
            CleanupStack::Pop(versitDateTime); // versitDateTime
        }
        CParserPropertyValue* propertyValue =
            new(ELeave) CParserPropertyValueMultiDateTime(versitExDates);
        CleanupStack::Pop(2); // versitExDates is now owned by propertyValue
        AddPropertyToParserL(propertyValue, KVersitTokenEXDATE(), aParser);
        // Needed cleanup stack items are popped out in the AddPropretyToParserL
    }
}

EXPORT_C TBool AknPhoneNumberTextUtils::WrapPhoneNumberToArrayL( 
    const TDesC& aPhoneNumberToWrap,
    TInt aLineWidthInPixels,
    TInt aMaxLines,
    const CFont& aFont,
    CArrayFix<TPtrC>& aWrappedArray )
    {
    TBool retVal( EFalse ); // Not truncated
 
    HBufC* reversedText = aPhoneNumberToWrap.AllocLC();
    TPtr revPtr = reversedText->Des();

    ReverseDescriptor( revPtr );

    CArrayFix<TInt>* lineWidthArray = new (ELeave) CArrayFixFlat<TInt>(KLineArrayGranularity);
    CleanupStack::PushL( lineWidthArray );

    lineWidthArray->AppendL( aLineWidthInPixels, aMaxLines );

    // Perform the wrap on the reversed text
    AknTextUtils::WrapToArrayL( revPtr, *lineWidthArray, aFont, aWrappedArray );

    // Now rearrange the TPtrCs to point to the original array
    TInt totalLen = reversedText->Length();
    TInt count = aWrappedArray.Count();
    TInt usedLen = 0; // Accumulates the length actually used
    for ( TInt index = 0; index < count; index++)
        {
        TPtrC& currentPtr = aWrappedArray.At(index);
        // The TPtrCs have to be moved. The reversing is taken into effect, but not purely reversed
        // because their otherwise they would have negative lengths.  That is, {a,b} does not go to
        // { final - a, final - b }, but rather to {final - b, final - a}; they are flipped, to get
        // their start points before the end points
        //
        // Now, representing the start position by pos, and the end by pos+len-1 we have the TPtrC at
        // {pos, pos+len-1} inclusive, in reversed array. 
        // The TPtrC must be modified to point to {total_len-1 - (pos+len-1), total_len-1 - pos} 
        // in the unreversed array:
        TInt len = currentPtr.Length();
        usedLen += len;
        TInt pos = currentPtr.Ptr() - reversedText->Ptr(); // pointer arithmetic
        TInt newPos = totalLen - pos - len;
        // If the TPtr is zero length then it must get special treatment, as the normal
        // calculations give an end point before the start point! i.e. {pos, pos-1}
        // We handle this by NOT flipping in this case.
        // { pos, pos-1 } -> {totalLen-1-pos, totalLen-1 - (pos-1)}
        // Note that a zero length wrapped line is completely possible amoung a bunch of other 
        // lines with characters on them, as the line lengths may be of wildly different lengths.
        if ( len == 0 ) 
            newPos--;
        currentPtr.Set( aPhoneNumberToWrap.Mid(newPos, len) );
        }

    // If the accumulated length is less than that in the entire input descriptor, then text does not fit
    if ( usedLen < totalLen )
        retVal = ETrue;

    CleanupStack::PopAndDestroy(2); // lineWidthArray first, and then reversedText
    return retVal;
    }

// -----------------------------------------------------------------------------
// CPIMAgnToDoAdapter::ExportItemL
// (other items were commented in a header)
// -----------------------------------------------------------------------------
//
void CPIMAgnToDoAdapter::ExportItemL(const MPIMToDoItem& aItem,
                                     CCalEntry& aEntry, TBool aResetEntry)
{
    JELOG2(EPim);
    if (aResetEntry)
    {
        // Reset native entry for exporting new data
        aEntry.SetSummaryL(KNullDesC());
        aEntry.SetDescriptionL(KNullDesC());
        aEntry.SetPriorityL(0);
        aEntry.SetCompletedL(EFalse, aEntry.CompletedTimeL());
    }

    // Export item data to the native ToDo calendar entry
    const MPIMItemData& itemData = aItem.ItemData();
    CArrayFix<TPIMField>* fields = itemData.FieldsLC();

    // Add default values to the calendar entry
    AddDefaultValuesToEntryL(itemData, aEntry);

    // Convert each field to the native ToDo calendar entry
    TInt count = fields->Count();
    for (TInt i = 0; i < count; i++)
    {
        TPIMToDoField field = static_cast<TPIMToDoField>(fields->At(i));
        ConvertToAgnL(field, aEntry, itemData);
    }
    CleanupStack::PopAndDestroy(fields);
}

/**
 * Set text and font into labels.
 *
 * SetBufferReserveLengthL causes a reallocation but this should never
 * be called unless somebody decides to change the font after the label
 * has been created and with this new font you can fit more characters 
 * in the same width

 */
void CAknTextControl::SetWrappedTextIntoLabelsL(const CArrayFix<TPtrC>& aWrappedArray, TInt aNumLines, const CFont* aFont)
	{
	__ASSERT_DEBUG(aNumLines == iNumberOfLines, Panic(EAknPanicSelfCheckFailure));

	for (TInt i=0; i < iNumberOfLines; i++)
		{
		
		if (Line(i)->BufferReserveLength() < aWrappedArray.At(i).Length())
			Line(i)->SetBufferReserveLengthL(aWrappedArray.At(i).Length());

		if (*(Line(i)->Text()) != aWrappedArray.At(i) )
			{
			Line(i)->SetTextL(aWrappedArray.At(i));
			Line(i)->SetFont(aFont);
			iLines[i]->iModified = ETrue;
			}
		}
	}

// -----------------------------------------------------------------------------
// CPIMAgnEventAdapter::ConvertFieldsToAgnL
// Reads PIM Item fields and converts them into Agenda entry's fields.
// -----------------------------------------------------------------------------
//
void CPIMAgnEventAdapter::ConvertFieldsToAgnL(const MPIMEventItem& aItem,
        CCalEntry& aEntry)
{
    JELOG2(EPim);
    CArrayFix<TPIMField>* fields = aItem.ItemData().FieldsLC();
    TInt amount = fields->Count();

    for (int i = 0; i < amount; i++)
    {
        TPIMEventField field = static_cast<TPIMEventField>(fields->At(i));
        switch (field)
        {
        case EPIMEventSummary: // Fallthrough
        case EPIMEventLocation: // Fallthrough
        case EPIMEventNote:
        {
            ConvertStringFieldToAgnL(aItem, aEntry, field);
            break;
        }
        case EPIMEventAlarm:
        {
            ConvertAlarmToAgnL(aItem, aEntry);
            break;
        }
        case EPIMEventStart: // Fallthrough
        case EPIMEventEnd:
        {
            ConvertDateFieldToAgnL(aItem, aEntry, field);
            break;
        }
        case EPIMEventClass:
        {
            ConvertClassToAgnL(aItem, aEntry);
            break;
        }
        case EPIMEventRevision: // fallthrough
        case EPIMEventUid:
        {
            // nothing
            break;
        }
        default:
        {
            User::Leave(KErrArgument);
        }
        }
    }
    CleanupStack::PopAndDestroy(fields);
}

// -----------------------------------------------------------------------------
// CPIMEventPropertyConverter::GetRepeatRuleFieldsL
// Gets the fields from a repeat rule
// -----------------------------------------------------------------------------
//
void CPIMEventPropertyConverter::GetRepeatRuleFieldsL(
    const MPIMRepeatRuleData* aRepeat, // Fields are read from this
    TInt* aInterval, // interval is stored here
    TInt* aFrequency, // frequency is stored here
    TVersitDateTime** aVersitEndDate) // end date is stored here
{
    JELOG2(EPim);
    TBool endExists = EFalse;
    CArrayFix<TPIMField>* repeatFields = aRepeat->GetFieldsL();
    CleanupStack::PushL(repeatFields);
    TInt fieldCount = repeatFields->Count();
    for (TInt i = 0; i < fieldCount; i++)
    {
        switch (repeatFields->At(i))
        {
        case EPIMRepeatRuleFrequency:
        {
            *aFrequency = aRepeat->GetIntL(EPIMRepeatRuleFrequency);
            break;
        }
        case EPIMRepeatRuleInterval:
        {
            *aInterval = aRepeat->GetIntL(EPIMRepeatRuleInterval);
            break;
        }
        case EPIMRepeatRuleEnd:
        {
            endExists = ETrue;
            break;
        }
        default:
        {
            // We ignore other fields
        }
        }
    }
    CleanupStack::PopAndDestroy(repeatFields);
    if (endExists)
    {
        TPIMDate endDate = aRepeat->GetDateL(EPIMRepeatRuleEnd);
        *aVersitEndDate
        = new(ELeave) TVersitDateTime(endDate.DateTime(), TVersitDateTime::EIsUTC);
    }
}

TInt TDmAdUtil::FindLargestLocallyCreated(const CArrayFix<TSmlDmMappingInfo>& aPreviousUriSegmentList)
    {
    TRACE("TDmAdUtil::FindLargestLocallyCreated");
    TInt largest = 0;
    for (TInt i=0; i < aPreviousUriSegmentList.Count(); i++)
        {
        const TSmlDmMappingInfo& mappingInfo = aPreviousUriSegmentList.At(i);        
        if (mappingInfo.iURISeg.Find(KDmAdLocallyCreatedRtNodeUriSegPrefix) == 0)
            {            
            TPtrC8 numberPart(mappingInfo.iURISeg.Mid(KDmAdLocallyCreatedRtNodeUriSegPrefix().Length()));
            TInt number = TDmAdUtil::DesToInt(numberPart);
            if (number > largest)
                {
                largest = number;
                }
            }
        }
    return largest;
    }

DMAD_EXPORT_C void TDmAdUtil::BuildRtNodeChildUriListL(MDmAdCallBack*                          aDmAdCallBack,
                                                  MDmAdStoreApi*                          aStoreApi,
                                                  const TDesC8&                           aUri,
                                                  const TDesC8&                           aParentLuid,
                                                  const CArrayFix<TSmlDmMappingInfo>&     aPreviousUriSegmentList,
                                                  CBufBase&                               aCurrentList)
    {
#ifdef DMAD_DUMP_PREVIOUS_URI_SEGMENT_LIST
        DEBUG_LOG(_L("BuildRtNodeChildUriListL:"));
        {
        for (TInt i=0; i < aPreviousUriSegmentList.Count(); i++)
            {
            const TSmlDmMappingInfo& mappingInfo = aPreviousUriSegmentList.At(i);
                        
            DEBUG_LOG1(_L("entry %d:"), i);            
            DEBUG_LOG1(_L8("Uri: %S"), &(mappingInfo.iURISeg));
            DEBUG_LOG_HEX(mappingInfo.iURISegLUID);
            
            }
        }
#endif

    RPointerArray<HBufC8> luidList;
    CleanupStack::PushL(TCleanupItem(PointerArrayCleanup, &luidList));
    
    aStoreApi->LuidListL(aUri, aParentLuid, luidList);


    // Finds largest number used in cli<x> named nodes.
    TInt largest = FindLargestLocallyCreated(aPreviousUriSegmentList);
    DEBUG_LOG1(_L("largest is cli%d"), largest);
    
    TInt countLuidList = luidList.Count();
    for (TInt j=0; j < countLuidList; j++)
        {
        const HBufC8* luidElem = luidList[j];

        HBufC8* uriSeg = 0;
        
        //Tries to find the luid from the aPreviousUriSegmentList
        for (TInt i=0; i < aPreviousUriSegmentList.Count(); i++)
            {
            const TSmlDmMappingInfo& mappingInfo = aPreviousUriSegmentList.At(i);
                        
            if (mappingInfo.iURISegLUID.Compare(*luidElem) == 0)
                {            
                uriSeg = mappingInfo.iURISeg.AllocLC();
                break;
                }
            }
        
        if (uriSeg == 0)
            {
            //Uri was not found from the aPreviousUriSegmentList
            uriSeg = BuildLocallyCreatedRtNodeUriSegLC(largest);
            
            DEBUG_LOG2(_L8("uriSeg %S, largest %d"), uriSeg, largest);
            
            HBufC8* wholeUri = TDmAdUtil::BuildUriLC(aUri, *uriSeg);            
            aDmAdCallBack->SetMappingL(*wholeUri, *luidElem);
            CleanupStack::PopAndDestroy(); //wholeUri
            }

        //If this is not the first element, inserts slash at the beginning
        //of the result list.
        if (j > 0)
            {            
            aCurrentList.InsertL(aCurrentList.Size(), KDmAdSeparator);
            }
        aCurrentList.InsertL(aCurrentList.Size(), *uriSeg);
        
        CleanupStack::PopAndDestroy(); // uriSeg
        }
    
    CleanupStack::PopAndDestroy(); //luidList
    }

// -----------------------------------------------------------------------------
// CWPRoot::CreateLinksL
// -----------------------------------------------------------------------------
//
void CWPRoot::CreateLinksL()
    {
    FLOG( _L( "[Provisioning] CWPRoot::ParameterL2:" ) );
    
    iNeeders.Reset();
    delete iNeededIDs;
    iNeededIDs = NULL;
    iNeededIDs = new(ELeave) CDesCArrayFlat( KIDArrayGranularity );
    delete iProviderIDs;
    iProviderIDs = NULL;
    iProviderIDs = new(ELeave) CDesCArrayFlat( KIDArrayGranularity );

    AcceptL( *this );

    // We now have arrays of links and targets of links. Put them together.
    for( TInt i( 0 ); i < iNeeders.Count(); i++ )
        {
        CWPCharacteristic* needer = iNeeders[i];
        TPtrC neededID( iNeededIDs->MdcaPoint( i ) );

        TBool foundProvider( EFalse );
        for( TInt j( 0 ); j < iProviders.Count() && !foundProvider; j++ )
            {
            CWPCharacteristic* needed = iProviders[j];
            TPtrC providerID( iProviderIDs->MdcaPoint( j ) );

            if( providerID == neededID )
                {
            	if ( needer->Type() == KWPPxPhysical && needed->Type() != KWPNapDef)
            		{
            		// incorrect link found. do nothing.
            		}
            	else
            		{
#ifndef __SYNCML_DM_OTA
					FLOG ( _L( "[Provisioning] CWPRoot::CreateLinksL*********** __SYNCML_DM_OTA ***********" ) );
            		if (KWPApplication == needer->Type())
            			{
            			_LIT( KNSmlDMProvisioningDMAppIdVal, "w7" );
            			FLOG (_L( "[Provisioning] CWPRoot::CreateLinksL:Needer is Application" ) );
            			
            			CArrayFix<TPtrC>* name = new(ELeave) CArrayFixFlat<TPtrC>(1);
				        CleanupStack::PushL(name);
				        				        
				        needer->ParameterL(EWPParameterAppID, name);
				        
				        if ((name->Count() > 0)
				        	&&
				        	0 == name->At(0).Compare(KNSmlDMProvisioningDMAppIdVal) )
				            {
				            CleanupStack::PopAndDestroy(); // name
            				continue;
				            }
				            
				        
				        CleanupStack::PopAndDestroy(); // name
            			}
            		FLOG ( _L( "[Provisioning] CWPRoot::CreateLinksL:*********** __SYNCML_DM_OTA ***********" ) );
#endif
            		
                    needer->InsertLinkL( *needed );
                    foundProvider = ETrue;
            		}
                }
            }
        }
    
    // Free the temporary memory
    iNeeders.Reset();
    iProviders.Reset();
    delete iNeededIDs;
    iNeededIDs = NULL;
    delete iProviderIDs;
    iProviderIDs = NULL;
    }