source: 3thparty/jmessenger/src/nu/fw/jeti/backend/roster/Roster.java @ 3952

Revision 3952, 20.7 KB checked in by alexandrecorreia, 13 years ago (diff)

Ticket #1710 - Adicao do codigo fonte java do componente jmessenger(jabberit_messenger)
  • Property svn:executable set to *
Line 
1/*
2 *      Jeti, a Java Jabber client, Copyright (C) 2001 E.S. de Boer 
3 *
4 *  This program is free software; you can redistribute it and/or modify
5 *  it under the terms of the GNU General Public License as published by
6 *  the Free Software Foundation; either version 2 of the License, or
7 *  (at your option) any later version.
8 *
9 *  This program is distributed in the hope that it will be useful,
10 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
11 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 *      GNU General Public License for more details.
13 *
14 *  You should have received a copy of the GNU General Public License
15 *  along with this program; if not, write to the Free Software
16 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17 *
18 *      For questions, comments etc,
19 *      use the website at http://jeti.jabberstudio.org
20 *  or mail me at jeti@jabberstudio.org
21 *  created 2001
22 */
23
24package nu.fw.jeti.backend.roster;
25
26import java.lang.reflect.InvocationTargetException;
27import java.util.HashMap;
28import java.util.Iterator;
29import java.util.List;
30import java.util.Map;
31
32import javax.swing.SwingUtilities;
33
34import nu.fw.jeti.events.CompleteRosterListener;
35import nu.fw.jeti.events.PresenceListener;
36import nu.fw.jeti.events.RosterListener;
37import nu.fw.jeti.jabber.Backend;
38import nu.fw.jeti.jabber.JID;
39import nu.fw.jeti.jabber.JIDStatus;
40import nu.fw.jeti.jabber.elements.IQXRoster;
41import nu.fw.jeti.jabber.elements.InfoQuery;
42import nu.fw.jeti.jabber.elements.Presence;
43import nu.fw.jeti.jabber.elements.RosterItem;
44import nu.fw.jeti.util.I18N;
45import nu.fw.jeti.util.Preferences;
46
47/**
48 * Class that controls the Roster. JIDS whithout a username
49 * are assumed to be a transport/server and are transfered to Server.
50 * The items in the roster are sorted stored.
51 * Changes in the roster are broadcasted using the RosterListener
52 * @see Server
53 * @see RosterListener
54 * @author E.S. de Boer
55 * @version 1.0
56 */
57
58public class Roster implements CompleteRosterListener, PresenceListener
59{
60        private JIDStatusTree jidTree;
61        private static Map jidStatussen = new HashMap(32); //default 20 different?;//fast access to tree
62        private Backend backend;
63        private boolean first; //server hack
64        private Server server;
65       
66        public Roster(Backend backend, Server server)
67        {
68                this.server = server;
69                this.backend = backend;
70                backend.addListener(CompleteRosterListener.class, this);
71                backend.addListener(PresenceListener.class, this);
72        }
73
74        //-------------------roster events--------------------------------------\\
75        public void rosterReceived(final InfoQuery infoquery, final IQXRoster roster)
76        {
77                Runnable updateAComponent = new Runnable() {
78                        public void run()
79                        {
80                                if (infoquery.getType().equals("result"))
81                                {
82                                        //complete new roster
83                                        completeRoster(roster);
84                                }
85                                else if (infoquery.getType().equals("set"))
86                                {
87                                        //add result
88                                        for (Iterator i = roster.getItems(); i.hasNext();)
89                                        {
90                                                RosterItem item = (RosterItem) i.next();
91                                                JID jid = item.getJID();
92                                                String nick = item.getName();
93                                                if (nick == null) nick = jid.toString();
94                                                NormalJIDStatus oldJIDStatus = (NormalJIDStatus) jidStatussen.get(jid);
95                                                if ("remove".equals(item.getSubscription()))
96                                                {
97                                                        removeFromRoster(oldJIDStatus, item, jid);
98                                                }
99                                                else if (oldJIDStatus == null)
100                                                {
101                                                        //group must be present (no unfiled) except when server
102                                                        if (item.getGroups() != null || jid.getUser() == null) addToRoster(nick, item, jid);
103                                                }
104                                                else
105                                                {
106                                                        changeItem(oldJIDStatus, nick, item, jid);
107                                                }
108                                        }
109                                }
110                        }
111                };
112                try
113                {
114                        SwingUtilities.invokeAndWait(updateAComponent);
115                } catch (InterruptedException e)
116                {
117                        e.printStackTrace();
118                } catch (InvocationTargetException e)
119                {
120                        e.printStackTrace();
121                }
122        }
123
124        private void completeRoster(IQXRoster roster)
125        {
126                //add complete roster
127                //System.out.println("result");
128                jidStatussen = new HashMap(32); //default 20 different?
129                server.addJIDStatussen(jidStatussen);
130                jidTree = new JIDStatusTree();
131                server.clear();
132                for (Iterator i = roster.getItems(); i.hasNext();)
133                {
134                        RosterItem item = (RosterItem) i.next();
135                        JIDStatus jidStatus = new NormalJIDStatus(item);
136                        jidStatussen.put(item.getJID(), jidStatus);
137                        if (item.getJID().getUser() == null)
138                        {
139                                //server /transport
140                                server.addServerNoFire(jidStatus);
141                        }
142                        else
143                        {
144                                if (item.getGroups() == null)
145                                        addJIDStatus(I18N.gettext("main.main.roster.Unfiled"), jidStatus);
146                                else
147                                {
148                                        for (Iterator j = item.getGroups().iterator(); j.hasNext();)
149                                        {
150                                                //new jidstatus per group?
151                                                addJIDStatus((String) j.next(), jidStatus);
152                                        }
153                                }
154                        }
155                }
156                backend.rosterLoaded();
157                server.fire();
158                for (Iterator j = backend.getListeners(RosterListener.class); j.hasNext();)
159                {
160                        ((RosterListener) j.next()).rosterReplaced(jidTree);
161                }
162        }
163
164        private void removeFromRoster(NormalJIDStatus oldJIDStatus, RosterItem item, JID jid)
165        {
166                if (oldJIDStatus == null)
167                        return; //jidstatus unknown
168                String oldNick = oldJIDStatus.getNick();
169                if (item.getJID().getUser() == null)
170                {
171                        //server /transport
172                        server.removeServer(oldNick, oldJIDStatus);
173                }
174                else
175                {
176                        if (oldJIDStatus.groupCount() < 1)
177                        {
178                                //unknown group
179                                removeJIDStatus(I18N.gettext("main.main.roster.Unfiled"), oldNick, oldJIDStatus);
180                        }
181                        else
182                        {
183                                //known groups
184                                for (Iterator j = oldJIDStatus.getGroups(); j.hasNext();)
185                                {
186                                        //remove
187                                        removeJIDStatus((String) j.next(), oldNick, oldJIDStatus);
188                                }
189                        }
190                }
191                jidStatussen.remove(jid); //remove from cache
192        }
193
194        private void addToRoster(String nick, RosterItem item, JID jid)
195        {
196                if (!first && (item.getGroups() == null || item.getName() == null))
197                {
198                        //server sends first a rosterset without nickname and groups
199                        //we don't need that because it generates a new group or new nicknames
200                        first = true; //first time sended
201                        return;
202                }
203                first = false;
204                //System.out.println("addnew");
205                NormalJIDStatus jidStatus = new NormalJIDStatus(item);
206                jidStatussen.put(jid, jidStatus);
207                if (jid.getUser() == null)
208                {
209                        //server /transport
210                        server.addServer(nick, jidStatus);
211                }
212                else if (item.getGroups() == null)
213                {
214                        //no groups only when complete roster
215                        addJIDStatusFire(I18N.gettext("main.main.roster.Unfiled"), nick, jidStatus);
216                }
217                else
218                {
219                        for (Iterator j = item.getGroups().iterator(); j.hasNext();)
220                        {
221                                //new jidstatus per group?
222                                addJIDStatusFire((String) j.next(), nick, jidStatus);
223                        }
224                }
225        }
226
227        private void changeItem(NormalJIDStatus oldJIDStatus, String nick, RosterItem item, JID jid)
228        {
229                //group nickname or other change to rosteritem
230                if (!nick.equals(oldJIDStatus.getNick()))
231                {
232                        //nick changes
233                        nickChanges(oldJIDStatus, nick, item, jid);
234                }
235                if (jid.getUser() == null) //no else because change nick & change groups could be at same time
236                {
237                        //server doesn't care about groups
238                        oldJIDStatus.update(item);
239                }
240                else if (item.getGroups() == null)
241                {
242                        //heeft 0 groups
243                        if (oldJIDStatus.groupCount() < 1)
244                                oldJIDStatus.update(item); //had 0 heeft 0 overbodig?
245                        else
246                        {
247                                if (!oldJIDStatus.isGroupPresent(I18N.gettext("main.main.roster.Unfiled")))
248                                {
249                                        //heeft 0 had meer
250                                        for (Iterator j = oldJIDStatus.getGroups(); j.hasNext();)
251                                        {
252                                                //remove
253                                                removeJIDStatus((String) j.next(), nick, oldJIDStatus);
254                                        }
255                                        addJIDStatusFire(I18N.gettext("main.main.roster.Unfiled"), nick, oldJIDStatus); //add to unfiled
256                                        oldJIDStatus.update(item);
257                                }
258                        }
259                }
260                else
261                {
262                        changeGroups(oldJIDStatus, nick, item);
263                }
264        }
265
266        private void nickChanges(NormalJIDStatus oldJIDStatus, String nick, RosterItem item, JID jid)
267        {
268                //nickname changed
269                String oldNick = oldJIDStatus.getNick();
270                if (jid.getUser() == null)
271                {
272                        //server /transport
273                        server.removeServer(oldNick, oldJIDStatus);
274                        oldJIDStatus.update(item);
275                        server.addServer(nick, oldJIDStatus);
276                }
277                else
278                {
279                        //nickname is different so new primarys
280                        //System.out.println("remove old nicknames");
281                        //remove old
282                        if (oldJIDStatus.groupCount() < 1)
283                        {
284                                //unknown group
285                                removeJIDStatus(I18N.gettext("main.main.roster.Unfiled"), oldNick, oldJIDStatus);
286                        }
287                        else
288                        {
289                                //known groups
290                                for (Iterator j = oldJIDStatus.getGroups(); j.hasNext();)
291                                {
292                                        //remove
293                                        removeJIDStatus((String) j.next(), oldNick, oldJIDStatus);
294                                }
295                        }
296                        oldJIDStatus.update(item);
297                        //addnew
298                        if (item.getGroups() == null)
299                        {
300                                addJIDStatusFire(I18N.gettext("main.main.roster.Unfiled"), nick, oldJIDStatus);
301                        }
302                        else
303                        {
304                                for (Iterator j = item.getGroups().iterator(); j.hasNext();)
305                                {
306                                        //new jidstatus per group?
307                                        addJIDStatusFire((String) j.next(), nick, oldJIDStatus);
308                                }
309                        }
310                }
311               
312        }
313
314        private void changeGroups(NormalJIDStatus oldJIDStatus, String nick, RosterItem item)
315        {
316                /*
317                if(oldJIDStatus.groupCount() < 1)//overbodig??
318                {//had 0 heeft meer
319                        removeJIDStatus("Unfiled",nick,oldJIDStatus);
320                        for(Iterator j = item.getGroups().iterator();j.hasNext();)
321                        {//new jidstatus per group?
322                                addJIDStatusFire((String) j.next(),nick,oldJIDStatus);
323                        }
324                        oldJIDStatus.update(item);
325                }
326                else
327                */
328                //{//heeft x had y
329                List oldGroups = oldJIDStatus.getGroupsCopy();
330                for (Iterator j = item.getGroups().iterator(); j.hasNext();)
331                {
332                        //new jidstatus per group?
333                        String newGroup = (String) j.next();
334                        if (oldGroups.contains(newGroup))
335                                oldGroups.remove(newGroup);
336                        else
337                                addJIDStatusFire(newGroup, nick, oldJIDStatus);
338                }
339                for (Iterator j = oldGroups.iterator(); j.hasNext();)
340                {
341                        //remove old groups
342                        removeJIDStatus((String) j.next(), nick, oldJIDStatus);
343                }
344                oldJIDStatus.update(item);
345                //}
346        }
347
348        //---------------------add //remove //change methods--------------------------------------
349        private void addJIDStatus(String group, JIDStatus jidStatus)
350        {
351                //add jidstatus for complete roster the roster will be completely refreshed so no fires per jidstatus
352                JIDStatusGroup jidGroup = jidTree.getGroup(group);
353                PrimaryJIDStatus primary = jidGroup.searchPrimaryJIDStatus(jidStatus.getNick());
354                if (primary == null)
355                {
356                        primary = new PrimaryJIDStatus(jidStatus.getNick(),jidStatus);
357                        jidGroup.addPrimaryJIDStatus(primary);
358                }
359                else primary.addJIDStatus(jidStatus);
360                //jidGroup.sort();
361        }
362
363        private void addJIDStatusFire(String group, String nick, NormalJIDStatus normalJIDStatus)
364        {
365        //      System.out.println("add");
366                JIDStatusGroup jidGroup;
367                if (!jidTree.existGroup(group))
368                {
369                        jidGroup = jidTree.getGroup(group);
370                        int index = jidTree.indexOfGroup(jidGroup);
371                        for (Iterator j = backend.getListeners(RosterListener.class); j.hasNext();)
372                        {
373                                //fire group make
374                                 ((RosterListener) j.next()).groupAdded(jidGroup, index);
375                        }
376                }
377                else jidGroup = jidTree.getGroup(group);
378                PrimaryJIDStatus primary = jidGroup.searchPrimaryJIDStatus(nick);
379                for (Iterator i = normalJIDStatus.getSecondaryJIDStatussen(); i.hasNext();)
380                {//add secondary jidstatussen
381                        SecondaryJIDStatus jidStatus = (SecondaryJIDStatus) i.next();
382                        // bug if primary was offline but now becomes online
383                        // then odd results so now do things slower but consistent
384                        //(add is rare so no problem)
385                        primary = addJIDStatus(nick, jidGroup, primary, jidStatus);
386                }
387                primary = addJIDStatus(nick, jidGroup, primary, normalJIDStatus);
388                primary.updatePresence(normalJIDStatus);
389                boolean oldOnline = primary.isOnline();
390                primary.updateOnline();
391                if(!oldOnline && primary.isOnline())
392                {//add online
393                        jidGroup.addOnline();
394                        for (Iterator j = backend.getListeners(RosterListener.class); j.hasNext();)
395                        {
396                                ((RosterListener) j.next()).groupUpdated(jidGroup, jidTree.indexOfGroup(jidGroup));
397                        }       
398                }
399                               
400        //      {//fire update if changed (faster)     
401        //              int index = jidGroup.indexOfPrimaryJIDStatus(primary);
402                        for (Iterator j = backend.getListeners(RosterListener.class); j.hasNext();)
403                        {
404                                ((RosterListener) j.next()).jidStatussenUpdated(jidGroup,primary);
405                                //primaryUpdated(jidGroup, primary,index);
406                        }
407        //      }
408                               
409               
410                /*
411                else if(primary.addJIDStatus(jidStatus))
412                { //fire update
413                        int index = jidGroup.indexOfPrimaryJIDStatus(primary);
414                        for(Iterator j = backend.getListeners(RosterListener.class);j.hasNext();)
415                        {
416                                ((RosterListener)j.next()).primaryUpdated(jidGroup,primary,index);
417                        }
418                }
419                else
420                {//primary doesn't change
421                        int index = primary.indexOfJIDStatus(jidStatus);
422                        for(Iterator j = backend.getListeners(RosterListener.class);j.hasNext();)
423                        {
424                                ((RosterListener)j.next()).jidStatusAdded(jidGroup,primary,jidStatus,index);
425                        }
426                }
427                */
428                //primary.updatePresence(secondary);
429
430                /*
431                for(Iterator j = backend.getListeners(RosterListener.class);j.hasNext();)
432                {
433                        ((RosterListener)j.next()).jidStatussenUpdated(jidGroup,primary);
434                }
435                */
436        }
437        private PrimaryJIDStatus addJIDStatus(String nick, JIDStatusGroup jidGroup, PrimaryJIDStatus primary, SecondaryJIDStatus jidStatus)
438        {
439                if (primary == null)
440                {
441                        primary = new PrimaryJIDStatus(nick,jidStatus);
442                        jidGroup.addPrimaryJIDStatus(primary);
443                        //primary.addJIDStatus(jidStatus);
444                        int index = jidGroup.indexOfPrimaryJIDStatus(primary);
445                        for (Iterator j = backend.getListeners(RosterListener.class); j.hasNext();)
446                        {//fire add primary
447                                 ((RosterListener) j.next()).primaryAdded(jidGroup, primary, index);
448                        }
449                }
450                else
451                {
452                        primary.addJIDStatus(jidStatus);
453//                      int index = primary.indexOfJIDStatus(jidStatus);
454//                      for(Iterator j = backend.getListeners(RosterListener.class);j.hasNext();)
455//                      {//fire add jidstatus
456//                              ((RosterListener)j.next()).jidStatusAdded(jidGroup,primary,jidStatus,index);
457//                             
458//                      }
459                }
460//              primary.updatePresence(jidStatus);
461                return primary;
462        }
463
464        private void removeJIDStatus(String group, String nick, NormalJIDStatus jidStatus)
465        {
466                //System.out.println("remove");
467                JIDStatusGroup jidGroup = jidTree.getGroup(group);
468                PrimaryJIDStatus primary = jidGroup.searchPrimaryJIDStatus(nick);
469                boolean oldOnline = primary.isOnline();
470                for (Iterator i = jidStatus.getSecondaryJIDStatussen(); i.hasNext();)
471                {
472                        SecondaryJIDStatus secondaryJIDStatus = (SecondaryJIDStatus) i.next();
473                        if (removeJIDStatus2(secondaryJIDStatus, jidGroup, primary))
474                        {
475                                if(oldOnline)
476                                {//gone offline
477                                        jidGroup.removeOnline();
478                                        for (Iterator j = backend.getListeners(RosterListener.class); j.hasNext();)
479                                        {
480                                                ((RosterListener) j.next()).groupUpdated(jidGroup, jidTree.indexOfGroup(jidGroup));
481                                        }
482                                }
483                                return;
484                        }
485                }
486                boolean deleted = removeJIDStatus2(jidStatus, jidGroup, primary);
487                if(!deleted) primary.updateOnline();
488                if(((deleted && oldOnline) || (oldOnline && !primary.isOnline()))
489            && -1 != jidTree.indexOfGroup(jidGroup))
490                {//gone offline
491                        jidGroup.removeOnline();
492                        for (Iterator j = backend.getListeners(RosterListener.class); j.hasNext();)
493                        {
494                                ((RosterListener) j.next()).groupUpdated(jidGroup, jidTree.indexOfGroup(jidGroup));
495                        }
496                }
497                //fire update
498                for (Iterator j = backend.getListeners(RosterListener.class); j.hasNext();)
499                {
500                        ((RosterListener) j.next()).jidStatussenUpdated(jidGroup, primary);
501                }
502        }
503
504        private boolean removeJIDStatus2(JIDStatus jidStatus, JIDStatusGroup jidGroup, PrimaryJIDStatus primary)
505        {
506                //return true if primary deleted
507                //int jidStatusIndex =0;
508                //if(primary.hasMultiple()) jidStatusIndex = primary.indexOfJIDStatus(jidStatus);
509                if (primary.removeJIDStatus(jidStatus))
510                {
511                        //if (primary.isEmpty())
512                        {
513                                int index = jidGroup.indexOfPrimaryJIDStatus(primary);
514                                jidGroup.removePrimaryJIDStatus(primary);
515                                for (Iterator j = backend.getListeners(RosterListener.class); j.hasNext();)
516                                {
517                                        //fire delete
518                                         ((RosterListener) j.next()).primaryDeleted(jidGroup, primary, index);
519                                }
520                                //fire remove
521                                if (jidGroup.size() < 1)
522                                {
523                                        //fire group remove
524                                        int index2 = jidTree.indexOfGroup(jidGroup);
525                                        jidTree.removeGroup(jidGroup);
526                                        for (Iterator j = backend.getListeners(RosterListener.class); j.hasNext();)
527                                        {
528                                                //fire group delete
529                                                 ((RosterListener) j.next()).groupDeleted(jidGroup, index2);
530                                        }
531                                }
532                                return true;
533                        }
534                        //                      else
535                        //                      {//fire update
536                        //                              for(Iterator j = backend.getListeners(RosterListener.class);j.hasNext();)
537                        //                              {
538                        //                                      ((RosterListener)j.next()).jidStatussenUpdated(jidGroup,primary);
539                        //                              }
540                        //                      }
541                }
542                //              else
543                //              {//primary doesn't change
544                //                      for(Iterator j = backend.getListeners(RosterListener.class);j.hasNext();)
545                //                      {
546                //                              ((RosterListener)j.next()).jidStatusDeleted(jidGroup,primary,jidStatus,jidStatusIndex);
547                //                      }
548                //              }
549                return false;
550        }
551
552        //------------------------------Prescence event------------------------------------\\
553
554        public void presenceChanged(final Presence presence)
555        {
556                JID jid = presence.getFrom();
557                final NormalJIDStatus jidStatus = (NormalJIDStatus) jidStatussen.get(jid);
558                if (jidStatus == null)
559                {
560                        return;
561                }
562                if (jid.getUser() == null)
563                {
564                        //server, server has no multiple resources
565                        jidStatus.updatePresence(presence);
566                        server.showChange(jidStatus);
567                        return;
568                }
569                SecondaryJIDStatus secondary = jidStatus.getSecondaryJIDStatus(jid.getResource());
570                boolean seconderyAdded = false;
571                ResourceJIDStatus remove = null;
572                if (presence.getShow() == Presence.UNAVAILABLE)
573                {
574                        remove = jidStatus.removeResource(jid.getResource());
575                        if (remove == null)
576                        {
577                                //no remove so no resource so update presence to unavailable
578                                secondary.updatePresence(presence);
579                        }
580                }
581                else
582                {
583                        if (secondary == null)
584                        {
585                                //new resource
586                                secondary = jidStatus.addSecondaryJIDStatus(jid);
587                                seconderyAdded = true;
588                        }
589                        else if (secondary.getShow() == presence.getShow())
590                        {//show hasn't changed
591                                if(secondary.getType().equals("msn") && secondary.getStatus()!=null
592                                                &&  Preferences.getBoolean("jeti","showRealNick", false))
593                                {//should status be visible?  old msn transport hack, remove when new nick mechanism
594                                        if(!secondary.getStatus().equals(presence.getStatus()))
595                                        {//status has changed
596                                                final SecondaryJIDStatus secondary2 = secondary;
597                                                Runnable updateAComponent = new Runnable() {
598                                                        public void run()
599                                                        {
600                                                                secondary2.updatePresence(presence);
601                                                                for (Iterator i = jidStatus.getGroups(); i.hasNext();)
602                                                                {//update tree part status is in, replace by update only the changed part?
603                                                                        JIDStatusGroup jidGroup = jidTree.getGroup((String) i.next());
604                                                                        PrimaryJIDStatus primary = jidGroup.searchPrimaryJIDStatus(jidStatus.getNick());
605                                                                        for (Iterator j = backend.getListeners(RosterListener.class); j.hasNext();)
606                                                                        {
607                                                                                ((RosterListener) j.next()).jidStatussenUpdated(jidGroup, primary);
608                                                                        }
609                                                                }
610                                                        }
611                                                };
612                                                SwingUtilities.invokeLater(updateAComponent);
613                                        }
614                                }
615                                secondary.updatePresence(presence);
616                                return;
617                        }
618                        secondary.updatePresence(presence);
619                        //show has changed so update
620                         jidStatus.sortSecondary();
621                }
622               
623                final SecondaryJIDStatus secondary2 = secondary;
624                final boolean seconderyAdded2 = seconderyAdded;
625                final ResourceJIDStatus remove2=remove;
626               
627                Runnable updateAComponent = new Runnable() {
628                        public void run()
629                        {
630//                              change
631                                for (Iterator i = jidStatus.getGroups(); i.hasNext();)
632                                {
633                                        //new jidstatus per group?
634                                        JIDStatusGroup jidGroup = jidTree.getGroup((String) i.next());
635                                        PrimaryJIDStatus primary = jidGroup.searchPrimaryJIDStatus(jidStatus.getNick());
636                                        if (seconderyAdded2) primary.addJIDStatus(secondary2);
637                                        if (remove2 != null) primary.removeJIDStatus(remove2);
638                                        else if (secondary2 != null) primary.updatePresence(secondary2);
639                                        boolean oldOnline = primary.isOnline();
640                                        primary.updateOnline();
641                                        boolean newOnline = primary.isOnline();
642                                        if(oldOnline && !newOnline)
643                                        {//gone offline
644                                                jidGroup.removeOnline();
645                                                for (Iterator j = backend.getListeners(RosterListener.class); j.hasNext();)
646                                                {
647                                                        ((RosterListener) j.next()).groupUpdated(jidGroup, jidTree.indexOfGroup(jidGroup));
648                                                }
649                                        }
650                                        else if(!oldOnline && newOnline)
651                                        {//gone online
652                                                jidGroup.addOnline();
653                                                for (Iterator j = backend.getListeners(RosterListener.class); j.hasNext();)
654                                                {
655                                                        ((RosterListener) j.next()).groupUpdated(jidGroup, jidTree.indexOfGroup(jidGroup));
656                                                }       
657                                        }
658                                        //int index = jidGroup.indexOfPrimaryJIDStatus(primary);
659                                        for (Iterator j = backend.getListeners(RosterListener.class); j.hasNext();)
660                                        {
661                                                ((RosterListener) j.next()).jidStatussenUpdated(jidGroup, primary);
662                                        }
663                                }
664                        }
665                };
666                try
667                {
668                        SwingUtilities.invokeAndWait(updateAComponent);
669                } catch (InterruptedException e)
670                {
671                        e.printStackTrace();
672                } catch (InvocationTargetException e)
673                {
674                        e.printStackTrace();
675                }
676        }
677
678        public static JIDStatus getJIDStatus(JID jid)
679        {
680                return (JIDStatus) jidStatussen.get(jid);
681        }
682       
683        public static Iterator getJIDStatussen()
684        {
685                return jidStatussen.values().iterator();
686        }
687
688        public String[] getAllGroups()
689        {
690                if (jidTree==null) return new String[]{ I18N.gettext("main.main.roster.Friends") };
691                return jidTree.getGroups();
692        }
693}
694
695/*
696 * Overrides for emacs
697 * Local variables:
698 * tab-width: 4
699 * End:
700 */
Note: See TracBrowser for help on using the repository browser.