Ejemplo n.º 1
0
EXPORT_C void CEikHotKeyTable::AddItemL(TInt aCommandId,TInt aKeycode,TInt aModifiers)
    {
    TInt pos=0;
    TInt* pNumber=&iNumberPlain;
    switch (aModifiers)
        {
    case 0:
        break;
    case EModifierCtrl:
        pos=iNumberPlain;
        pNumber=&iNumberCtrl;
        break;
    case (EModifierShift|EModifierCtrl):
        pos=iNumberPlain+iNumberCtrl;
        pNumber=&iNumberShiftCtrl;
        break;
    default:
        User::Leave(KErrNotSupported);
        }
    SEikHotKey hotKey;
    hotKey.iCommandId=aCommandId;
    hotKey.iKeycode=aKeycode;
    InsertL(pos+*pNumber,hotKey);
    (*pNumber)++; // after the InsertL succeeds
    }
Ejemplo n.º 2
0
CAppSidChecker& RSidCheckerMap::FindSidCheckerL(TUid aAppType)
	{
	CAppSidChecker* checker = NULL;
	CAppSidChecker** checkerPtr = Find(aAppType.iUid);
	if(checkerPtr)
		{
		checker = *checkerPtr;
		}
	else
		{
		// No CAppSidChecker instance loaded, try to find one
		checker = CAppSidChecker::CheckerForAppType(aAppType);
		if(checker)
			{
			CleanupStack::PushL(checker);
			InsertL(aAppType.iUid, checker);
			CleanupStack::Pop(checker);
			checker->SetRescanCallBackL(iRescanCallBack);
			}
		else
			{
			User::Leave(KErrNotFound);
			}
		}
	return *checker;
	}
TUint CTupleStoreImpl::PutL(TTupleType aTupleType, const TTupleName& aTupleName, const TDesC& aSubName, 
		const TComponentName& aComponent,
		const TDesC8& aSerializedData, TBBPriority aPriority, TBool aReplace,
		const TTime& aLeaseExpires, TBool aKeepExisting)
{
	CALLSTACKITEM_N(_CL("CTupleStoreImpl"), _CL("PutL"));

	if (aTupleName.iModule.iUid == KBBAnyUidValue ||
		aTupleName.iId == KBBAnyId ||
		aComponent.iModule.iUid == KBBAnyUidValue ||
		aComponent.iId == KBBAnyId) User::Leave(KErrArgument);

	TUint ret;
	{
		TAutomaticTransactionHolder ath(*this);

		TBool exists=SeekNameL(aTupleType, aTupleName, aSubName);
		if (exists && aKeepExisting) {
			UpdateL();
			iTable.SetColL(ELeaseExpires, aLeaseExpires);
			MDBStore::PutL();
			return 0;
		} else if (exists && aReplace) {
			UpdateL();
		} else {
			InsertL();
			iTable.SetColL(ETupleType, aTupleType);
			iTable.SetColL(ENameModule, aTupleName.iModule.iUid);
			iTable.SetColL(ENameId, aTupleName.iId);
			iTable.SetColL(ENameSubName1, aSubName);
			iTable.SetColL(ENameSubName2, aSubName.Left(iSubNameIndexLength));
			iTable.SetColL(EPriority, aPriority);
			iTable.SetColL(EComponentModule, aComponent.iModule.iUid);
			iTable.SetColL(EComponentId, aComponent.iId);
		}
		ret=iTable.ColUint(ETupleId);

		if (aSerializedData.Length() > 0) {
			RADbColWriteStream w; w.OpenLA(iTable, EData);
			w.WriteUint32L(aSerializedData.Length());
			w.WriteL(aSerializedData);
			w.CommitL();
		} else {
			iTable.SetColNullL(EData);
		}
		iTable.SetColL(ELeaseExpires, aLeaseExpires);
		MDBStore::PutL();
	}

	if (aLeaseExpires < iNextExpiry) {
		TTime now=GetTime();
		TTimeIntervalSeconds s;
		aLeaseExpires.SecondsFrom(now, s);
		TInt wait=s.Int();
		iTimer->Wait(wait);
	}
	return ret;
}
Ejemplo n.º 4
0
/**
Add a new URI and its associated properties into the storage. 

@param aUriStream A stream to read the CInetUriImpl object.
@param aUriId URI Id value that will be returned to the caller
@param aPropId Property Id value that will be returned to the caller

*/
void CUriListInterface::AddUriL ( RReadStream& aUriStream, TInt& aUriId, TInt& aPropId )
	{	
	CInetUriImpl* inetUri = CInetUriImpl::NewL ();
	CleanupStack::PushL ( inetUri );
	inetUri->UnpackL ( aUriStream );
	InsertL ( *inetUri );
	aUriId = inetUri->UriId ();
	aPropId = inetUri->Properties().PropId ();
	CleanupStack::PopAndDestroy ( inetUri );	
	}
void CMediaMtpDataProvider::GetSupportedFormatL()
    {
    iSupportedFormat.Reset();

    TInt count = sizeof ( KMediaMtpDataProviderSupportedFormats ) / sizeof( TUint16 );
    for ( TInt i = 0; i < count; i++ )
        {
        InsertL( iSupportedFormat, KMediaMtpDataProviderSupportedFormats[i] );
        }
    }
