3 files changed, 62 insertions, 46 deletions

diff --git a/kabc/addressee.cpp b/kabc/addressee.cpp
index cb10160..2aca559 100644
--- a/kabc/addressee.cpp
+++ b/kabc/addressee.cpp
@@ -286,50 +286,51 @@ void Addressee::mergeContact( const Addressee& ad , bool isSubSet) // = false)
         if ( ad.mData->birthday.isValid()) 
             mData->birthday =  ad.mData->birthday;
     if ( mData->mailer.isEmpty() ) mData->mailer = ad.mData->mailer;
     if ( !mData->timeZone.isValid() ) mData->timeZone = ad.mData->timeZone;
     if ( !mData->geo.isValid() ) mData->geo = ad.mData->geo;
     if ( mData->title .isEmpty() ) mData->title = ad.mData->title  ;
     if ( mData->role.isEmpty() ) mData->role = ad.mData->role ;
     if ( mData->organization.isEmpty() ) mData->organization = ad.mData->organization ; 
     if ( mData->note.isEmpty() ) mData->note = ad.mData->note ; 
     if ( mData->productId.isEmpty() ) mData->productId  = ad.mData->productId; 
     if ( mData->sortString.isEmpty() )  mData->sortString  = ad.mData->sortString; 
     if ( !mData->secrecy.isValid() ) mData->secrecy = ad.mData->secrecy;
     if ( ( !mData->url.isValid() && ad.mData->url.isValid() ) ) mData->url = ad.mData->url ;
     QStringList t;
     QStringList tAD;
     uint iii;
     if ( isSubSet ) {
         // ********** phone numbers
         PhoneNumber::List phoneAD = ad.phoneNumbers();
         PhoneNumber::List::Iterator phoneItAD;
         for ( phoneItAD = phoneAD.begin(); phoneItAD != phoneAD.end(); ++phoneItAD ) {
             bool found = false;
             PhoneNumber::List::Iterator it;
             for( it = mData->phoneNumbers.begin(); it != mData->phoneNumbers.end(); ++it ) {
-                if ( (*it) == ( *phoneItAD ) ) {
+                if ( ( *phoneItAD ).contains( (*it)  ) ) {
                     found = true;
+                    (*it).setType( ( *phoneItAD ).type() );
                     break;
                 }
             }
             if ( ! found )
                 mData->phoneNumbers.append( *phoneItAD );                
         }
         // ************* emails;
         t = mData->emails;
         tAD = ad.mData->emails;
         for ( iii = 0; iii < tAD.count(); ++iii)
             if ( !t.contains(tAD[iii] ) )
                 mData->emails.append( tAD[iii] );
         // ************* categories;
         t = mData->categories;
         tAD = ad.mData->categories;
         for ( iii = 0; iii < tAD.count(); ++iii)
             if ( !t.contains(tAD[iii] ) )
                 mData->categories.append( tAD[iii] );
 
 
     }
 
     QStringList::ConstIterator it;
     for( it = ad.mData->custom.begin(); it != ad.mData->custom.end(); ++it ) {
@@ -337,90 +338,82 @@ void Addressee::mergeContact( const Addressee& ad , bool isSubSet) // = false)
         bool found = false;
         QStringList::ConstIterator itL;
         for( itL = mData->custom.begin(); itL != mData->custom.end(); ++itL ) {
             if ( (*itL).startsWith( qualifiedName ) ) {
                 found = true;
                 break;
             }
         }
         if ( ! found ) {
             mData->custom.append( *it );
         }
     }
     if ( mData->logo.undefined() && !ad.mData->logo.undefined() ) mData->logo = ad.mData->logo;
     if ( mData->photo.undefined() && !ad.mData->photo.undefined() ) mData->photo = ad.mData->photo;
     if ( !mData->sound.isIntern() ) {
         if ( mData->sound.url().isEmpty() ) {
             mData->sound = ad.mData->sound;
         }
     }
     if ( !mData->agent.isIntern() ) {
         if ( mData->agent.url().isEmpty() ) {
             mData->agent = ad.mData->agent;
         }
     }
-
-#if 0
-
- if (  mData->url.isValid() )
-        if ( ! mData->url.path().isEmpty()) l.append( mData->url.path()  ); 
-    KABC::PhoneNumber::List phoneNumbers;
-    KABC::PhoneNumber::List::Iterator phoneIter;
-
-    QStringList t;
-    for ( phoneIter = mData->phoneNumbers.begin(); phoneIter != mData->phoneNumbers.end();
-          ++phoneIter )
-        t.append( ( *phoneIter ).number()+QString::number( ( *phoneIter ).type() ) );
-    t.sort();
-    uint iii;
-    for ( iii = 0; iii < t.count(); ++iii)
-        l.append( t[iii]  );
-    t = mData->emails;
-    t.sort();
-    for ( iii = 0; iii < t.count(); ++iii)
-        l.append( t[iii]  );
-    t = mData->categories;
-    t.sort();
-    for ( iii = 0; iii < t.count(); ++iii)
-        l.append( t[iii]  );
-    t = mData->custom;
-    t.sort();
-    for ( iii = 0; iii < t.count(); ++iii)
-        l.append( t[iii]  );
-    KABC::Address::List::Iterator addressIter;
-    for ( addressIter = mData->addresses.begin(); addressIter != mData->addresses.end();
-          ++addressIter ) {
-        t = (*addressIter).asList();
-        t.sort();
-        for ( iii = 0; iii < t.count(); ++iii)
-            l.append( t[iii]  );
+    { 
+        Key::List::Iterator itA;
+        for( itA = ad.mData->keys.begin(); itA != ad.mData->keys.end(); ++itA ) {
+            bool found = false;
+            Key::List::Iterator it;
+            for( it = mData->keys.begin(); it != mData->keys.end(); ++it ) {
+                if ( (*it) == (*itA)) {
+                    found = true;
+                    break;
+                    
+                }
+            }
+            if ( ! found ) {
+                mData->keys.append( *itA );
+            }
+        }
     }
+    KABC::Address::List::Iterator addressIterA;
+    for ( addressIterA = ad.mData->addresses.begin(); addressIterA != ad.mData->addresses.end(); ++addressIterA ) {
+        bool found = false;
+        KABC::Address::List::Iterator addressIter;
+        for ( addressIter = mData->addresses.begin(); addressIter != mData->addresses.end();
+              ++addressIter ) {
+            if ( (*addressIter) == (*addressIterA)) {
+                found = true;
+                (*addressIter).setType( (*addressIterA).type() );
+                break;
+            }
 
-#endif
-
-    // pending:
-    // merging addresses
-    // merging keys
+        }
+        if ( ! found ) {
+            mData->addresses.append( *addressIterA );
+        }
+    }
     //qDebug("merge contact %s ", ad.uid().latin1());
     setUid( ad.uid() );
     setRevision( ad.revision() );
 }
 
 bool Addressee::removeVoice()
 {
     PhoneNumber::List phoneN = phoneNumbers();
     PhoneNumber::List::Iterator phoneIt;
     bool found = false;
     for ( phoneIt = phoneN.begin(); phoneIt != phoneN.end(); ++phoneIt ) {
         if ( (*phoneIt).type() & PhoneNumber::Voice) { // voice found
             if ((*phoneIt).type() - PhoneNumber::Voice ) {
                 (*phoneIt).setType((*phoneIt).type() - PhoneNumber::Voice );
                 insertPhoneNumber( (*phoneIt) );
                 found = true;
             }
         }
         
     }
     return found;
 }
 
 bool Addressee::containsAdr(const Addressee& ad )
diff --git a/kabc/phonenumber.cpp b/kabc/phonenumber.cpp
index d7e3925..3d82553 100644
--- a/kabc/phonenumber.cpp
+++ b/kabc/phonenumber.cpp
@@ -60,54 +60,76 @@ bool PhoneNumber::operator==( const PhoneNumber &p ) const
   
   return true;
 }
 
 bool PhoneNumber::operator!=( const PhoneNumber &p ) const
 {
   return !( p == *this );
 }
 
 bool PhoneNumber::simplifyNumber()
 {
     QString Number;
     int i;
     Number = mNumber.stripWhiteSpace ();
     mNumber = "";
     for ( i = 0; i < Number.length(); ++i) {
         if ( Number.at(i).isDigit() || Number.at(i) == '+'|| Number.at(i) == '*'|| Number.at(i) == '#' )
             mNumber += Number.at(i);
     }
     return ( mNumber.length() > 0 );
 }
 // make cellphone compatible
 void PhoneNumber::simplifyType()
 {
- if ( mType & Fax ) mType = Fax;
- else if ( mType & Cell ) mType = Cell;
- else if ( mType & Work  ) mType = Work  ;
- else if ( mType & Home ) mType = Home;
- else  mType = Pref;
+    if ( mType & Fax ) mType = Fax;
+    else if ( mType & Cell ) mType = Cell;
+    else if ( mType & Work  ) mType = Work  ;
+    else if ( mType & Home ) mType = Home;
+    else  mType = Pref;
 }
