← Back to branch summary

~ubuntu-branches/ubuntu/karmic/eva/karmic

« back to all changes in this revision

Viewing changes to src/libeva/evaqunlist.cpp

  • Committer: Bazaar Package Importer
  • Author(s): ZhengPeng Hou
  • Date: 2008-02-15 12:41:06 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20080215124106-x3mvc2nharfsl99l
Tags: 0.4.9+svn20080215-0ubuntu1
New upstream SVN release, upstream has switched to
svn now. 

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/libeva/evaqunlist.cpp
69
69
        : qunID(id), cardName(""), cardGender(0), cardPhone(""), cardEmail(""), cardMemo(""),
70
70
        m_RealNamesVersion(0), msgType(Notify), m_ChatFontSize(9), m_ChatFontColor(0)
71
71
{
 
72
        m_memberStartCount = 0;
 
73
        m_bFirstRefresh = true;
72
74
}
73
75
 
74
76
Qun::Qun(const Qun &rhs)
80
82
{
81
83
        qunID = rhs.getQunID();
82
84
        info = rhs.getDetails();
83
 
        numberList = rhs.getQQList();
 
85
        //numberList = rhs.getQQList();
84
86
        memberList = rhs.getMembers();
 
87
        memberArgs = rhs.getMemberArgs();
85
88
        tmpQunList = rhs.getTmpQunList();
86
89
        cardName = rhs.getCardName();
87
90
        cardGender = rhs.getCardGender();
93
96
 
94
97
        m_ChatFontSize = rhs.getChatFontSize();
95
98
        m_ChatFontColor = rhs.getChatFontColor();
96
 
        
 
99
 
97
100
        return *this;
98
101
}
99
102
 
101
104
{
102
105
        std::list<FriendItem> list = l;
103
106
        std::list<FriendItem>::iterator iter;
 
107
        std::list<FriendItem>::iterator iter1;
104
108
        for(iter = list.begin(); iter!= list.end(); ++iter){
105
 
                std::list<FriendItem>::iterator iter1;
106
109
                for(iter1 = memberList.begin(); iter1!= memberList.end(); ++iter1){
107
110
                        if(iter1->getQQ() == iter->getQQ()){
108
 
                                // since this method is always called right after updating qun info
109
 
                                // therefore, we use the old real name record at the moment, next time
110
 
                                // when user open a Qun chat window, real name will be updated 
111
 
                                // automatically
112
 
                                iter->setQunRealName(iter1->getQunRealName()); 
113
 
                                memberList.erase(iter1);
114
 
                                break;
 
111
                                break;
115
112
                        }
116
113
                }
117
 
        }
118
 
 
119
 
        std::map<unsigned int, QunMember>::iterator it;
120
 
        
121
 
        for(iter = list.begin(); iter!= list.end(); ++iter){
122
 
                it = memberArgs.find(iter->getQQ());
123
 
                if(it != memberArgs.end()){
124
 
                        iter->setQunGroupIndex(it->second.groupIndex);
125
 
                        iter->setQunAdminValue(it->second.admin);
 
114
                if(iter1 != memberList.end()){ // already in our list
 
115
                        iter->setQunRealName(iter1->getQunRealName());
 
116
                        iter->setQunGroupIndex(iter1->getQunGroupIndex());
 
117
                        iter->setQunAdminValue(iter1->getQunAdminValue());
 
118
                        (*iter1) = (*iter);
 
119
                }else{ // new guy, just add it
 
120
                        memberList.push_back(*iter);
126
121
                }
127
 
                memberList.push_back(*iter);
128
122
        }
129
123
}
130
124
 
140
134
                                iter->setOnline(true);
141
135
                }
142
136
        }
143
 
        //numberList = list;
144
137
}
145
138
 
146
139
const FriendItem *Qun::getMemberDetails( const unsigned int qqNum ) 
169
162
        std::list<FriendItem>::iterator iter;
170
163
        for(iter = memberList.begin(); iter!= memberList.end(); ++iter){
171
164
                if(iter->getQQ() == item.getQQ()){
172
 
                        memberList.erase(iter);
 
165
                        item.setQunGroupIndex(iter->getQunGroupIndex());
 
166
                        item.setQunAdminValue(iter->getQunAdminValue());
 
167
                        (*iter) = item;
173
168
                        break;
174
169
                }
175
170
        }
176
 
        
177
 
        std::map<unsigned int, QunMember>::iterator it = memberArgs.find(item.getQQ());
178
 
        if(it != memberArgs.end()){
179
 
                item.setQunGroupIndex(it->second.groupIndex);
180
 
                item.setQunAdminValue(it->second.admin);
 
171
        if(iter == memberList.end()){
 
172
                std::map<unsigned int, QunMember>::iterator it = memberArgs.find(item.getQQ());
 
173
                if( it != memberArgs.end()){
 
174
                        item.setQunGroupIndex(it->second.groupIndex);
 
175
                        item.setQunAdminValue(it->second.admin);
 
176
                }
 
177
                memberList.push_back(item);
181
178
        }
182
 
        memberList.push_back(item);
183
179
}
184
180
 