Ejemplo n.º 6
0
void Bignum::_Deque::InsertR(int i)
{
  _Ary * Node;
  if (IsEmpty()) {
    InsertL(i);
  }
  else {
    Node = new _Ary(i,_Tail,_Tail->prev);
    _Tail->prev->next = Node;
    _Tail->prev = Node;
  }
}            
Ejemplo n.º 7
0
Label &Label::operator=(const Label & d)
{
  if (this==&d) { return *this; }

  _Empty();

  if (!IsEmpty()) {
    for (_Ary * loop = d._Head; loop!=d._Tail; loop = loop->next) {
      InsertL(loop->ch);
    } }
  return *this;     
}
void CMediaMtpDataProvider::GetAllSupportedPropL()
    {
    iSupportedPropAll.Reset();

    TInt i = 0;
    TInt count = sizeof( KMmMtpDpSupportedPropMandatoryAll ) / sizeof( TUint16 );
    for ( i = 0; i < count; i++ )
        InsertL( iSupportedPropAll, KMmMtpDpSupportedPropMandatoryAll[i] );

    count = sizeof ( KMmMtpDpSupportedPropAdditionalAll ) / sizeof(TUint16);
    for ( i = 0; i < count; i++ )
        InsertL( iSupportedPropAll, KMmMtpDpSupportedPropAdditionalAll[i] );

    count = sizeof ( KMmMtpDpSupportedPropMandatoryAudio ) / sizeof(TUint16);
    for ( i = 0; i < count; i++ )
        InsertL( iSupportedPropAll, KMmMtpDpSupportedPropMandatoryAudio[i] );

    count = sizeof ( KMmMtpDpSupportedPropAdditionalAudio ) / sizeof(TUint16);
    for ( i = 0; i < count; i++ )
        InsertL( iSupportedPropAll, KMmMtpDpSupportedPropAdditionalAudio[i] );

    count = sizeof ( KMmMtpDpSupportedPropMandatoryWMV ) / sizeof(TUint16);
    for ( i = 0; i < count; i++ )
        InsertL( iSupportedPropAll, KMmMtpDpSupportedPropMandatoryWMV[i] );

    count = sizeof ( KMmMtpDpSupportedPropAdditionalWMV ) / sizeof(TUint16);
    for ( i = 0; i < count; i++ )
        InsertL( iSupportedPropAll, KMmMtpDpSupportedPropAdditionalWMV[i] );
    }
Ejemplo n.º 9
0
void Label::InsertR(char ch)
{
  _Ary * Node;
  if (IsEmpty()) {
    InsertL(ch);
  }
  else {
    Node = new _Ary(ch,_Tail,_Tail->prev);
    _Tail->prev->next = Node;
    _Tail->prev = Node;
    //_Index++;
  }
}     
Ejemplo n.º 10
0
void CAknInlineTextStore::InsertInlineTextL( CAknPositionedInlineText* aInlineText )
    {
    TInt insertPosition(0);
    for (TInt ii = Count()-1; ii >= 0; --ii)
		{
		if ( At(ii)->DocPos() <= aInlineText->DocPos() )
            {
            insertPosition = ii+1;
            break;
            }
		}

    InsertL( insertPosition, aInlineText );
    }
Ejemplo n.º 11
0
// -----------------------------------------------------------------------------
// CWPRoot::StartCharacteristicL
// -----------------------------------------------------------------------------
//
void CWPRoot::StartCharacteristicL( const TDesC& aName )
    {
    FLOG( _L( "[Provisioning] CWPRoot::StartCharacteristicL:" ) );

    CWPCharacteristic* newChar = 
        WPElementFactory::CreateCharacteristicLC( aName );
    if( iStack.Count() == 0 )
        {
        // Assumes ownership if doesn't leave
        InsertL( newChar );
        }
    else
        {
        CWPCharacteristic* latest = iStack[ iStack.Count()-1 ];
        // Assumes ownership if doesn't leave
        latest->InsertL( newChar );
        }
    CleanupStack::Pop(); // newChar

    User::LeaveIfError( iStack.Append( newChar ) );
    }
Ejemplo n.º 12
0
// -----------------------------------------------------------------------------
// CWPRoot::StartCharacteristicL
// -----------------------------------------------------------------------------
//
void CWPRoot::StartCharacteristicL( TInt aType )
    {
    FTRACE(RDebug::Print(_L("[Provisioning] CWPRoot::StartCharacteristicL: aType (%d)"), aType));

    CWPCharacteristic* newChar = 
        WPElementFactory::CreateCharacteristicLC( aType );
    if( iStack.Count() == 0 )
        {
        // Assumes ownership if doesn't leave
        InsertL( newChar );
        }
    else
        {
        CWPCharacteristic* latest = iStack[ iStack.Count()-1 ];
        // Assumes ownership if doesn't leave
        latest->InsertL( newChar );
        }
    CleanupStack::Pop(); // newChar

    User::LeaveIfError( iStack.Append( newChar ) );
    }
//--------------------------------------------------------------------
//--------------------------------------------------------------------
//
void CPosLmNameIndex::UpdateL( TPosLmItemId aLmid, HBufC* aName )
    {
    TInt index = Find( aLmid );
    if ( index >= 0 )
        {
        CIndexItem* entry = iArray->At( index );
        // if name is exactly same, no need to change anything
        if ( entry->Name().Compare( *aName ) != 0 )
            {
            DoRemove( index );
            InsertL( aLmid, aName );
            }
        else
            {
            delete aName;
            }
        }
    else
        {
        delete aName;
        }
    }