+bool PhoneNumber::contains( const PhoneNumber &p  )
+{
+    QString Number;
+    QString Num;
+    uint i;
+    Number = mNumber.stripWhiteSpace ();
+    Num = "";
+    for ( i = 0; i < Number.length(); ++i) {
+        if ( Number.at(i).isDigit() || Number.at(i) == '+'|| Number.at(i) == '*'|| Number.at(i) == '#' )
+            Num += Number.at(i);
+    }
+    QString NumberR;
+    QString NumR;
+    NumberR = p.mNumber.stripWhiteSpace ();
+    NumR = "";
+    for ( i = 0; i < NumberR.length(); ++i) {
+        if ( NumberR.at(i).isDigit() || NumberR.at(i) == '+'|| NumberR.at(i) == '*'|| NumberR.at(i) == '#' )
+            NumR += NumberR.at(i);
+    }
+    return (Num == NumR);
+}
+
 void PhoneNumber::setId( const QString &id )
 {
   mId = id;
 }
 
 QString PhoneNumber::id() const
 {
   return mId;
 }
 
 void PhoneNumber::setNumber( const QString &number )
 {
   mNumber = number;
 }
 
 QString PhoneNumber::number() const
 {
   return mNumber;
 }
 
 void PhoneNumber::setType( int type )
 {
   mType = type;
 }