185
181
void Qun::addTmpQun( const TmpQun & q )
191
187
{
192
188
        memberArgs = list;
193
189
        m_RealNamesVersion = 0;
194
 
        numberList.clear();
195
 
        /// if we clear this list, the real name setting will lost
196
 
        //memberList.clear(); 
 
190
 
 
191
        std::map<unsigned int, QunMember>::iterator it;
 
192
        std::list<FriendItem>::iterator iter;
 
193
 
 
194
        std::map<unsigned int, bool> toRemove; //record those members who are kicked out from this Qun
 
195
        for(iter = memberList.begin(); iter != memberList.end(); ++ iter){
 
196
                toRemove[iter->getQQ()] = true;
 
197
        }
 
198
        // try every member in memberArgs, check if already in
 
199
        // in our memberList. if it is we'll use the old one
 
200
        // otherwise use the memberArgs one
 
201
        for(it = memberArgs.begin(); it!=memberArgs.end(); ++it){
 
202
                for(iter = memberList.begin(); iter != memberList.end(); ++ iter){
 
203
                        if(iter->getQQ() == it->first){
 
204
                                toRemove.erase(iter->getQQ());
 
205
                                iter->setQunGroupIndex( it->second.groupIndex);
 
206
                                iter->setQunAdminValue( it->second.admin);
 
207
                                break;
 
208
                        }
 
209
                }
 
210
                if(iter != memberList.end()) continue; // we have deleted it
 
211
                
 
212
                FriendItem item(it->first);
 
213
                item.setQunGroupIndex( it->second.groupIndex);
 
214
                item.setQunAdminValue( it->second.admin);
 
215
                memberList.push_back(item);
 
216
        }
197
217
        
198
 
        std::list<FriendItem> tmpList;
 
218
        // remove those NOT existed members
 
219
        std::map<unsigned int, bool>::iterator remvIt;
 
220
        iter = memberList.begin();
 
221
        while(iter != memberList.end()){
 
222
                remvIt = toRemove.find(iter->getQQ());
 
223
                if(remvIt != toRemove.end()){
 
224
                        memberList.erase(iter);
 
225
                        toRemove.erase(remvIt);
 
226
                        iter = memberList.begin();
 
227
                } else
 
228
                        iter++;
 
229
        }
 
230
}
199
231
 
200
 
        std::map<unsigned int, QunMember>::iterator it;
 
232
std::list<unsigned int> Qun::getNextMembers()
 
233
{
 
234
        std::list<unsigned int> list;
 
235
        unsigned int i = 0;
 
236
        if(m_memberStartCount == memberList.size() ) return list;
201
237
        std::list<FriendItem>::iterator iter;
202
238
        for(iter = memberList.begin(); iter!= memberList.end(); ++iter){
203
 
                it = memberArgs.find(iter->getQQ());
204
 
                if(it!= memberArgs.end()){
205
 
                        tmpList.push_back(*iter);
 
239
                if(i >= m_memberStartCount){
 
240
                        if(i > m_memberStartCount + 30) break;
 
241
                        list.push_back(iter->getQQ());
206
242
                }
 
243
                i++;
207
244
        }
208
 
        memberList.clear();
209
 
        memberList = tmpList;
 
245
        m_memberStartCount += list.size();
 
246
        return list;
210
247
}
211
248
 
212
249
const  bool Qun::isAdmin( const unsigned int id)
238
275
QunList &QunList::operator=(const QunList &rhs)
239
276
{
240
277
        qunList = rhs.getQunList();
 
278
        m_iter = qunList.begin();
241
279
        return *this;
242
280
}
243
281
 
277
315
        return NULL;
278
316
}
279
317
 
 
318
Qun * QunList::getQunByExtID( const unsigned int ext )
 
319
{
 
320
        std::list<Qun>::iterator iter;
 
321
        for(iter = qunList.begin(); iter!=qunList.end(); ++iter){
 
322
                if(iter->getExtQunID() == ext){
 
323
                        return &(*iter);
 
324
                }
 
325
        }
 
326
        return NULL;
 
327
}
 
328
 
280
329
void QunList::setDetails( const QunInfo & info )
281
330
{
282
331
        std::list<Qun>::iterator iter;
321
370
        }
322
371
}
323
372
 
324
 
void QunList::setQQList(const unsigned int id, const std::list<unsigned int> &list)
325
 
{
326
 
        std::list<Qun>::iterator iter;
327
 
        for(iter = qunList.begin(); iter!= qunList.end(); ++iter){
328
 
                if(iter->getQunID() == id){
329
 
                        iter->setQQList(list);
330
 
                        return;
331
 
                }
332
 
        }
333
 
}
 
373
// void QunList::setQQList(const unsigned int id, const std::list<unsigned int> &list)
 
374
// {
 
375
//      std::list<Qun>::iterator iter;
 
376
//      for(iter = qunList.begin(); iter!= qunList.end(); ++iter){
 
377
//              if(iter->getQunID() == id){
 
378
//                      iter->setQQList(list);
 
379
//                      return;
 
380
//              }
 
381
//      }
 
382
// }
334
383
 
335
384
void QunList::setMemberArgs(const unsigned int id, const std::map<unsigned int, QunMember> &list)
336
385
{
358
407
                }
359
408
        }       
360
409
}
 
410
 
 
411
Qun * QunList::first( )
 
412
{
 
413
        m_iter = qunList.begin();
 
414
        if(m_iter == qunList.end())
 
415
                return NULL;
 
416
        return &(*m_iter);
 
417
}
 
418
 
 
419
Qun * QunList::next( )
 
420
{
 
421
        m_iter++;
 
422
        if(m_iter == qunList.end())
 
423
                return NULL;
 
424
        return &(*m_iter);
 
425
}
 
426
 
 
427
const unsigned int QunList::getQunExtID( const unsigned int id )
 
428
{
 
429
        Qun *q = getQun(id);
 
430
        if(q)
 
431
                return q->getExtQunID();
 
432
        return 0;
 
433
}