Ejemplo n.º 14
0
// -----------------------------------------------------------------------------
// CSIPMessage::AddHeaderL
// -----------------------------------------------------------------------------
//
EXPORT_C void CSIPMessage::AddHeaderL (CSIPHeaderBase* aSIPHeader)
	{
	__ASSERT_ALWAYS (aSIPHeader != 0, User::Leave(KErrArgument));

	__ASSERT_ALWAYS (!(aSIPHeader->IsExtensionHeader() &&
	                   SIPHeaderLookup::IsSupported(aSIPHeader->Name())),
					   User::Leave(KErrSipCodecNotAllowed));

	// Never add the Content-Length header. Instead store its value.
	if (IsContentLengthHeader(*aSIPHeader))
		{
		if (iAnnouncedContentLengthSet) 
			{
			User::Leave(KErrAlreadyExists);
			}
		iAnnouncedContentLengthSet = ETrue;
		iAnnouncedContentLength = 
			(static_cast<CSIPContentLengthHeader*>(aSIPHeader))->Value();
		delete aSIPHeader;
		return;
		}
	TInt index = FindHeaderListIndex (*aSIPHeader);
	if (index == KErrNotFound) // Insert as the head of a new header list.
		{
		TSglQue<CSIPHeaderBase> headerList(KSIPHeaderOffset);
		headerList.AddLast (*aSIPHeader);
		InsertL (headerList);
		}
	else // Try to add to existing header list
		{
		if (!aSIPHeader->MoreThanOneAllowed()) 
            {
            User::Leave(KErrAlreadyExists);
            }
		iSIPHeaderListArray[index].AddLast(*aSIPHeader);
		}
	}
Ejemplo n.º 15
0
int Load_file(char* loadFile)
{
    FILE *fpb;
        MyRecord rec;
        long lSize;
        int numOfrecords, i;
        fpb = fopen (loadFile,"rb");
        if (fpb==NULL)
        {
            printf("Cannot open binary file\n");
            return 0;
        }

        // check number of records
        fseek (fpb , 0 , SEEK_END);
        lSize = ftell (fpb);
        rewind (fpb);
        numOfrecords = (int) lSize/sizeof(rec);
        if(hashtsize == 0)
        {
            hashtsize = primes(numOfrecords/2);
            hashtable = malloc(hashtsize*(sizeof(pnode)));
        }
        for(i = 0; i < hashtsize; i++)
        {
            hashtable[i] = NULL;
        }
        for (i=0; i<numOfrecords ; i++)
        {
            fread(&rec, sizeof(rec), 1, fpb);
            InsertL(rec, hashtable, hashtsize, start_town);
        }
        fclose(fpb);
        printf("Data file loaded succesfully.\n");
        return 1;
}
Ejemplo n.º 16
0
int main (int argc, char** argv)
{
    int a, pop, sum, k;
    int l, o, c;
    int fd, val;

    MyRecord temprec, r;
    char ch;
    char phoneno[20];
    char town[20];
    char min[20], max[20];
    char word[20];
    l = 0;
    o = 0;
    c = 0;
    char loadFile[20], opFile[20], configFile[20];

    /* Diabasma orismatwn */

    opterr = 0;

    while ((a = getopt (argc, argv, "l:o:c:")) != -1)
        switch (a)
        {
           case 'l':
             strcpy(loadFile, optarg);
             l = 1;
             break;
           case 'o':
             strcpy(opFile, optarg);
             o = 1;
             break;
           case 'c':
             strcpy(configFile, optarg);
             c = 1;
             break;
           case '?':
             if (optopt == 'p' || optopt == 'i' || optopt == 'd')
               fprintf (stderr, "Option -%c requires an argument.\n", optopt);
             else if (isprint (optopt))
               fprintf (stderr, "Unknown option `-%c'.\n", optopt);
             else
               fprintf (stderr,
                        "Unknown option character `\\x%x'.\n",
                        optopt);
             return 1;
           default:
             abort ();
        }

   InitializeI(&start_town);

   /* Xrhsh orismatwn */
    if(c == 1)
    {
        FILE* con;
        con = fopen(configFile,"r");
        if (con == NULL)
        {
            printf("Cannot open configuration file\n");
        }
        else
            while(!feof(con))
            {
                if(fscanf(con, "%s %d", word, &val) == 2)
                    if(strcmp(word, "Hash_Table_Size") == 0)
                    {
                        hashtsize = val;
                        hashtable = malloc(hashtsize*(sizeof(pnode)));
                    }
            }
    }
    if(l == 1)
    {
        Load_file(loadFile);
        l = 0;
    }
     if(o == 1)                     // An uparxei operation file tote to stdin anakateuthunetai sto arxeio ayto k diabazontai oi entoles kanonika mexri na teleiwsei
    {
        if(hashtsize == 0)
        {
            hashtsize = primes(DEFAULT_HASH_SIZE);
            hashtable = malloc(hashtsize*(sizeof(pnode)));
        }
        if( access(opFile, F_OK ) != -1 )
        {
            fd = dup(fileno(stdin));
            freopen(opFile, "r", stdin);
        }
        else
            printf("Cannot open operation file\n");

    }
    memset(max, '0', 20);
    memset(min, '0', 20);
    if(hashtsize == 0)
        {
            hashtsize = primes(DEFAULT_HASH_SIZE);
            hashtable = malloc(hashtsize*(sizeof(pnode)));
        }
    if(o == 0)
        printf("Give input\n");

    /* Epanalipsh gia thn eisagwgh entolwn. Diavasma prwtou xarakthra kai elegxos periptwsewn */
    while(1)
    {


        ch = getchar();
        if(ch == 'i')
        {
            ReadValue(&temprec);
            if(SearchL(temprec.phone, hashtable, hashtsize, &r) == 0)
                InsertL(temprec, hashtable, hashtsize, start_town);
            else
                printf("Number %s already exists. Cannot add the same number twice.\n", temprec.phone);
            //temp_town = start_town;
		}
		else if(ch == 'q')
		{
            scanf("%10s", phoneno);
            if(SearchL(phoneno, hashtable, hashtsize, &r) == 1)
                WriteValue(r);
            else
                printf("Number %s not found.\n", phoneno);
            memset(phoneno, '\0', 20);
		}
		else if(ch == 'd')
		{
            scanf("%10s", phoneno);
            DeleteL(phoneno, hashtable, hashtsize, start_town);
            memset(phoneno, '\0', 20);
		}
		else if(ch == 'l')
        {
            scanf("%s", loadFile);
            Load_file(loadFile);
        }
		else if(ch == 'e')
		{
            FreeIndex(start_town);
            free(start_town);
            free(hashtable);
            return 0;
		}
		else if(ch == 'p')
		{
            scanf("%s", town);
            pop = PopulationI(start_town, town);
            if(pop > 0)
                printf("%s: %d\n", town, pop);
            else
                printf("Town %s not found.\n", town);
            memset(town, '\0', 20);
		}
		else if(ch == 's')
		{
            scanf("%s", town);
            sum = SummaryI(start_town, town);
            if(sum > 0)
                printf("%s: %d\n", town, sum);
            else
                printf("Town %s not found.\n", town);
            memset(town, '\0', 20);
		}
		else if(ch == 't')
		{
            scanf("%d", &k);
            Top(start_town, k);
		}
		else if(ch == 'f')
		{
            ch = getchar();
            if(ch == 't')
            {
                ch = getchar();
                if(ch == ' ')
                {
                    scanf("%s %d", town, &k);
                    TopKSpenders(start_town, town, k);
                }
                else if(ch == 's')
                    TopTownSpenders(start_town);
            }
		}
		else if(ch == 'm')
		{
            ch = getchar();
            if(ch == 'a')
            {
                ch = getchar();
                if(ch == 'x')
                {
                    //if(max[0] == '0')
                        Max(start_town);
                }
            }
            else if(ch == 'i')
            {
                ch = getchar();
                if(ch == 'n')
                {
                   // if(min[0] == '0')
                        Min(start_town);
                }
            }
		}
		//scanf("%20s", junk);
		if(o == 1 && ch == EOF)     // An yparxei operation file san orisma kai exei teleiwsei h anagnwsh epanafora tou stdin.
        {
            fflush(stdin);
            dup2(fd, fileno(stdin));
            close(fd);
            clearerr(stdin);
            o = 0;
            printf("Operation file finished succesfully.\n");
        }
        fflush(stdin);
    }

    return 0;

    }