diff --git a/kabc/phonenumber.h b/kabc/phonenumber.h
index 410a52f..2d4d3e0 100644
--- a/kabc/phonenumber.h
+++ b/kabc/phonenumber.h
@@ -71,48 +71,49 @@ class PhoneNumber
            Isdn = 2048, Pcs = 4096, Pager = 8192, Sip = 16384 };
 
     /**
       Create an empty phone number object.
     */  
     PhoneNumber();
 
     /**
       Create a phonenumber object.
      
       @param number Number
       @param type   Type as defined in enum. Multiple types can be
                     specified by combining them by a logical or.
     */
     PhoneNumber( const QString &number, int type = Home );
 
     /**
       Destructor.
     */
     ~PhoneNumber();
     
     bool operator==( const PhoneNumber & ) const;
     bool operator!=( const PhoneNumber & ) const;
     
+    bool contains( const PhoneNumber &p  );
     /**
       Sets the unique identifier.
     */
     void setId( const QString &id );
 
     /**
       Returns the unique identifier.
     */
     QString id() const;
     
     /**
       Sets the number.
     */
     void setNumber( const QString & );
 
     /**
       Returns the number.
     */
     QString number() const;
     
     /**
       Sets the type. Multiple types can be specified by combining them by
       a logical or.
     */