// ---------------------------------------------------------------------------
// CMediaMtpDataProvider::GetSupportedPropL
//
// ---------------------------------------------------------------------------
//
void CMediaMtpDataProvider::GetSupportedPropL()
    {
    iSupportedPropAudio.Reset();
    iSupportedPropVideo.Reset();

    TInt count = 0, i = 0;
    count = sizeof( KMmMtpDpSupportedPropMandatoryAll ) / sizeof( TUint16 );
    for ( i = 0; i < count; i++ )
        {
        InsertL( iSupportedPropAudio, KMmMtpDpSupportedPropMandatoryAll[i] );
        InsertL( iSupportedPropVideo, KMmMtpDpSupportedPropMandatoryAll[i] );

        }

    count = sizeof( KMmMtpDpSupportedPropAdditionalAll ) / sizeof( TUint16 );
    for ( i = 0; i < count; i++ )
        {
        InsertL( iSupportedPropAudio, KMmMtpDpSupportedPropAdditionalAll[i] );
        InsertL( iSupportedPropVideo, KMmMtpDpSupportedPropAdditionalAll[i] );
        }

    for ( TInt j = 0; j < iSupportedFormat.Count(); j++ )
        {
        switch ( iSupportedFormat[j] )
            {
            case EMTPFormatCodeWMA:
            case EMTPFormatCodeMP3:
            case EMTPFormatCodeAAC:
            case EMTPFormatCodeWAV:
            case EMTPFormatCodeMP4Container:
            case EMTPFormatCode3GPContainer:
                {
                count = sizeof ( KMmMtpDpSupportedPropMandatoryAudio ) / sizeof( TUint16 );
                for ( i = 0; i < count; i++ )
                    {
                    InsertL( iSupportedPropAudio, KMmMtpDpSupportedPropMandatoryAudio[i] );
                    }

                count = sizeof ( KMmMtpDpSupportedPropAdditionalAudio ) / sizeof(TUint16);
                for ( i = 0; i < count; i++ )
                    {
                    InsertL( iSupportedPropAudio, KMmMtpDpSupportedPropAdditionalAudio[i] );
                    }
                }
                break;

            case EMTPFormatCodeWMV:
            case EMTPFormatCodeASF:
                {
                count = sizeof ( KMmMtpDpSupportedPropMandatoryWMV ) / sizeof(TUint16);
                for ( i = 0; i < count; i++ )
                    {
                    InsertL( iSupportedPropVideo, KMmMtpDpSupportedPropMandatoryWMV[i] );
                    }

                count = sizeof ( KMmMtpDpSupportedPropAdditionalWMV ) / sizeof(TUint16);
                for ( i = 0; i < count; i++ )
                    {
                    InsertL( iSupportedPropVideo, KMmMtpDpSupportedPropAdditionalWMV[i] );
                    }
                }
                break;

            default:
                {
                // shouldn't happen
                User::Leave( KErrNotSupported );
                }
                break;
            }
        }
    }
	void InsertL( TInt aPos, MJuikControl& aControl, TInt aProportion, TInt aFlags )
	{
		CALLSTACKITEM_N(_CL("CJuikSizer"), _CL("InsertL(MJuikControl"));
		auto_ptr<CJuikSizerItem> item( new (ELeave) CJuikControlSizerItem(aControl, aProportion, aFlags ) );
		InsertL( item.release(), aPos );
	}
Ejemplo n.º 19
0
/**
Database event handler.

@param aEvent the database event.
*/
void CContactLocalView::HandleDatabaseEventL(TContactDbObserverEvent aEvent)
	{
	// handle Backup / Restore notifications before checking View State
	switch (aEvent.iType)
		{
		case EContactDbObserverEventBackupBeginning:
		case EContactDbObserverEventRestoreBeginning:
#if defined(__VERBOSE_DEBUG__)
			RDebug::Print(_L("[CNTMODEL] CContactLocalView{ViewPrefs = 0x%08X}::HandleDatabaseEventL -> Backup/Restore Beginning, state = %i\r\n"), 
				iViewPreferences, iState);
#endif
			if (iState == EReady)
				{
				SetState(ENotReady);
				}
			else
				{
				// stop sorting
				iViewCntMgr->StopSortL();
				}
			return;

		case EContactDbObserverEventBackupRestoreCompleted:
#if defined(__VERBOSE_DEBUG__)
			RDebug::Print(_L("[CNTMODEL] CContactLocalView{ViewPrefs = 0x%08X}::HandleDatabaseEventL -> Backup/Restore Completed, state = %i, old sort error %i\r\n"), 
				iViewPreferences, iState, iExtension->iError);
#endif
			if (iState == ENotReady && iExtension->iError == KErrNone)
				{
				// view was ready before tables were closed
				SetState(EReady);
				}
			else // view was Initializing (sorting) before tables were closed
				{
				// re-read database and sort
				SafeResort();
				}
			return;

		default:
			// other events dealt with below
			break;
		}


	if (iState!=EReady)
		{
		if (iViewCntMgr->IsICCSynchronised())
			{
			/*
			 * View events are only queued when the ICC has been synchronised. This prevents
			 * duplicate contacts in an ICC view because add events are not queued until the 
			 * SIM is fully synchronised. 
			 * 
			 * See LUD-5EBHZF "ICC contacts view broadcasts add item events after view is 
			 * ready" for more detail.
       		 */
			
#if defined(__VERBOSE_DEBUG__)
			DebugLogNotification(_L("[CNTMODEL] . . . . . Queueing Database Event "), aEvent);
#endif
			iOutstandingEvents.AppendL(aEvent);
			
            // The view state is set to ENotReady when a recovery takes place, and also when the tables
            // are closed, so set ready here.
            if (iState == ENotReady && (aEvent.iType
                    == EContactDbObserverEventRecover || aEvent.iType
                    == EContactDbObserverEventTablesOpened))
                {
                SetState(EReady);
                }
            // view was Initializing (sorting) before recovery or compression started!  
            if (iState == EInitializing && (aEvent.iType
                    == EContactDbObserverEventRecover || aEvent.iType
                    == EContactDbObserverEventCompress))
                {
                // re-read database and sort
                SafeResort();
                }
                
			}		
			
			
#if defined(__VERBOSE_DEBUG__)
		else
			{
			DebugLogNotification(_L("[CNTMODEL] . . . . . Discarding Database Event "), aEvent);
			}
#endif
		}
	else
		{
		TContactViewEvent event;
		event.iInt = KErrNone;
		switch(aEvent.iType)
			{
			case EContactDbObserverEventGroupChanged:
			case EContactDbObserverEventContactChanged:
			case EContactDbObserverEventOwnCardChanged:
				{
				if (aEvent.iType == EContactDbObserverEventGroupChanged)
				    {
	    			//Groups are a special case the base view may not contain the group
    				//but a sub view may be such a group and need to know its changed
				    event.iEventType=TContactViewEvent::EGroupChanged;
				    event.iContactId=aEvent.iContactId;
				    NotifyObservers(event);
				    }
				
				// Remove from old position, and notify.
				TRAPD(err,event.iInt=RemoveL(aEvent.iContactId));

                if (err == KErrNone && event.iInt != KErrNotFound)
                    {
				    event.iEventType=TContactViewEvent::EItemRemoved;
				    event.iContactId=aEvent.iContactId;
				    NotifyObservers(event);
					}
				
				// Insert at new position, and notify.
				event.iInt=InsertL(aEvent.iContactId);
                if (event.iInt != KErrNotFound)
					{
				    event.iEventType=TContactViewEvent::EItemAdded;
				    event.iContactId=aEvent.iContactId;
				    NotifyObservers(event);
                    }
				break;
				}
			case EContactDbObserverEventContactAdded:
			case EContactDbObserverEventGroupAdded:
#if defined(__VERBOSE_DEBUG__)
			DebugLogNotification(_L("[CNTMODEL] DatabaseEvent -> Contact/Group Added"), aEvent);
#endif
				event.iInt=InsertL(aEvent.iContactId);
				if (event.iInt != KErrNotFound)
					{
					event.iEventType=TContactViewEvent::EItemAdded;
					event.iContactId=aEvent.iContactId;
					NotifyObservers(event);
					}
				break;
			case EContactDbObserverEventContactDeleted:
				if(aEvent.iContactId == KNullContactId) // KNullContactId indicates a bulk delete.
					{ 
					SetState(EInitializing); // Use initializing state to avoid ESortOrderChanged event being sent to observers. 
					SafeResort(); 
					} 
				else 
					{ 
					event.iInt=RemoveL(aEvent.iContactId); 
					if (event.iInt != KErrNotFound) 
						{ 
						event.iEventType=TContactViewEvent::EItemRemoved; 
						event.iContactId=aEvent.iContactId; 
						NotifyObservers(event); 
						} 
					} 
				break; 
			case EContactDbObserverEventGroupDeleted:
			case EContactDbObserverEventOwnCardDeleted:
				event.iInt=RemoveL(aEvent.iContactId);
				if (event.iInt != KErrNotFound)
					{
					event.iEventType=TContactViewEvent::EItemRemoved;
					event.iContactId=aEvent.iContactId;
					NotifyObservers(event);
					}
				break;
			case EContactDbObserverEventUnknownChanges:
			case EContactDbObserverEventCurrentDatabaseChanged:
				SetState(EInitializing); // Use initializing state to avoid ESortOrderChanged event being sent to observers.
				SafeResort();
				break;
			case EContactDbObserverEventSortOrderChanged: // event is not currently used
				SetState(ENotReady);
				SafeResort();
				break;
			case EContactDbObserverEventTablesClosed:
				if (iState == EReady)
					{
					SetState(ENotReady);
					}
				break;
			case EContactDbObserverEventTablesOpened:
				// re-read database and sort
				SafeResort();
				break;

			case EContactDbObserverEventNull:
			case EContactDbObserverEventUnused:
			case EContactDbObserverEventRecover:
			case EContactDbObserverEventCompress:
			case EContactDbObserverEventRollback:
			case EContactDbObserverEventTemplateChanged:
			case EContactDbObserverEventTemplateDeleted:
			case EContactDbObserverEventTemplateAdded:
			case EContactDbObserverEventCurrentItemDeleted:
			case EContactDbObserverEventCurrentItemChanged:				
			case EContactDbObserverEventPreferredTemplateChanged:
			case EContactDbObserverEventSpeedDialsChanged:
			case EContactDbObserverEventRestoreBadDatabase:
				break;

			// these events should not come here, but be dealt with at the top of HandleDatabaseEventL
			case EContactDbObserverEventBackupBeginning:
			case EContactDbObserverEventRestoreBeginning:
			case EContactDbObserverEventBackupRestoreCompleted:
				break;
				
			default:
				ASSERT(EFalse);
			}
		}
	}
Ejemplo n.º 20
0
void CMsvEntryArray::GroupL(TGroupCriterion aGroupCriterion,TMsvSelectionOrdering aOrdering,TBool aDoSort)
//
// This function works recursively, grouping and sorting the entry selection.  The 
// 'sort' happens at the same time as the 1st 'group', then separate grouped arrays 
// are grouped indidvidually and then merged together at the end. The order in which 
// the grouping occurs is determined by the CMsvEntryArray::TGroupCriterion enum
//	
	{
	TMsvSorting sortType=aOrdering.Sorting();
	TKeyArrayFixPtr key=MessageSortKey(sortType);
	
	if (aGroupCriterion==EStopGrouping)
		{  // if you haven't sorted yet
		if (aDoSort)
			{
			// Subject based sorting requires a special algorithm. Only message entries are treated as other entries normally
			// do not have a prefix like e.g. "re: " or "fwd: "
			if(At(0)->iType == KUidMsvMessageEntry && (sortType == 	EMsvSortByDescription || sortType == EMsvSortByDescriptionReverse))
				{
				SubjectBasedSortL(sortType == EMsvSortByDescriptionReverse,aOrdering.SubjectSkipString());							
				}
			else
				{
				CMsvEntryArray* temp=CMsvEntryArray::NewLC(iOrigMtmList);
				TInt count=Count();
				if (count)
					temp->InsertL(0,&(*(this))[0],count);
				Reset();
				const TMsvEntry** entry = &temp->At(0);
				while (count--)
					InsertIsqAllowDuplicatesL(*entry++, key); // Sorted
				ReverseOrder(sortType);
				CleanupStack::PopAndDestroy(); // temp
				}
			if (At(0)->iType == KUidMsvMessageEntry && (sortType == EMsvSortByDetails || sortType == EMsvSortByDetailsReverse))
				{
				DetailBasedSortL(); // Sort blocks of messages with matching details into newest first
				}
			}
		else
			{
			// The aDoSort flag is not set, but we still need to do a subject
			// based sort if this array contains only message entries, and we are
			// sorting by description. Alternatively, we need to do a date based sort
			// if this array contains only message entries and we are sorting by detail.
			// In order to ensure the array contains only message entries, we
			// check that we have previously grouped the entries by type which would
			// have put all the message entries together in their own array.
			if (Count() > 0 && At(0)->iType == KUidMsvMessageEntry && OkToGroup(EGroupByType, aOrdering))
				{
				if (sortType == EMsvSortByDescription || sortType == EMsvSortByDescriptionReverse)
					{
					SubjectBasedSortL(sortType == EMsvSortByDescriptionReverse,aOrdering.SubjectSkipString());
					}
				else if (sortType == EMsvSortByDetails || sortType == EMsvSortByDetailsReverse)
					{
					DetailBasedSortL(); // Sort blocks of messages with matching details into newest first
					}
				}
			}
		return;
		}

	if (OkToGroup(aGroupCriterion, aOrdering))
		{
		//
		// Copy contents into temp and then put new grouped contents into 'this'
		TInt count=Count();
		if (count==0)
			return; // nothing to do here
		const TInt numberOfArrays=NumberOfArraysToSplitIntoL(aGroupCriterion);
		if (numberOfArrays<1)  // cannot group on this so move on to next grouping
			{
			GroupL(TGroupCriterion(aGroupCriterion+1), aOrdering, aDoSort);
			return;
			}
		CMsvEntryArray* temp;
		if (iActualMtmList)
			temp = CMsvEntryArray::NewLC(*iActualMtmList);
		else
			temp = CMsvEntryArray::NewLC(iOrigMtmList);
		temp->InsertL(0,&(*(this))[0],count);
		Reset();

		//
		// create the separate arrays for each group
		CArrayFixFlat<CMsvEntryArray*>* arrays=new(ELeave) CArrayFixFlat<CMsvEntryArray*>(numberOfArrays);
		CleanupStack::PushL(arrays);
		for (TInt ii=0; ii<numberOfArrays; ii++)
			{
			if (iActualMtmList)
				arrays->AppendL(CMsvEntryArray::NewLC(*iActualMtmList));
			else
				arrays->AppendL(CMsvEntryArray::NewLC(iOrigMtmList));
			}

		//
		// split the selection into the correct group, 
		// sorting aswell if needed and not doing standard folders
		const TMsvEntry** entry = &temp->At(0);
		if (!aDoSort || aGroupCriterion==EGroupByStandardFolders)
			{
			while (count--)
				{
				arrays->At(ArrayId(*entry,aGroupCriterion))->AppendL(*entry);
				entry++;
				}
			}
		else if (aGroupCriterion==EGroupByType)
			{
			TKeyArrayFixPtr folderKey = TKeyArrayFixPtr(_FOFF(TMsvEntry,iDetails),ECmpCollated);
			while (count--)
				{
				if ((*entry)->iType==KUidMsvFolderEntry)
					arrays->At(ArrayId(*entry, aGroupCriterion))->InsertIsqAllowDuplicatesL(*entry, folderKey);
				else
					arrays->At(ArrayId(*entry, aGroupCriterion))->InsertIsqAllowDuplicatesL(*entry, key);
				entry++;
				}
			for (TInt jj=0; jj<numberOfArrays; jj++)
				{
				if (arrays->At(jj)->Count() && arrays->At(jj)->At(0)->iType!=KUidMsvFolderEntry)
					arrays->At(jj)->ReverseOrder(sortType);
				}
			aDoSort=EFalse; 
			}
		else
			{
			while (count--)
				{
				arrays->At(ArrayId(*entry, aGroupCriterion))->InsertIsqAllowDuplicatesL(*entry, key); // Sorted
				entry++;
				}
			for (TInt jj=0; jj<numberOfArrays; jj++)
				arrays->At(jj)->ReverseOrder(sortType);
			aDoSort=EFalse; 
			}

		
		
		
		
		//
		// group further - but check that standard entries and grouped folders are not grouped anymore
		if (aGroupCriterion==EGroupByStandardFolders)
			{
			__ASSERT_DEBUG(numberOfArrays==2, PanicServer(EMsvToManyGroups));
			arrays->At(0)->GroupL(TGroupCriterion(aGroupCriterion+1), aOrdering, aDoSort);
			}
		else if (aGroupCriterion==EGroupByType)
			{
			for (TInt jj=0; jj<numberOfArrays; jj++)
				if (arrays->At(jj)->Count() && arrays->At(jj)->At(0)->iType!=KUidMsvFolderEntry)
					arrays->At(jj)->GroupL(TGroupCriterion(aGroupCriterion+1), aOrdering, aDoSort);
			}
		else 
			{
			for (TInt jj=0; jj<numberOfArrays; jj++)
				arrays->At(jj)->GroupL(TGroupCriterion(aGroupCriterion+1), aOrdering, aDoSort);
			}
		
		//
		// merge the separate arrays into 'this'
		for (TInt kk=0; kk<numberOfArrays; kk++)
			{
			count=arrays->At(kk)->Count();
			if (count)
				InsertL(0,&(*(arrays->At(kk)))[0],count);
			}
		CleanupStack::PopAndDestroy(numberOfArrays+2); // arrays contents + temp + arrays
		}
	else // move on to the next grouping
		GroupL(TGroupCriterion(aGroupCriterion+1), aOrdering, aDoSort);
	}
//--------------------------------------------------------------------
//--------------------------------------------------------------------
//
void CPosLmNameIndex::InsertL( const CPosLandmark& aLandmark )
    {
    TPtrC name;
    aLandmark.GetLandmarkName( name );
    InsertL( aLandmark.LandmarkId(), name );
    }
void CTupleStoreImpl::ConstructL()
{
	CALLSTACKITEM_N(_CL("CTupleStoreImpl"), _CL("ConstructL"));

	iSubNameIndexLength=40;

	// name:      id,           tupletype,   
	TInt cols[]={ EDbColUint32, EDbColInt32, 
	//{     Uid,         Id,          subname1 }, 
		EDbColInt32, EDbColInt32, EDbColText, 
	//      priority,   
		EDbColInt8,
	// {	Uid,         Id},
		EDbColInt32, EDbColInt32, 
	//      data              LeaseExpires
		EDbColLongBinary, EDbColDateTime, 
	//		subname2
		EDbColText, -1 };

	TInt col_flags[]={ TDbCol::EAutoIncrement, 0, 0, 0, 0, 0,
		0, 0, 
		0, 0,
		0, 0 };
	// the tuple id is added to indices so that data is read in
	// the order it arrives
	TInt idxs[]={ 
		ETupleType, ENameModule, ENameId, ENameSubName2, ETupleId, -2, 
		ETupleId, -2,
		ETupleType, EComponentModule, EComponentId, 
			EPriority, ETupleId, -2,
		ELeaseExpires, 
		-1 };

	MDBStore::ConstructL(cols, idxs, false, 
		_L("TUPLES"), EFalse, col_flags);

	iTimer=CTimeOut::NewL(*this, CActive::EPriorityIdle);
	if (SeekIdL(0)) {
		TInt version=0;
		iTable.GetL();
		// check version and migrate if necessary
		version=iTable.ColInt32(ENameId);

		if (version<KVersion) {
			SwitchIndexL(-1); // no index
			TBool found=iTable.FirstL();
			while (found) {
				iTable.GetL();
				TUint uid_in_table, new_uid;
				new_uid=uid_in_table=iTable.ColInt(ENameModule);
				GetBackwardsCompatibleUid(new_uid);
				if (new_uid != uid_in_table) {
					UpdateL();
					iTable.SetColL(ENameModule, new_uid);
					MDBStore::PutL();
				}
				found=iTable.NextL();
			}
		}
		if (version<=KVersionBeforeExpires) {
			SwitchIndexL(-1); // no index
			TBool found=iTable.FirstL();
			while (found) {
				iTable.GetL();
				TInt tupletype;
				TTupleName tn;

				tn.iModule.iUid=iTable.ColInt(ENameModule);
				tn.iId=iTable.ColInt(ENameId);
				tupletype=iTable.ColInt(ETupleType);

				if ( (!(tn == KCLSettingsTuple)) && tupletype!=ETupleSpaceInternal ) {
					MDBStore::DeleteL();
				}
				found=iTable.NextL();
			}
		}

		if (version<KVersionBeforeNewUids) {
			TInt no_idxs[]={ -1 };
			iTable.Close();
			DeleteIndices(_L("TUPLES"));
			CC_TRAPD(err, MDBStore::ConstructL(cols, no_idxs, 
				false, _L("TUPLES"), ETrue, col_flags));
			iDb.BeginL();
			TTransactionHolder th(*this);
			TBool found=iTable.FirstL();
			while (found) {
				iTable.GetL();
				if ( iTable.ColUint(ETupleId) == 0 ) {
					UpdateL();
					iTable.SetColL(ENameId, KVersion);
					MDBStore::PutL();
				} else if (! iTable.IsColNull(ENameSubName1)) {
					UpdateL();
					iTable.SetColL(ENameSubName2,
						iTable.ColDes(ENameSubName1).Left(iSubNameIndexLength));
					MDBStore::PutL();
				}
				found=iTable.NextL();
			}
			iDb.CommitL();
			MDBStore::ConstructL(cols, idxs, 
				false, _L("TUPLES"), ETrue, col_flags);
		}

		if (version>=KVersionBeforeNewUids) {
			CleanOldTuplesL();
		}
		SeekIdL(0);
		UpdateL();
		iTable.SetColL(ENameId, KVersion);
		MDBStore::PutL();
		
	} else {
		InsertL();
		iTable.SetColL(ETupleType, ETupleSpaceInternal);
		iTable.SetColL(ENameId, KVersion);
		iTable.SetColL( ELeaseExpires, Time::MaxTTime() );
		MDBStore::PutL();
	}
}
	void AddL( MJuikSizer& aSizer, TInt aProportion, TInt aFlags )
	{
		CALLSTACKITEM_N(_CL("CJuikSizer"), _CL("AddL(MJuikSizer"));
		auto_ptr<CJuikSizerItem> item( new (ELeave) CJuikSizerSizerItem(aSizer, aProportion, aFlags ) );
		InsertL( item.release(), EndIndex() );
	}
//--------------------------------------------------------------------
//--------------------------------------------------------------------
//
void CPosLmNameIndex::InsertL( TPosLmItemId aLmid, const TDesC& aName )
    {
    HBufC* name = aName.AllocLC();
    CleanupStack::Pop( name );
    InsertL( aLmid, name );
    }