Mercurial > ~mikael > mcabber > hg
annotate mcabber/src/roster.c @ 848:a9161d2dc414
Introduce special buffer stuff
Update roster and commands: add support for a new "special" kind of buffer.
A special buffer "[status]" is automatically created at startup.
| author | Mikael Berthe <mikael@lilotux.net> |
|---|---|
| date | Mon, 08 May 2006 23:45:58 +0200 |
| parents | 915a7f17474a |
| children | a8fadbd97858 |
| rev | line source |
|---|---|
| 72 | 1 /* |
| 2 * roster.c -- Local roster implementation | |
| 393 | 3 * |
| 699 | 4 * Copyright (C) 2005, 2006 Mikael Berthe <bmikael@lists.lilotux.net> |
| 72 | 5 * |
| 6 * This program is free software; you can redistribute it and/or modify | |
| 7 * it under the terms of the GNU General Public License as published by | |
| 8 * the Free Software Foundation; either version 2 of the License, or (at | |
| 9 * your option) any later version. | |
| 10 * | |
| 11 * This program is distributed in the hope that it will be useful, but | |
| 12 * WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| 14 * General Public License for more details. | |
| 15 * | |
| 16 * You should have received a copy of the GNU General Public License | |
| 17 * along with this program; if not, write to the Free Software | |
| 18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 | |
| 19 * USA | |
| 20 */ | |
| 21 | |
| 265 | 22 #define _GNU_SOURCE /* for strcasestr() */ |
| 72 | 23 #include <string.h> |
| 24 | |
| 25 #include "roster.h" | |
|
772
464be13343a9
Store most data in UTF-8 internally
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
26 #include "utils.h" |
| 72 | 27 |
| 28 | |
| 584 | 29 char *strrole[] = { /* Should match enum in roster.h */ |
| 30 "none", | |
| 31 "moderator", | |
| 32 "participant", | |
| 33 "visitor" | |
| 34 }; | |
| 35 | |
| 36 char *straffil[] = { /* Should match enum roster.h */ | |
| 37 "none", | |
| 38 "owner", | |
| 39 "admin", | |
| 40 "memeber", | |
| 41 "outcast" | |
| 42 }; | |
| 43 | |
|
438
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
44 /* Resource structure */ |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
45 |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
46 typedef struct { |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
47 gchar *name; |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
48 gchar prio; |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
49 enum imstatus status; |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
50 gchar *status_msg; |
|
625
028c01940490
Show presence timestamps in "/info" and "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
621
diff
changeset
|
51 time_t status_timestamp; |
|
438
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
52 enum imrole role; |
|
572
afc2bd38b15c
Implement affiliations handling, add "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
564
diff
changeset
|
53 enum imaffiliation affil; |
|
438
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
54 gchar *realjid; /* for chatrooms, if buddy's real jid is known */ |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
55 } res; |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
56 |
| 72 | 57 /* This is a private structure type for the roster */ |
| 58 | |
| 59 typedef struct { | |
|
438
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
60 gchar *name; |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
61 gchar *jid; |
| 72 | 62 guint type; |
|
438
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
63 enum subscr subscription; |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
64 GSList *resource; |
|
644
68fb0c1dfb15
MUC: better nickname check when entering a room
Mikael Berthe <mikael@lilotux.net>
parents:
625
diff
changeset
|
65 |
|
68fb0c1dfb15
MUC: better nickname check when entering a room
Mikael Berthe <mikael@lilotux.net>
parents:
625
diff
changeset
|
66 /* For groupchats */ |
|
68fb0c1dfb15
MUC: better nickname check when entering a room
Mikael Berthe <mikael@lilotux.net>
parents:
625
diff
changeset
|
67 gchar *nickname; |
|
68fb0c1dfb15
MUC: better nickname check when entering a room
Mikael Berthe <mikael@lilotux.net>
parents:
625
diff
changeset
|
68 gchar *topic; |
|
68fb0c1dfb15
MUC: better nickname check when entering a room
Mikael Berthe <mikael@lilotux.net>
parents:
625
diff
changeset
|
69 guint8 inside_room; |
|
68fb0c1dfb15
MUC: better nickname check when entering a room
Mikael Berthe <mikael@lilotux.net>
parents:
625
diff
changeset
|
70 |
|
843
915a7f17474a
Remember the status message when a buddy goes offline
Mikael Berthe <mikael@lilotux.net>
parents:
819
diff
changeset
|
71 /* To keep track of last status message */ |
|
915a7f17474a
Remember the status message when a buddy goes offline
Mikael Berthe <mikael@lilotux.net>
parents:
819
diff
changeset
|
72 gchar *offline_status_message; |
|
915a7f17474a
Remember the status message when a buddy goes offline
Mikael Berthe <mikael@lilotux.net>
parents:
819
diff
changeset
|
73 |
|
644
68fb0c1dfb15
MUC: better nickname check when entering a room
Mikael Berthe <mikael@lilotux.net>
parents:
625
diff
changeset
|
74 /* Flag used for the UI */ |
| 72 | 75 guint flags; |
|
644
68fb0c1dfb15
MUC: better nickname check when entering a room
Mikael Berthe <mikael@lilotux.net>
parents:
625
diff
changeset
|
76 |
| 72 | 77 // list: user -> points to his group; group -> points to its users list |
| 78 GSList *list; | |
| 79 } roster; | |
| 80 | |
| 81 | |
| 82 /* ### Variables ### */ | |
| 83 | |
| 84 static int hide_offline_buddies; | |
| 85 static GSList *groups; | |
| 236 | 86 static GSList *unread_list; |
|
662
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
87 static GHashTable *unread_jids; |
| 72 | 88 GList *buddylist; |
| 78 | 89 GList *current_buddy; |
| 330 | 90 GList *alternate_buddy; |
| 72 | 91 |
|
848
a9161d2dc414
Introduce special buffer stuff
Mikael Berthe <mikael@lilotux.net>
parents:
843
diff
changeset
|
92 static roster roster_special; |
|
a9161d2dc414
Introduce special buffer stuff
Mikael Berthe <mikael@lilotux.net>
parents:
843
diff
changeset
|
93 |
|
662
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
94 void unread_jid_add(const char *jid); |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
95 int unread_jid_del(const char *jid); |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
96 |
| 72 | 97 |
|
848
a9161d2dc414
Introduce special buffer stuff
Mikael Berthe <mikael@lilotux.net>
parents:
843
diff
changeset
|
98 /* ### Initialization ### */ |
|
a9161d2dc414
Introduce special buffer stuff
Mikael Berthe <mikael@lilotux.net>
parents:
843
diff
changeset
|
99 |
|
a9161d2dc414
Introduce special buffer stuff
Mikael Berthe <mikael@lilotux.net>
parents:
843
diff
changeset
|
100 void roster_init(void) |
|
a9161d2dc414
Introduce special buffer stuff
Mikael Berthe <mikael@lilotux.net>
parents:
843
diff
changeset
|
101 { |
|
a9161d2dc414
Introduce special buffer stuff
Mikael Berthe <mikael@lilotux.net>
parents:
843
diff
changeset
|
102 roster_special.name = "[status]"; |
|
a9161d2dc414
Introduce special buffer stuff
Mikael Berthe <mikael@lilotux.net>
parents:
843
diff
changeset
|
103 roster_special.type = ROSTER_TYPE_SPECIAL; |
|
a9161d2dc414
Introduce special buffer stuff
Mikael Berthe <mikael@lilotux.net>
parents:
843
diff
changeset
|
104 } |
|
a9161d2dc414
Introduce special buffer stuff
Mikael Berthe <mikael@lilotux.net>
parents:
843
diff
changeset
|
105 |
|
438
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
106 /* ### Resources functions ### */ |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
107 |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
108 static void free_all_resources(GSList **reslist) |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
109 { |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
110 GSList *lip; |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
111 res *p_res; |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
112 |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
113 for ( lip = *reslist; lip ; lip = g_slist_next(lip)) { |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
114 p_res = (res*)lip->data; |
|
774
46304b773a44
Remove useless checks before g_free() calls
Mikael Berthe <mikael@lilotux.net>
parents:
772
diff
changeset
|
115 g_free((gchar*)p_res->status_msg); |
|
46304b773a44
Remove useless checks before g_free() calls
Mikael Berthe <mikael@lilotux.net>
parents:
772
diff
changeset
|
116 g_free((gchar*)p_res->name); |
|
46304b773a44
Remove useless checks before g_free() calls
Mikael Berthe <mikael@lilotux.net>
parents:
772
diff
changeset
|
117 g_free((gchar*)p_res->realjid); |
|
438
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
118 } |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
119 // Free all nodes but the first (which is static) |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
120 g_slist_free(*reslist); |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
121 *reslist = NULL; |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
122 } |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
123 |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
124 // Resources are sorted in ascending order |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
125 static gint resource_compare_prio(res *a, res *b) { |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
126 //return (a->prio - b->prio); |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
127 if (a->prio < b->prio) return -1; |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
128 else return 1; |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
129 } |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
130 |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
131 // get_resource(rost, resname) |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
132 // Return a pointer to the resource with name resname, in rost's resources list |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
133 // - if rost has no resources, return NULL |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
134 // - if resname is defined, return the match or NULL |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
135 // - if resname is NULL, the last resource is returned, currently |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
136 // This could change in the future, because we should return the best one |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
137 // (priority? last used? and fall back to the first resource) |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
138 // |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
139 static res *get_resource(roster *rost, const char *resname) |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
140 { |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
141 GSList *p; |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
142 res *r = NULL; |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
143 |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
144 for (p = rost->resource; p; p = g_slist_next(p)) { |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
145 r = p->data; |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
146 if (resname && !strcmp(r->name, resname)) |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
147 return r; |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
148 } |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
149 |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
150 // The last resource is one of the resources with the highest priority, |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
151 // however, we don't know if it is the more-recently-used. |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
152 if (!resname) return r; |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
153 return NULL; |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
154 } |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
155 |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
156 // get_or_add_resource(rost, resname, priority) |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
157 // - if there is a "resname" resource in rost's resources, return a pointer |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
158 // on this resource |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
159 // - if not, add the resource, set the name, and return a pointer on this |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
160 // new resource |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
161 static res *get_or_add_resource(roster *rost, const char *resname, gchar prio) |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
162 { |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
163 GSList *p; |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
164 res *nres; |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
165 |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
166 if (!resname) return NULL; |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
167 |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
168 for (p = rost->resource; p; p = g_slist_next(p)) { |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
169 res *r = p->data; |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
170 if (!strcmp(r->name, resname)) |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
171 return r; |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
172 } |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
173 |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
174 // Resource not found |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
175 nres = g_new0(res, 1); |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
176 nres->name = g_strdup(resname); |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
177 nres->prio = prio; |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
178 rost->resource = g_slist_insert_sorted(rost->resource, nres, |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
179 (GCompareFunc)&resource_compare_prio); |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
180 return nres; |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
181 } |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
182 |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
183 static void del_resource(roster *rost, const char *resname) |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
184 { |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
185 GSList *p; |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
186 GSList *p_res_elt = NULL; |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
187 res *p_res; |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
188 |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
189 if (!resname) return; |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
190 |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
191 for (p = rost->resource; p; p = g_slist_next(p)) { |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
192 res *r = p->data; |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
193 if (!strcmp(r->name, resname)) |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
194 p_res_elt = p; |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
195 } |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
196 |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
197 if (!p_res_elt) return; // Resource not found |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
198 |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
199 p_res = p_res_elt->data; |
|
843
915a7f17474a
Remember the status message when a buddy goes offline
Mikael Berthe <mikael@lilotux.net>
parents:
819
diff
changeset
|
200 |
|
915a7f17474a
Remember the status message when a buddy goes offline
Mikael Berthe <mikael@lilotux.net>
parents:
819
diff
changeset
|
201 // Keep a copy of the status message when a buddy goes offline |
|
915a7f17474a
Remember the status message when a buddy goes offline
Mikael Berthe <mikael@lilotux.net>
parents:
819
diff
changeset
|
202 if (g_slist_length(rost->resource) == 1) { |
|
915a7f17474a
Remember the status message when a buddy goes offline
Mikael Berthe <mikael@lilotux.net>
parents:
819
diff
changeset
|
203 g_free(rost->offline_status_message); |
|
915a7f17474a
Remember the status message when a buddy goes offline
Mikael Berthe <mikael@lilotux.net>
parents:
819
diff
changeset
|
204 rost->offline_status_message = p_res->status_msg; |
|
915a7f17474a
Remember the status message when a buddy goes offline
Mikael Berthe <mikael@lilotux.net>
parents:
819
diff
changeset
|
205 p_res->status_msg = NULL; |
|
915a7f17474a
Remember the status message when a buddy goes offline
Mikael Berthe <mikael@lilotux.net>
parents:
819
diff
changeset
|
206 } |
|
915a7f17474a
Remember the status message when a buddy goes offline
Mikael Berthe <mikael@lilotux.net>
parents:
819
diff
changeset
|
207 |
|
438
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
208 // Free allocations and delete resource node |
|
774
46304b773a44
Remove useless checks before g_free() calls
Mikael Berthe <mikael@lilotux.net>
parents:
772
diff
changeset
|
209 g_free(p_res->name); |
|
46304b773a44
Remove useless checks before g_free() calls
Mikael Berthe <mikael@lilotux.net>
parents:
772
diff
changeset
|
210 g_free(p_res->status_msg); |
|
46304b773a44
Remove useless checks before g_free() calls
Mikael Berthe <mikael@lilotux.net>
parents:
772
diff
changeset
|
211 g_free(p_res->realjid); |
|
438
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
212 rost->resource = g_slist_delete_link(rost->resource, p_res_elt); |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
213 return; |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
214 } |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
215 |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
216 |
| 72 | 217 /* ### Roster functions ### */ |
| 218 | |
| 219 // Comparison function used to search in the roster (compares jids and types) | |
|
336
eb994ee40029
Make some functions static
Mikael Berthe <mikael@lilotux.net>
parents:
331
diff
changeset
|
220 static gint roster_compare_jid_type(roster *a, roster *b) { |
| 89 | 221 if (! (a->type & b->type)) |
| 480 | 222 return -1; // arbitrary (but should be != 0, of course) |
| 72 | 223 return strcasecmp(a->jid, b->jid); |
| 224 } | |
| 225 | |
|
670
2cd0805515a4
Fix a bug in roster_find()
Mikael Berthe <mikael@lilotux.net>
parents:
669
diff
changeset
|
226 // Comparison function used to search in the roster (compares names and types) |
|
2cd0805515a4
Fix a bug in roster_find()
Mikael Berthe <mikael@lilotux.net>
parents:
669
diff
changeset
|
227 static gint roster_compare_name_type(roster *a, roster *b) { |
|
2cd0805515a4
Fix a bug in roster_find()
Mikael Berthe <mikael@lilotux.net>
parents:
669
diff
changeset
|
228 if (! (a->type & b->type)) |
|
2cd0805515a4
Fix a bug in roster_find()
Mikael Berthe <mikael@lilotux.net>
parents:
669
diff
changeset
|
229 return -1; // arbitrary (but should be != 0, of course) |
|
783
25022410f80f
Use case sensitive group names
Mikael Berthe <mikael@lilotux.net>
parents:
774
diff
changeset
|
230 return strcmp(a->name, b->name); |
|
670
2cd0805515a4
Fix a bug in roster_find()
Mikael Berthe <mikael@lilotux.net>
parents:
669
diff
changeset
|
231 } |
|
2cd0805515a4
Fix a bug in roster_find()
Mikael Berthe <mikael@lilotux.net>
parents:
669
diff
changeset
|
232 |
| 72 | 233 // Comparison function used to sort the roster (by name) |
|
336
eb994ee40029
Make some functions static
Mikael Berthe <mikael@lilotux.net>
parents:
331
diff
changeset
|
234 static gint roster_compare_name(roster *a, roster *b) { |
|
783
25022410f80f
Use case sensitive group names
Mikael Berthe <mikael@lilotux.net>
parents:
774
diff
changeset
|
235 return strcmp(a->name, b->name); |
| 72 | 236 } |
| 237 | |
| 238 // Finds a roster element (user, group, agent...), by jid or name | |
| 89 | 239 // If roster_type is 0, returns match of any type. |
| 72 | 240 // Returns the roster GSList element, or NULL if jid/name not found |
| 78 | 241 GSList *roster_find(const char *jidname, enum findwhat type, guint roster_type) |
| 72 | 242 { |
| 243 GSList *sl_roster_elt = groups; | |
| 244 GSList *res; | |
| 245 roster sample; | |
| 246 GCompareFunc comp; | |
| 247 | |
| 192 | 248 if (!jidname) return NULL; |
| 72 | 249 |
| 89 | 250 if (!roster_type) |
| 480 | 251 roster_type = ROSTER_TYPE_USER | ROSTER_TYPE_ROOM | |
|
447
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
252 ROSTER_TYPE_AGENT | ROSTER_TYPE_GROUP; |
| 89 | 253 |
| 72 | 254 sample.type = roster_type; |
| 255 if (type == jidsearch) { | |
|
438
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
256 sample.jid = (gchar*)jidname; |
| 72 | 257 comp = (GCompareFunc)&roster_compare_jid_type; |
| 258 } else if (type == namesearch) { | |
|
438
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
259 sample.name = (gchar*)jidname; |
|
670
2cd0805515a4
Fix a bug in roster_find()
Mikael Berthe <mikael@lilotux.net>
parents:
669
diff
changeset
|
260 comp = (GCompareFunc)&roster_compare_name_type; |
| 72 | 261 } else |
| 262 return NULL; // should not happen | |
| 263 | |
| 264 while (sl_roster_elt) { | |
| 265 roster *roster_elt = (roster*)sl_roster_elt->data; | |
| 266 if (roster_type & ROSTER_TYPE_GROUP) { | |
|
783
25022410f80f
Use case sensitive group names
Mikael Berthe <mikael@lilotux.net>
parents:
774
diff
changeset
|
267 if ((type == namesearch) && !strcmp(jidname, roster_elt->name)) |
| 72 | 268 return sl_roster_elt; |
| 269 } | |
|
483
4a10c04ac2fb
Fix a bug in roster_find()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
270 res = g_slist_find_custom(roster_elt->list, &sample, comp); |
|
4a10c04ac2fb
Fix a bug in roster_find()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
271 if (res) return res; |
| 72 | 272 sl_roster_elt = g_slist_next(sl_roster_elt); |
| 273 } | |
| 274 return NULL; | |
| 275 } | |
| 276 | |
| 277 // Returns pointer to new group, or existing group with that name | |
| 78 | 278 GSList *roster_add_group(const char *name) |
| 72 | 279 { |
| 280 roster *roster_grp; | |
|
669
2b87065270f3
roster_add_group(): do not call roster_find() twice
Mikael Berthe <mikael@lilotux.net>
parents:
662
diff
changeset
|
281 GSList *p_group; |
|
2b87065270f3
roster_add_group(): do not call roster_find() twice
Mikael Berthe <mikael@lilotux.net>
parents:
662
diff
changeset
|
282 |
| 72 | 283 // #1 Check name doesn't already exist |
|
669
2b87065270f3
roster_add_group(): do not call roster_find() twice
Mikael Berthe <mikael@lilotux.net>
parents:
662
diff
changeset
|
284 p_group = roster_find(name, namesearch, ROSTER_TYPE_GROUP); |
|
2b87065270f3
roster_add_group(): do not call roster_find() twice
Mikael Berthe <mikael@lilotux.net>
parents:
662
diff
changeset
|
285 if (!p_group) { |
| 72 | 286 // #2 Create the group node |
| 287 roster_grp = g_new0(roster, 1); | |
| 288 roster_grp->name = g_strdup(name); | |
| 289 roster_grp->type = ROSTER_TYPE_GROUP; | |
| 290 // #3 Insert (sorted) | |
| 291 groups = g_slist_insert_sorted(groups, roster_grp, | |
| 292 (GCompareFunc)&roster_compare_name); | |
|
669
2b87065270f3
roster_add_group(): do not call roster_find() twice
Mikael Berthe <mikael@lilotux.net>
parents:
662
diff
changeset
|
293 p_group = roster_find(name, namesearch, ROSTER_TYPE_GROUP); |
| 72 | 294 } |
|
669
2b87065270f3
roster_add_group(): do not call roster_find() twice
Mikael Berthe <mikael@lilotux.net>
parents:
662
diff
changeset
|
295 return p_group; |
|
2b87065270f3
roster_add_group(): do not call roster_find() twice
Mikael Berthe <mikael@lilotux.net>
parents:
662
diff
changeset
|
296 |
| 72 | 297 } |
| 298 | |
| 299 // Returns a pointer to the new user, or existing user with that name | |
| 78 | 300 GSList *roster_add_user(const char *jid, const char *name, const char *group, |
| 603 | 301 guint type, enum subscr esub) |
| 72 | 302 { |
| 303 roster *roster_usr; | |
| 304 roster *my_group; | |
| 305 GSList *slist; | |
| 306 | |
|
447
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
307 if ((type != ROSTER_TYPE_USER) && |
|
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
308 (type != ROSTER_TYPE_ROOM) && |
|
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
309 (type != ROSTER_TYPE_AGENT)) { |
| 72 | 310 // XXX Error message? |
| 311 return NULL; | |
| 312 } | |
| 313 | |
| 78 | 314 // Let's be arbitrary: default group has an empty name (""). |
| 315 if (!group) group = ""; | |
| 316 | |
| 72 | 317 // #1 Check this user doesn't already exist |
|
563
b0f1b127bfb6
Prevent from adding a duplicate jid (when types are different)
Mikael Berthe <mikael@lilotux.net>
parents:
562
diff
changeset
|
318 slist = roster_find(jid, jidsearch, 0); |
| 607 | 319 if (slist) { |
| 320 char *oldgroupname; | |
| 321 // That's an update | |
| 322 roster_usr = slist->data; | |
| 323 roster_usr->subscription = esub; | |
| 324 if (name) | |
| 325 buddy_setname(slist->data, (char*)name); | |
| 326 // Let's check if the group name has changed | |
| 327 oldgroupname = ((roster*)((GSList*)roster_usr->list)->data)->name; | |
| 328 if (group && strcmp(oldgroupname, group)) | |
| 329 buddy_setgroup(slist->data, (char*)group); | |
| 330 return slist; | |
| 331 } | |
| 72 | 332 // #2 add group if necessary |
| 333 slist = roster_add_group(group); | |
| 334 if (!slist) return NULL; | |
| 335 my_group = (roster*)slist->data; | |
| 336 // #3 Create user node | |
| 337 roster_usr = g_new0(roster, 1); | |
| 338 roster_usr->jid = g_strdup(jid); | |
| 78 | 339 if (name) { |
| 340 roster_usr->name = g_strdup(name); | |
| 341 } else { | |
| 342 gchar *p, *str = g_strdup(jid); | |
| 80 | 343 p = strstr(str, "/"); |
| 78 | 344 if (p) *p = '\0'; |
| 345 roster_usr->name = g_strdup(str); | |
| 346 g_free(str); | |
| 347 } | |
|
662
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
348 if (unread_jid_del(jid)) { |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
349 roster_usr->flags |= ROSTER_FLAG_MSG; |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
350 // Append the roster_usr to unread_list |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
351 unread_list = g_slist_append(unread_list, roster_usr); |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
352 } |
| 603 | 353 roster_usr->type = type; |
| 354 roster_usr->subscription = esub; | |
| 355 roster_usr->list = slist; // (my_group SList element) | |
| 72 | 356 // #4 Insert node (sorted) |
| 357 my_group->list = g_slist_insert_sorted(my_group->list, roster_usr, | |
| 564 | 358 (GCompareFunc)&roster_compare_name); |
| 72 | 359 return roster_find(jid, jidsearch, type); |
| 360 } | |
| 361 | |
| 362 // Removes user (jid) from roster, frees allocated memory | |
| 78 | 363 void roster_del_user(const char *jid) |
| 72 | 364 { |
| 365 GSList *sl_user, *sl_group; | |
| 366 GSList **sl_group_listptr; | |
| 367 roster *roster_usr; | |
| 246 | 368 GSList *node; |
| 72 | 369 |
|
447
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
370 sl_user = roster_find(jid, jidsearch, |
|
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
371 ROSTER_TYPE_USER|ROSTER_TYPE_AGENT|ROSTER_TYPE_ROOM); |
| 89 | 372 if (sl_user == NULL) |
| 72 | 373 return; |
| 374 roster_usr = (roster*)sl_user->data; | |
| 246 | 375 |
| 376 // Remove (if present) from unread messages list | |
| 377 node = g_slist_find(unread_list, roster_usr); | |
| 378 if (node) unread_list = g_slist_delete_link(unread_list, node); | |
|
662
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
379 // If there is a pending unread message, keep track of it |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
380 if (roster_usr->flags & ROSTER_FLAG_MSG) |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
381 unread_jid_add(roster_usr->jid); |
| 246 | 382 |
| 383 // Let's free memory (jid, name, status message) | |
|
774
46304b773a44
Remove useless checks before g_free() calls
Mikael Berthe <mikael@lilotux.net>
parents:
772
diff
changeset
|
384 g_free((gchar*)roster_usr->jid); |
|
46304b773a44
Remove useless checks before g_free() calls
Mikael Berthe <mikael@lilotux.net>
parents:
772
diff
changeset
|
385 g_free((gchar*)roster_usr->name); |
|
46304b773a44
Remove useless checks before g_free() calls
Mikael Berthe <mikael@lilotux.net>
parents:
772
diff
changeset
|
386 g_free((gchar*)roster_usr->nickname); |
|
46304b773a44
Remove useless checks before g_free() calls
Mikael Berthe <mikael@lilotux.net>
parents:
772
diff
changeset
|
387 g_free((gchar*)roster_usr->topic); |
|
843
915a7f17474a
Remember the status message when a buddy goes offline
Mikael Berthe <mikael@lilotux.net>
parents:
819
diff
changeset
|
388 g_free((gchar*)roster_usr->offline_status_message); |
|
438
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
389 free_all_resources(&roster_usr->resource); |
| 210 | 390 g_free(roster_usr); |
| 72 | 391 |
| 392 // That's a little complex, we need to dereference twice | |
| 393 sl_group = ((roster*)sl_user->data)->list; | |
| 394 sl_group_listptr = &((roster*)(sl_group->data))->list; | |
| 395 *sl_group_listptr = g_slist_delete_link(*sl_group_listptr, sl_user); | |
| 78 | 396 |
| 397 // We need to rebuild the list | |
| 398 if (current_buddy) | |
| 399 buddylist_build(); | |
| 210 | 400 // TODO What we could do, too, is to check if the deleted node is |
| 78 | 401 // current_buddy, in which case we could move current_buddy to the |
| 402 // previous (or next) node. | |
| 72 | 403 } |
| 404 | |
| 210 | 405 // Free all roster data and call buddylist_build() to free the buddylist. |
| 164 | 406 void roster_free(void) |
| 407 { | |
| 408 GSList *sl_grp = groups; | |
| 409 | |
|
301
efcbd3c1ad15
Free unread_list when the roster is freed
Mikael Berthe <mikael@lilotux.net>
parents:
265
diff
changeset
|
410 // Free unread_list |
|
efcbd3c1ad15
Free unread_list when the roster is freed
Mikael Berthe <mikael@lilotux.net>
parents:
265
diff
changeset
|
411 if (unread_list) { |
|
efcbd3c1ad15
Free unread_list when the roster is freed
Mikael Berthe <mikael@lilotux.net>
parents:
265
diff
changeset
|
412 g_slist_free(unread_list); |
|
efcbd3c1ad15
Free unread_list when the roster is freed
Mikael Berthe <mikael@lilotux.net>
parents:
265
diff
changeset
|
413 unread_list = NULL; |
|
efcbd3c1ad15
Free unread_list when the roster is freed
Mikael Berthe <mikael@lilotux.net>
parents:
265
diff
changeset
|
414 } |
|
efcbd3c1ad15
Free unread_list when the roster is freed
Mikael Berthe <mikael@lilotux.net>
parents:
265
diff
changeset
|
415 |
| 164 | 416 // Walk through groups |
| 417 while (sl_grp) { | |
| 418 roster *roster_grp = (roster*)sl_grp->data; | |
| 419 GSList *sl_usr = roster_grp->list; | |
| 420 // Walk through this group users | |
| 421 while (sl_usr) { | |
| 422 roster *roster_usr = (roster*)sl_usr->data; | |
|
662
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
423 // If there is a pending unread message, keep track of it |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
424 if (roster_usr->flags & ROSTER_FLAG_MSG) |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
425 unread_jid_add(roster_usr->jid); |
| 164 | 426 // Free name and jid |
|
774
46304b773a44
Remove useless checks before g_free() calls
Mikael Berthe <mikael@lilotux.net>
parents:
772
diff
changeset
|
427 g_free((gchar*)roster_usr->jid); |
|
46304b773a44
Remove useless checks before g_free() calls
Mikael Berthe <mikael@lilotux.net>
parents:
772
diff
changeset
|
428 g_free((gchar*)roster_usr->name); |
|
46304b773a44
Remove useless checks before g_free() calls
Mikael Berthe <mikael@lilotux.net>
parents:
772
diff
changeset
|
429 g_free((gchar*)roster_usr->nickname); |
|
46304b773a44
Remove useless checks before g_free() calls
Mikael Berthe <mikael@lilotux.net>
parents:
772
diff
changeset
|
430 g_free((gchar*)roster_usr->topic); |
|
843
915a7f17474a
Remember the status message when a buddy goes offline
Mikael Berthe <mikael@lilotux.net>
parents:
819
diff
changeset
|
431 g_free((gchar*)roster_usr->offline_status_message); |
|
438
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
432 free_all_resources(&roster_usr->resource); |
| 214 | 433 g_free(roster_usr); |
| 164 | 434 sl_usr = g_slist_next(sl_usr); |
| 435 } | |
| 436 // Free group's users list | |
| 437 if (roster_grp->list) | |
| 438 g_slist_free(roster_grp->list); | |
| 439 // Free group's name and jid | |
|
774
46304b773a44
Remove useless checks before g_free() calls
Mikael Berthe <mikael@lilotux.net>
parents:
772
diff
changeset
|
440 g_free((gchar*)roster_grp->jid); |
|
46304b773a44
Remove useless checks before g_free() calls
Mikael Berthe <mikael@lilotux.net>
parents:
772
diff
changeset
|
441 g_free((gchar*)roster_grp->name); |
| 214 | 442 g_free(roster_grp); |
| 164 | 443 sl_grp = g_slist_next(sl_grp); |
| 444 } | |
| 445 // Free groups list | |
| 446 if (groups) { | |
| 447 g_slist_free(groups); | |
| 448 groups = NULL; | |
| 449 // Update (i.e. free) buddylist | |
| 450 if (buddylist) | |
| 451 buddylist_build(); | |
| 452 } | |
| 453 } | |
| 454 | |
|
468
644b8bf9ca4d
Improve MUC presence messages handling
Mikael Berthe <mikael@lilotux.net>
parents:
447
diff
changeset
|
455 // roster_setstatus() |
|
572
afc2bd38b15c
Implement affiliations handling, add "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
564
diff
changeset
|
456 // Note: resname, role, affil and realjid are for room members only |
|
438
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
457 void roster_setstatus(const char *jid, const char *resname, gchar prio, |
|
468
644b8bf9ca4d
Improve MUC presence messages handling
Mikael Berthe <mikael@lilotux.net>
parents:
447
diff
changeset
|
458 enum imstatus bstat, const char *status_msg, |
|
625
028c01940490
Show presence timestamps in "/info" and "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
621
diff
changeset
|
459 time_t status_time, |
|
572
afc2bd38b15c
Implement affiliations handling, add "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
564
diff
changeset
|
460 enum imrole role, enum imaffiliation affil, |
|
afc2bd38b15c
Implement affiliations handling, add "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
564
diff
changeset
|
461 const char *realjid) |
| 72 | 462 { |
| 463 GSList *sl_user; | |
| 464 roster *roster_usr; | |
|
438
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
465 res *p_res; |
| 72 | 466 |
|
447
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
467 sl_user = roster_find(jid, jidsearch, |
|
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
468 ROSTER_TYPE_USER|ROSTER_TYPE_ROOM|ROSTER_TYPE_AGENT); |
| 92 | 469 // If we can't find it, we add it |
| 89 | 470 if (sl_user == NULL) |
| 603 | 471 sl_user = roster_add_user(jid, NULL, NULL, ROSTER_TYPE_USER, sub_none); |
| 72 | 472 |
|
438
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
473 // If there is no resource name, we can leave now |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
474 if (!resname) return; |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
475 |
| 72 | 476 roster_usr = (roster*)sl_user->data; |
|
438
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
477 |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
478 // New or updated resource |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
479 p_res = get_or_add_resource(roster_usr, resname, prio); |
|
494
3f5aa4852684
Fix small bug in roster_setstatus()
Mikael Berthe <mikael@lilotux.net>
parents:
489
diff
changeset
|
480 p_res->prio = prio; |
|
438
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
481 p_res->status = bstat; |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
482 if (p_res->status_msg) { |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
483 g_free((gchar*)p_res->status_msg); |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
484 p_res->status_msg = NULL; |
| 221 | 485 } |
| 486 if (status_msg) | |
|
438
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
487 p_res->status_msg = g_strdup(status_msg); |
|
625
028c01940490
Show presence timestamps in "/info" and "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
621
diff
changeset
|
488 if (!status_time) |
|
028c01940490
Show presence timestamps in "/info" and "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
621
diff
changeset
|
489 time(&status_time); |
|
028c01940490
Show presence timestamps in "/info" and "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
621
diff
changeset
|
490 p_res->status_timestamp = status_time; |
|
468
644b8bf9ca4d
Improve MUC presence messages handling
Mikael Berthe <mikael@lilotux.net>
parents:
447
diff
changeset
|
491 |
|
644b8bf9ca4d
Improve MUC presence messages handling
Mikael Berthe <mikael@lilotux.net>
parents:
447
diff
changeset
|
492 p_res->role = role; |
|
572
afc2bd38b15c
Implement affiliations handling, add "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
564
diff
changeset
|
493 p_res->affil = affil; |
|
468
644b8bf9ca4d
Improve MUC presence messages handling
Mikael Berthe <mikael@lilotux.net>
parents:
447
diff
changeset
|
494 |
|
644b8bf9ca4d
Improve MUC presence messages handling
Mikael Berthe <mikael@lilotux.net>
parents:
447
diff
changeset
|
495 if (p_res->realjid) { |
|
644b8bf9ca4d
Improve MUC presence messages handling
Mikael Berthe <mikael@lilotux.net>
parents:
447
diff
changeset
|
496 g_free((gchar*)p_res->realjid); |
|
644b8bf9ca4d
Improve MUC presence messages handling
Mikael Berthe <mikael@lilotux.net>
parents:
447
diff
changeset
|
497 p_res->realjid = NULL; |
|
644b8bf9ca4d
Improve MUC presence messages handling
Mikael Berthe <mikael@lilotux.net>
parents:
447
diff
changeset
|
498 } |
|
644b8bf9ca4d
Improve MUC presence messages handling
Mikael Berthe <mikael@lilotux.net>
parents:
447
diff
changeset
|
499 if (realjid) |
|
644b8bf9ca4d
Improve MUC presence messages handling
Mikael Berthe <mikael@lilotux.net>
parents:
447
diff
changeset
|
500 p_res->realjid = g_strdup(realjid); |
|
843
915a7f17474a
Remember the status message when a buddy goes offline
Mikael Berthe <mikael@lilotux.net>
parents:
819
diff
changeset
|
501 |
|
915a7f17474a
Remember the status message when a buddy goes offline
Mikael Berthe <mikael@lilotux.net>
parents:
819
diff
changeset
|
502 // If bstat is offline, we MUST delete the resource, actually |
|
915a7f17474a
Remember the status message when a buddy goes offline
Mikael Berthe <mikael@lilotux.net>
parents:
819
diff
changeset
|
503 if (bstat == offline) { |
|
915a7f17474a
Remember the status message when a buddy goes offline
Mikael Berthe <mikael@lilotux.net>
parents:
819
diff
changeset
|
504 del_resource(roster_usr, resname); |
|
915a7f17474a
Remember the status message when a buddy goes offline
Mikael Berthe <mikael@lilotux.net>
parents:
819
diff
changeset
|
505 return; |
|
915a7f17474a
Remember the status message when a buddy goes offline
Mikael Berthe <mikael@lilotux.net>
parents:
819
diff
changeset
|
506 } |
| 72 | 507 } |
| 508 | |
| 78 | 509 // roster_setflags() |
| 510 // Set one or several flags to value (TRUE/FALSE) | |
| 80 | 511 void roster_setflags(const char *jid, guint flags, guint value) |
| 78 | 512 { |
| 513 GSList *sl_user; | |
| 514 roster *roster_usr; | |
| 515 | |
|
447
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
516 sl_user = roster_find(jid, jidsearch, |
|
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
517 ROSTER_TYPE_USER|ROSTER_TYPE_ROOM|ROSTER_TYPE_AGENT); |
| 89 | 518 if (sl_user == NULL) |
| 78 | 519 return; |
| 520 | |
| 521 roster_usr = (roster*)sl_user->data; | |
| 522 if (value) | |
| 523 roster_usr->flags |= flags; | |
| 524 else | |
| 525 roster_usr->flags &= ~flags; | |
| 526 } | |
| 148 | 527 |
| 528 // roster_msg_setflag() | |
| 529 // Set the ROSTER_FLAG_MSG to the given value for the given jid. | |
| 530 // It will update the buddy's group message flag. | |
| 236 | 531 // Update the unread messages list too. |
| 148 | 532 void roster_msg_setflag(const char *jid, guint value) |
| 533 { | |
| 534 GSList *sl_user; | |
| 535 roster *roster_usr, *roster_grp; | |
| 536 | |
|
447
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
537 sl_user = roster_find(jid, jidsearch, |
|
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
538 ROSTER_TYPE_USER|ROSTER_TYPE_ROOM|ROSTER_TYPE_AGENT); |
|
678
e175f5d96f04
Fix a small issue in roster_msg_setflag()
Mikael Berthe <mikael@lilotux.net>
parents:
670
diff
changeset
|
539 // If we can't find it, we add it |
|
e175f5d96f04
Fix a small issue in roster_msg_setflag()
Mikael Berthe <mikael@lilotux.net>
parents:
670
diff
changeset
|
540 if (sl_user == NULL) { |
|
e175f5d96f04
Fix a small issue in roster_msg_setflag()
Mikael Berthe <mikael@lilotux.net>
parents:
670
diff
changeset
|
541 sl_user = roster_add_user(jid, NULL, NULL, ROSTER_TYPE_USER, sub_none); |
|
e175f5d96f04
Fix a small issue in roster_msg_setflag()
Mikael Berthe <mikael@lilotux.net>
parents:
670
diff
changeset
|
542 } |
| 148 | 543 |
| 544 roster_usr = (roster*)sl_user->data; | |
| 545 roster_grp = (roster*)roster_usr->list->data; | |
| 546 if (value) { | |
| 547 // Message flag is TRUE. This is easy, we just have to set both flags | |
| 548 // to TRUE... | |
| 549 roster_usr->flags |= ROSTER_FLAG_MSG; | |
| 550 roster_grp->flags |= ROSTER_FLAG_MSG; // group | |
| 236 | 551 // Append the roster_usr to unread_list, but avoid duplicates |
| 552 if (!g_slist_find(unread_list, roster_usr)) | |
| 553 unread_list = g_slist_append(unread_list, roster_usr); | |
| 148 | 554 } else { |
| 555 // Message flag is FALSE. | |
| 556 guint msg = FALSE; | |
| 557 roster_usr->flags &= ~ROSTER_FLAG_MSG; | |
| 236 | 558 if (unread_list) { |
| 559 GSList *node = g_slist_find(unread_list, roster_usr); | |
| 560 if (node) unread_list = g_slist_delete_link(unread_list, node); | |
| 561 } | |
| 148 | 562 // For the group value we need to watch all buddies in this group; |
| 563 // if one is flagged, then the group will be flagged. | |
| 564 // I will re-use sl_user and roster_usr here, as they aren't used | |
| 565 // anymore. | |
| 566 sl_user = roster_grp->list; | |
| 567 while (sl_user) { | |
| 568 roster_usr = (roster*)sl_user->data; | |
| 569 if (roster_usr->flags & ROSTER_FLAG_MSG) { | |
| 570 msg = TRUE; | |
| 571 break; | |
| 572 } | |
| 573 sl_user = g_slist_next(sl_user); | |
| 574 } | |
| 575 if (!msg) | |
| 576 roster_grp->flags &= ~ROSTER_FLAG_MSG; | |
| 577 else | |
| 578 roster_grp->flags |= ROSTER_FLAG_MSG; | |
| 579 // Actually the "else" part is useless, because the group | |
| 580 // ROSTER_FLAG_MSG should already be set... | |
| 581 } | |
| 582 } | |
| 583 | |
|
510
6c3cd3aa4a91
New 'buddy_format' option
Mikael Berthe <mikael@lilotux.net>
parents:
509
diff
changeset
|
584 const char *roster_getname(const char *jid) |
|
6c3cd3aa4a91
New 'buddy_format' option
Mikael Berthe <mikael@lilotux.net>
parents:
509
diff
changeset
|
585 { |
|
6c3cd3aa4a91
New 'buddy_format' option
Mikael Berthe <mikael@lilotux.net>
parents:
509
diff
changeset
|
586 GSList *sl_user; |
|
6c3cd3aa4a91
New 'buddy_format' option
Mikael Berthe <mikael@lilotux.net>
parents:
509
diff
changeset
|
587 roster *roster_usr; |
|
6c3cd3aa4a91
New 'buddy_format' option
Mikael Berthe <mikael@lilotux.net>
parents:
509
diff
changeset
|
588 |
|
6c3cd3aa4a91
New 'buddy_format' option
Mikael Berthe <mikael@lilotux.net>
parents:
509
diff
changeset
|
589 sl_user = roster_find(jid, jidsearch, |
|
6c3cd3aa4a91
New 'buddy_format' option
Mikael Berthe <mikael@lilotux.net>
parents:
509
diff
changeset
|
590 ROSTER_TYPE_USER|ROSTER_TYPE_ROOM|ROSTER_TYPE_AGENT); |
|
6c3cd3aa4a91
New 'buddy_format' option
Mikael Berthe <mikael@lilotux.net>
parents:
509
diff
changeset
|
591 if (sl_user == NULL) |
|
6c3cd3aa4a91
New 'buddy_format' option
Mikael Berthe <mikael@lilotux.net>
parents:
509
diff
changeset
|
592 return NULL; // Not in the roster... |
|
6c3cd3aa4a91
New 'buddy_format' option
Mikael Berthe <mikael@lilotux.net>
parents:
509
diff
changeset
|
593 |
|
6c3cd3aa4a91
New 'buddy_format' option
Mikael Berthe <mikael@lilotux.net>
parents:
509
diff
changeset
|
594 roster_usr = (roster*)sl_user->data; |
|
6c3cd3aa4a91
New 'buddy_format' option
Mikael Berthe <mikael@lilotux.net>
parents:
509
diff
changeset
|
595 return roster_usr->name; |
|
6c3cd3aa4a91
New 'buddy_format' option
Mikael Berthe <mikael@lilotux.net>
parents:
509
diff
changeset
|
596 } |
|
6c3cd3aa4a91
New 'buddy_format' option
Mikael Berthe <mikael@lilotux.net>
parents:
509
diff
changeset
|
597 |
| 89 | 598 void roster_settype(const char *jid, guint type) |
| 599 { | |
| 600 GSList *sl_user; | |
| 601 roster *roster_usr; | |
| 602 | |
| 603 if ((sl_user = roster_find(jid, jidsearch, 0)) == NULL) | |
| 604 return; | |
| 605 | |
| 606 roster_usr = (roster*)sl_user->data; | |
| 607 roster_usr->type = type; | |
| 608 } | |
| 609 | |
|
438
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
610 enum imstatus roster_getstatus(const char *jid, const char *resname) |
| 90 | 611 { |
| 612 GSList *sl_user; | |
| 613 roster *roster_usr; | |
|
438
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
614 res *p_res; |
| 90 | 615 |
| 616 sl_user = roster_find(jid, jidsearch, ROSTER_TYPE_USER|ROSTER_TYPE_AGENT); | |
| 617 if (sl_user == NULL) | |
| 618 return offline; // Not in the roster, anyway... | |
| 619 | |
| 620 roster_usr = (roster*)sl_user->data; | |
|
438
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
621 p_res = get_resource(roster_usr, resname); |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
622 if (p_res) |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
623 return p_res->status; |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
624 return offline; |
| 90 | 625 } |
| 626 | |
|
438
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
627 const char *roster_getstatusmsg(const char *jid, const char *resname) |
|
318
45076d02eeef
The /status command can specify a status message
Mikael Berthe <mikael@lilotux.net>
parents:
301
diff
changeset
|
628 { |
|
45076d02eeef
The /status command can specify a status message
Mikael Berthe <mikael@lilotux.net>
parents:
301
diff
changeset
|
629 GSList *sl_user; |
|
45076d02eeef
The /status command can specify a status message
Mikael Berthe <mikael@lilotux.net>
parents:
301
diff
changeset
|
630 roster *roster_usr; |
|
438
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
631 res *p_res; |
|
318
45076d02eeef
The /status command can specify a status message
Mikael Berthe <mikael@lilotux.net>
parents:
301
diff
changeset
|
632 |
|
45076d02eeef
The /status command can specify a status message
Mikael Berthe <mikael@lilotux.net>
parents:
301
diff
changeset
|
633 sl_user = roster_find(jid, jidsearch, ROSTER_TYPE_USER|ROSTER_TYPE_AGENT); |
|
45076d02eeef
The /status command can specify a status message
Mikael Berthe <mikael@lilotux.net>
parents:
301
diff
changeset
|
634 if (sl_user == NULL) |
|
425
03f1e37759a6
roster_getstatusmsg() should return a pointer
Mikael Berthe <mikael@lilotux.net>
parents:
393
diff
changeset
|
635 return NULL; // Not in the roster, anyway... |
|
318
45076d02eeef
The /status command can specify a status message
Mikael Berthe <mikael@lilotux.net>
parents:
301
diff
changeset
|
636 |
|
45076d02eeef
The /status command can specify a status message
Mikael Berthe <mikael@lilotux.net>
parents:
301
diff
changeset
|
637 roster_usr = (roster*)sl_user->data; |
|
438
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
638 p_res = get_resource(roster_usr, resname); |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
639 if (p_res) |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
640 return p_res->status_msg; |
|
843
915a7f17474a
Remember the status message when a buddy goes offline
Mikael Berthe <mikael@lilotux.net>
parents:
819
diff
changeset
|
641 return roster_usr->offline_status_message; |
|
318
45076d02eeef
The /status command can specify a status message
Mikael Berthe <mikael@lilotux.net>
parents:
301
diff
changeset
|
642 } |
|
45076d02eeef
The /status command can specify a status message
Mikael Berthe <mikael@lilotux.net>
parents:
301
diff
changeset
|
643 |
| 89 | 644 guint roster_gettype(const char *jid) |
| 645 { | |
| 646 GSList *sl_user; | |
| 647 roster *roster_usr; | |
| 648 | |
| 649 if ((sl_user = roster_find(jid, jidsearch, 0)) == NULL) | |
| 650 return 0; | |
| 651 | |
| 652 roster_usr = (roster*)sl_user->data; | |
| 653 return roster_usr->type; | |
| 654 } | |
| 655 | |
|
819
c2d7d9dd4193
New option 'block_unsubscribed'
Mikael Berthe <mikael@lilotux.net>
parents:
792
diff
changeset
|
656 guint roster_getsubscription(const char *jid) |
|
c2d7d9dd4193
New option 'block_unsubscribed'
Mikael Berthe <mikael@lilotux.net>
parents:
792
diff
changeset
|
657 { |
|
c2d7d9dd4193
New option 'block_unsubscribed'
Mikael Berthe <mikael@lilotux.net>
parents:
792
diff
changeset
|
658 GSList *sl_user; |
|
c2d7d9dd4193
New option 'block_unsubscribed'
Mikael Berthe <mikael@lilotux.net>
parents:
792
diff
changeset
|
659 roster *roster_usr; |
|
c2d7d9dd4193
New option 'block_unsubscribed'
Mikael Berthe <mikael@lilotux.net>
parents:
792
diff
changeset
|
660 |
|
c2d7d9dd4193
New option 'block_unsubscribed'
Mikael Berthe <mikael@lilotux.net>
parents:
792
diff
changeset
|
661 if ((sl_user = roster_find(jid, jidsearch, 0)) == NULL) |
|
c2d7d9dd4193
New option 'block_unsubscribed'
Mikael Berthe <mikael@lilotux.net>
parents:
792
diff
changeset
|
662 return 0; |
|
c2d7d9dd4193
New option 'block_unsubscribed'
Mikael Berthe <mikael@lilotux.net>
parents:
792
diff
changeset
|
663 |
|
c2d7d9dd4193
New option 'block_unsubscribed'
Mikael Berthe <mikael@lilotux.net>
parents:
792
diff
changeset
|
664 roster_usr = (roster*)sl_user->data; |
|
c2d7d9dd4193
New option 'block_unsubscribed'
Mikael Berthe <mikael@lilotux.net>
parents:
792
diff
changeset
|
665 return roster_usr->subscription; |
|
c2d7d9dd4193
New option 'block_unsubscribed'
Mikael Berthe <mikael@lilotux.net>
parents:
792
diff
changeset
|
666 } |
|
c2d7d9dd4193
New option 'block_unsubscribed'
Mikael Berthe <mikael@lilotux.net>
parents:
792
diff
changeset
|
667 |
|
610
0e8247cf2bd1
Consider buddies as offline when they have cancelled our subscription
Mikael Berthe <mikael@lilotux.net>
parents:
607
diff
changeset
|
668 // roster_unsubscribed() |
|
0e8247cf2bd1
Consider buddies as offline when they have cancelled our subscription
Mikael Berthe <mikael@lilotux.net>
parents:
607
diff
changeset
|
669 // We have lost buddy's presence updates; this function clears the status |
|
0e8247cf2bd1
Consider buddies as offline when they have cancelled our subscription
Mikael Berthe <mikael@lilotux.net>
parents:
607
diff
changeset
|
670 // message, sets the buddy offline and frees the resources |
|
0e8247cf2bd1
Consider buddies as offline when they have cancelled our subscription
Mikael Berthe <mikael@lilotux.net>
parents:
607
diff
changeset
|
671 void roster_unsubscribed(const char *jid) |
|
0e8247cf2bd1
Consider buddies as offline when they have cancelled our subscription
Mikael Berthe <mikael@lilotux.net>
parents:
607
diff
changeset
|
672 { |
|
0e8247cf2bd1
Consider buddies as offline when they have cancelled our subscription
Mikael Berthe <mikael@lilotux.net>
parents:
607
diff
changeset
|
673 GSList *sl_user; |
|
0e8247cf2bd1
Consider buddies as offline when they have cancelled our subscription
Mikael Berthe <mikael@lilotux.net>
parents:
607
diff
changeset
|
674 roster *roster_usr; |
|
0e8247cf2bd1
Consider buddies as offline when they have cancelled our subscription
Mikael Berthe <mikael@lilotux.net>
parents:
607
diff
changeset
|
675 |
|
0e8247cf2bd1
Consider buddies as offline when they have cancelled our subscription
Mikael Berthe <mikael@lilotux.net>
parents:
607
diff
changeset
|
676 sl_user = roster_find(jid, jidsearch, ROSTER_TYPE_USER|ROSTER_TYPE_AGENT); |
|
0e8247cf2bd1
Consider buddies as offline when they have cancelled our subscription
Mikael Berthe <mikael@lilotux.net>
parents:
607
diff
changeset
|
677 if (sl_user == NULL) |
|
0e8247cf2bd1
Consider buddies as offline when they have cancelled our subscription
Mikael Berthe <mikael@lilotux.net>
parents:
607
diff
changeset
|
678 return; |
|
0e8247cf2bd1
Consider buddies as offline when they have cancelled our subscription
Mikael Berthe <mikael@lilotux.net>
parents:
607
diff
changeset
|
679 |
|
0e8247cf2bd1
Consider buddies as offline when they have cancelled our subscription
Mikael Berthe <mikael@lilotux.net>
parents:
607
diff
changeset
|
680 roster_usr = (roster*)sl_user->data; |
|
0e8247cf2bd1
Consider buddies as offline when they have cancelled our subscription
Mikael Berthe <mikael@lilotux.net>
parents:
607
diff
changeset
|
681 free_all_resources(&roster_usr->resource); |
|
0e8247cf2bd1
Consider buddies as offline when they have cancelled our subscription
Mikael Berthe <mikael@lilotux.net>
parents:
607
diff
changeset
|
682 } |
|
0e8247cf2bd1
Consider buddies as offline when they have cancelled our subscription
Mikael Berthe <mikael@lilotux.net>
parents:
607
diff
changeset
|
683 |
| 72 | 684 |
| 685 /* ### BuddyList functions ### */ | |
| 686 | |
| 120 | 687 // buddylist_set_hide_offline_buddies(hide) |
| 72 | 688 // "hide" values: 1=hide 0=show_all -1=invert |
| 120 | 689 void buddylist_set_hide_offline_buddies(int hide) |
| 72 | 690 { |
| 691 if (hide < 0) // NEG (invert) | |
| 692 hide_offline_buddies = !hide_offline_buddies; | |
| 693 else if (hide == 0) // FALSE (don't hide) | |
| 694 hide_offline_buddies = 0; | |
| 695 else // TRUE (hide) | |
| 696 hide_offline_buddies = 1; | |
| 697 } | |
| 698 | |
| 120 | 699 inline int buddylist_get_hide_offline_buddies(void) |
| 700 { | |
| 701 return hide_offline_buddies; | |
| 702 } | |
| 703 | |
| 72 | 704 // buddylist_build() |
| 705 // Creates the buddylist from the roster entries. | |
| 706 void buddylist_build(void) | |
| 707 { | |
| 708 GSList *sl_roster_elt = groups; | |
| 709 roster *roster_elt; | |
| 81 | 710 roster *roster_current_buddy = NULL; |
| 330 | 711 roster *roster_alternate_buddy = NULL; |
| 128 | 712 int shrunk_group; |
| 72 | 713 |
| 81 | 714 // We need to remember which buddy is selected. |
| 715 if (current_buddy) | |
| 716 roster_current_buddy = BUDDATA(current_buddy); | |
| 717 current_buddy = NULL; | |
| 330 | 718 if (alternate_buddy) |
| 719 roster_alternate_buddy = BUDDATA(alternate_buddy); | |
| 720 alternate_buddy = NULL; | |
| 81 | 721 |
| 72 | 722 // Destroy old buddylist |
| 723 if (buddylist) { | |
| 724 g_list_free(buddylist); | |
| 725 buddylist = NULL; | |
| 726 } | |
| 727 | |
|
848
a9161d2dc414
Introduce special buffer stuff
Mikael Berthe <mikael@lilotux.net>
parents:
843
diff
changeset
|
728 buddylist = g_list_append(buddylist, &roster_special); |
|
a9161d2dc414
Introduce special buffer stuff
Mikael Berthe <mikael@lilotux.net>
parents:
843
diff
changeset
|
729 |
| 72 | 730 // Create the new list |
| 731 while (sl_roster_elt) { | |
| 732 GSList *sl_roster_usrelt; | |
| 733 roster *roster_usrelt; | |
| 147 | 734 guint pending_group = FALSE; |
| 72 | 735 roster_elt = (roster*) sl_roster_elt->data; |
| 736 | |
| 737 // Add the group now unless hide_offline_buddies is set, | |
| 738 // in which case we'll add it only if an online buddy belongs to it. | |
| 147 | 739 // We take care to keep the current_buddy in the list, too. |
| 740 if (!hide_offline_buddies || roster_elt == roster_current_buddy) | |
| 72 | 741 buddylist = g_list_append(buddylist, roster_elt); |
| 742 else | |
| 147 | 743 pending_group = TRUE; |
| 72 | 744 |
| 128 | 745 shrunk_group = roster_elt->flags & ROSTER_FLAG_HIDE; |
| 746 | |
| 72 | 747 sl_roster_usrelt = roster_elt->list; |
| 748 while (sl_roster_usrelt) { | |
| 749 roster_usrelt = (roster*) sl_roster_usrelt->data; | |
| 750 | |
| 751 // Buddy will be added if either: | |
| 752 // - hide_offline_buddies is FALSE | |
| 753 // - buddy is not offline | |
| 754 // - buddy has a lock (for example the buddy window is currently open) | |
| 755 // - buddy has a pending (non-read) message | |
| 128 | 756 // - group isn't hidden (shrunk) |
| 147 | 757 // - this is the current_buddy |
| 758 if (!hide_offline_buddies || roster_usrelt == roster_current_buddy || | |
|
438
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
759 (buddy_getstatus((gpointer)roster_usrelt, NULL) != offline) || |
| 72 | 760 (buddy_getflags((gpointer)roster_usrelt) & |
| 761 (ROSTER_FLAG_LOCK | ROSTER_FLAG_MSG))) { | |
| 762 // This user should be added. Maybe the group hasn't been added yet? | |
| 147 | 763 if (pending_group && |
| 764 (hide_offline_buddies || roster_usrelt == roster_current_buddy)) { | |
| 72 | 765 // It hasn't been done yet |
| 766 buddylist = g_list_append(buddylist, roster_elt); | |
| 767 pending_group = FALSE; | |
| 768 } | |
| 769 // Add user | |
| 128 | 770 // XXX Should we add the user if there is a message and |
| 771 // the group is shrunk? If so, we'd need to check LOCK flag too, | |
| 772 // perhaps... | |
| 773 if (!shrunk_group) | |
| 774 buddylist = g_list_append(buddylist, roster_usrelt); | |
| 72 | 775 } |
| 776 | |
| 777 sl_roster_usrelt = g_slist_next(sl_roster_usrelt); | |
| 778 } | |
| 779 sl_roster_elt = g_slist_next(sl_roster_elt); | |
| 780 } | |
| 78 | 781 |
| 81 | 782 // Check if we can find our saved current_buddy... |
| 783 if (roster_current_buddy) | |
| 784 current_buddy = g_list_find(buddylist, roster_current_buddy); | |
| 330 | 785 if (roster_alternate_buddy) |
| 786 alternate_buddy = g_list_find(buddylist, roster_alternate_buddy); | |
| 78 | 787 // current_buddy initialization |
| 788 if (!current_buddy || (g_list_position(buddylist, current_buddy) == -1)) | |
| 81 | 789 current_buddy = g_list_first(buddylist); |
| 72 | 790 } |
| 791 | |
| 792 // buddy_hide_group(roster, hide) | |
| 793 // "hide" values: 1=hide 0=show_all -1=invert | |
| 794 void buddy_hide_group(gpointer rosterdata, int hide) | |
| 795 { | |
| 207 | 796 roster *roster_usr = rosterdata; |
| 72 | 797 if (hide > 0) // TRUE (hide) |
| 207 | 798 roster_usr->flags |= ROSTER_FLAG_HIDE; |
| 72 | 799 else if (hide < 0) // NEG (invert) |
| 207 | 800 roster_usr->flags ^= ROSTER_FLAG_HIDE; |
| 72 | 801 else // FALSE (don't hide) |
| 207 | 802 roster_usr->flags &= ~ROSTER_FLAG_HIDE; |
| 72 | 803 } |
| 804 | |
| 805 const char *buddy_getjid(gpointer rosterdata) | |
| 806 { | |
| 207 | 807 roster *roster_usr = rosterdata; |
| 808 return roster_usr->jid; | |
| 809 } | |
| 810 | |
| 210 | 811 // buddy_setgroup() |
| 812 // Change the group of current buddy | |
| 813 // | |
| 814 void buddy_setgroup(gpointer rosterdata, char *newgroupname) | |
| 815 { | |
| 816 roster *roster_usr = rosterdata; | |
| 817 GSList **sl_group; | |
|
620
97dd14e22b2a
Rewrite buddy_setgroup()
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
818 GSList *sl_newgroup; |
|
97dd14e22b2a
Rewrite buddy_setgroup()
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
819 roster *my_newgroup; |
| 210 | 820 |
| 821 // A group has no group :) | |
| 822 if (roster_usr->type & ROSTER_TYPE_GROUP) return; | |
| 823 | |
|
620
97dd14e22b2a
Rewrite buddy_setgroup()
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
824 // Add newgroup if necessary |
|
97dd14e22b2a
Rewrite buddy_setgroup()
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
825 if (!newgroupname) newgroupname = ""; |
|
97dd14e22b2a
Rewrite buddy_setgroup()
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
826 sl_newgroup = roster_add_group(newgroupname); |
|
97dd14e22b2a
Rewrite buddy_setgroup()
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
827 if (!sl_newgroup) return; |
|
97dd14e22b2a
Rewrite buddy_setgroup()
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
828 my_newgroup = (roster*)sl_newgroup->data; |
|
97dd14e22b2a
Rewrite buddy_setgroup()
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
829 |
| 210 | 830 // Remove the buddy from current group |
| 831 sl_group = &((roster*)((GSList*)roster_usr->list)->data)->list; | |
| 832 *sl_group = g_slist_remove(*sl_group, rosterdata); | |
| 393 | 833 |
|
621
f20c1934a8a7
"/move": remove old group if it is empty
Mikael Berthe <mikael@lilotux.net>
parents:
620
diff
changeset
|
834 // Remove old group if it is empty |
|
f20c1934a8a7
"/move": remove old group if it is empty
Mikael Berthe <mikael@lilotux.net>
parents:
620
diff
changeset
|
835 if (!*sl_group) { |
|
f20c1934a8a7
"/move": remove old group if it is empty
Mikael Berthe <mikael@lilotux.net>
parents:
620
diff
changeset
|
836 roster *roster_grp = (roster*)((GSList*)roster_usr->list)->data; |
|
774
46304b773a44
Remove useless checks before g_free() calls
Mikael Berthe <mikael@lilotux.net>
parents:
772
diff
changeset
|
837 g_free((gchar*)roster_grp->jid); |
|
46304b773a44
Remove useless checks before g_free() calls
Mikael Berthe <mikael@lilotux.net>
parents:
772
diff
changeset
|
838 g_free((gchar*)roster_grp->name); |
|
621
f20c1934a8a7
"/move": remove old group if it is empty
Mikael Berthe <mikael@lilotux.net>
parents:
620
diff
changeset
|
839 g_free(roster_grp); |
|
f20c1934a8a7
"/move": remove old group if it is empty
Mikael Berthe <mikael@lilotux.net>
parents:
620
diff
changeset
|
840 groups = g_slist_remove(groups, roster_grp); |
|
f20c1934a8a7
"/move": remove old group if it is empty
Mikael Berthe <mikael@lilotux.net>
parents:
620
diff
changeset
|
841 } |
|
f20c1934a8a7
"/move": remove old group if it is empty
Mikael Berthe <mikael@lilotux.net>
parents:
620
diff
changeset
|
842 |
|
620
97dd14e22b2a
Rewrite buddy_setgroup()
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
843 // Add the buddy to its new group |
|
97dd14e22b2a
Rewrite buddy_setgroup()
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
844 roster_usr->list = sl_newgroup; // (my_newgroup SList element) |
|
97dd14e22b2a
Rewrite buddy_setgroup()
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
845 my_newgroup->list = g_slist_insert_sorted(my_newgroup->list, roster_usr, |
|
97dd14e22b2a
Rewrite buddy_setgroup()
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
846 (GCompareFunc)&roster_compare_name); |
| 212 | 847 |
| 210 | 848 buddylist_build(); |
| 849 } | |
| 850 | |
| 207 | 851 void buddy_setname(gpointer rosterdata, char *newname) |
| 852 { | |
| 853 roster *roster_usr = rosterdata; | |
| 209 | 854 GSList **sl_group; |
| 207 | 855 |
| 856 // TODO For groups, we need to check for unicity | |
| 857 // However, renaming a group boils down to moving all its buddies to | |
| 858 // another group, so calling this function is not really necessary... | |
| 859 if (roster_usr->type & ROSTER_TYPE_GROUP) return; | |
| 860 | |
| 861 if (roster_usr->name) { | |
| 862 g_free((gchar*)roster_usr->name); | |
| 863 roster_usr->name = NULL; | |
| 864 } | |
| 865 if (newname) | |
| 866 roster_usr->name = g_strdup(newname); | |
| 209 | 867 |
| 868 // We need to resort the group list | |
| 869 sl_group = &((roster*)((GSList*)roster_usr->list)->data)->list; | |
| 870 *sl_group = g_slist_sort(*sl_group, (GCompareFunc)&roster_compare_name); | |
| 871 | |
| 872 buddylist_build(); | |
| 72 | 873 } |
| 874 | |
| 875 const char *buddy_getname(gpointer rosterdata) | |
| 876 { | |
| 207 | 877 roster *roster_usr = rosterdata; |
| 878 return roster_usr->name; | |
| 879 } | |
| 880 | |
|
548
265c50238a48
Add buddy_{get,set}topic()
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
881 // buddy_setnickname(buddy, newnickname) |
|
265c50238a48
Add buddy_{get,set}topic()
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
882 // Only for chatrooms |
|
469
a926523d2392
Use UTF8 to handle resources and room nicknames
Mikael Berthe <mikael@lilotux.net>
parents:
468
diff
changeset
|
883 void buddy_setnickname(gpointer rosterdata, const char *newname) |
|
447
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
884 { |
|
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
885 roster *roster_usr = rosterdata; |
|
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
886 |
|
649
3ad6675caaf1
MUC: fix join bug when the conference is in the roster
Mikael Berthe <mikael@lilotux.net>
parents:
644
diff
changeset
|
887 if (!(roster_usr->type & ROSTER_TYPE_ROOM)) return; // XXX Error message? |
|
447
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
888 |
|
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
889 if (roster_usr->nickname) { |
|
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
890 g_free((gchar*)roster_usr->nickname); |
|
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
891 roster_usr->nickname = NULL; |
|
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
892 } |
|
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
893 if (newname) |
|
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
894 roster_usr->nickname = g_strdup(newname); |
|
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
895 } |
|
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
896 |
|
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
897 const char *buddy_getnickname(gpointer rosterdata) |
|
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
898 { |
|
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
899 roster *roster_usr = rosterdata; |
|
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
900 return roster_usr->nickname; |
|
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
901 } |
|
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
902 |
|
644
68fb0c1dfb15
MUC: better nickname check when entering a room
Mikael Berthe <mikael@lilotux.net>
parents:
625
diff
changeset
|
903 // buddy_setinsideroom(buddy, inside) |
|
68fb0c1dfb15
MUC: better nickname check when entering a room
Mikael Berthe <mikael@lilotux.net>
parents:
625
diff
changeset
|
904 // Only for chatrooms |
|
68fb0c1dfb15
MUC: better nickname check when entering a room
Mikael Berthe <mikael@lilotux.net>
parents:
625
diff
changeset
|
905 void buddy_setinsideroom(gpointer rosterdata, guint8 inside) |
|
68fb0c1dfb15
MUC: better nickname check when entering a room
Mikael Berthe <mikael@lilotux.net>
parents:
625
diff
changeset
|
906 { |
|
68fb0c1dfb15
MUC: better nickname check when entering a room
Mikael Berthe <mikael@lilotux.net>
parents:
625
diff
changeset
|
907 roster *roster_usr = rosterdata; |
|
68fb0c1dfb15
MUC: better nickname check when entering a room
Mikael Berthe <mikael@lilotux.net>
parents:
625
diff
changeset
|
908 |
|
68fb0c1dfb15
MUC: better nickname check when entering a room
Mikael Berthe <mikael@lilotux.net>
parents:
625
diff
changeset
|
909 if (!(roster_usr->type & ROSTER_TYPE_ROOM)) return; |
|
68fb0c1dfb15
MUC: better nickname check when entering a room
Mikael Berthe <mikael@lilotux.net>
parents:
625
diff
changeset
|
910 |
|
68fb0c1dfb15
MUC: better nickname check when entering a room
Mikael Berthe <mikael@lilotux.net>
parents:
625
diff
changeset
|
911 roster_usr->inside_room = inside; |
|
68fb0c1dfb15
MUC: better nickname check when entering a room
Mikael Berthe <mikael@lilotux.net>
parents:
625
diff
changeset
|
912 } |
|
68fb0c1dfb15
MUC: better nickname check when entering a room
Mikael Berthe <mikael@lilotux.net>
parents:
625
diff
changeset
|
913 |
|
68fb0c1dfb15
MUC: better nickname check when entering a room
Mikael Berthe <mikael@lilotux.net>
parents:
625
diff
changeset
|
914 guint8 buddy_getinsideroom(gpointer rosterdata) |
|
68fb0c1dfb15
MUC: better nickname check when entering a room
Mikael Berthe <mikael@lilotux.net>
parents:
625
diff
changeset
|
915 { |
|
68fb0c1dfb15
MUC: better nickname check when entering a room
Mikael Berthe <mikael@lilotux.net>
parents:
625
diff
changeset
|
916 roster *roster_usr = rosterdata; |
|
68fb0c1dfb15
MUC: better nickname check when entering a room
Mikael Berthe <mikael@lilotux.net>
parents:
625
diff
changeset
|
917 return roster_usr->inside_room; |
|
68fb0c1dfb15
MUC: better nickname check when entering a room
Mikael Berthe <mikael@lilotux.net>
parents:
625
diff
changeset
|
918 } |
|
68fb0c1dfb15
MUC: better nickname check when entering a room
Mikael Berthe <mikael@lilotux.net>
parents:
625
diff
changeset
|
919 |
|
548
265c50238a48
Add buddy_{get,set}topic()
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
920 // buddy_settopic(buddy, newtopic) |
|
265c50238a48
Add buddy_{get,set}topic()
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
921 // Only for chatrooms |
|
265c50238a48
Add buddy_{get,set}topic()
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
922 void buddy_settopic(gpointer rosterdata, const char *newtopic) |
|
265c50238a48
Add buddy_{get,set}topic()
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
923 { |
|
265c50238a48
Add buddy_{get,set}topic()
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
924 roster *roster_usr = rosterdata; |
|
265c50238a48
Add buddy_{get,set}topic()
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
925 |
|
265c50238a48
Add buddy_{get,set}topic()
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
926 if (!(roster_usr->type & ROSTER_TYPE_ROOM)) return; |
|
265c50238a48
Add buddy_{get,set}topic()
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
927 |
|
265c50238a48
Add buddy_{get,set}topic()
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
928 if (roster_usr->topic) { |
|
265c50238a48
Add buddy_{get,set}topic()
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
929 g_free((gchar*)roster_usr->topic); |
|
265c50238a48
Add buddy_{get,set}topic()
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
930 roster_usr->topic = NULL; |
|
265c50238a48
Add buddy_{get,set}topic()
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
931 } |
|
265c50238a48
Add buddy_{get,set}topic()
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
932 if (newtopic) |
|
265c50238a48
Add buddy_{get,set}topic()
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
933 roster_usr->topic = g_strdup(newtopic); |
|
265c50238a48
Add buddy_{get,set}topic()
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
934 } |
|
265c50238a48
Add buddy_{get,set}topic()
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
935 |
|
265c50238a48
Add buddy_{get,set}topic()
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
936 const char *buddy_gettopic(gpointer rosterdata) |
|
265c50238a48
Add buddy_{get,set}topic()
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
937 { |
|
265c50238a48
Add buddy_{get,set}topic()
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
938 roster *roster_usr = rosterdata; |
|
265c50238a48
Add buddy_{get,set}topic()
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
939 return roster_usr->topic; |
|
265c50238a48
Add buddy_{get,set}topic()
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
940 } |
|
265c50238a48
Add buddy_{get,set}topic()
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
941 |
| 207 | 942 // buddy_getgroupname() |
| 943 // Returns a pointer on buddy's group name. | |
| 944 const char *buddy_getgroupname(gpointer rosterdata) | |
| 945 { | |
| 946 roster *roster_usr = rosterdata; | |
| 947 | |
| 948 if (roster_usr->type & ROSTER_TYPE_GROUP) | |
| 949 return roster_usr->name; | |
| 950 | |
|
848
a9161d2dc414
Introduce special buffer stuff
Mikael Berthe <mikael@lilotux.net>
parents:
843
diff
changeset
|
951 if (roster_usr->type & ROSTER_TYPE_SPECIAL) |
|
a9161d2dc414
Introduce special buffer stuff
Mikael Berthe <mikael@lilotux.net>
parents:
843
diff
changeset
|
952 return NULL; |
|
a9161d2dc414
Introduce special buffer stuff
Mikael Berthe <mikael@lilotux.net>
parents:
843
diff
changeset
|
953 |
| 207 | 954 // This is a user |
| 955 return ((roster*)((GSList*)roster_usr->list)->data)->name; | |
| 72 | 956 } |
| 957 | |
| 166 | 958 // buddy_getgroup() |
| 959 // Returns a pointer on buddy's group. | |
| 960 gpointer buddy_getgroup(gpointer rosterdata) | |
| 961 { | |
| 207 | 962 roster *roster_usr = rosterdata; |
| 166 | 963 |
| 207 | 964 if (roster_usr->type & ROSTER_TYPE_GROUP) |
| 166 | 965 return rosterdata; |
| 966 | |
|
848
a9161d2dc414
Introduce special buffer stuff
Mikael Berthe <mikael@lilotux.net>
parents:
843
diff
changeset
|
967 if (roster_usr->type & ROSTER_TYPE_SPECIAL) |
|
a9161d2dc414
Introduce special buffer stuff
Mikael Berthe <mikael@lilotux.net>
parents:
843
diff
changeset
|
968 return NULL; |
|
a9161d2dc414
Introduce special buffer stuff
Mikael Berthe <mikael@lilotux.net>
parents:
843
diff
changeset
|
969 |
| 166 | 970 // This is a user |
| 207 | 971 return (gpointer)((GSList*)roster_usr->list)->data; |
| 166 | 972 } |
| 973 | |
|
489
21ab22a60bcb
Auto-convert a roster item to "room" type when receiving a groupchat message
Mikael Berthe <mikael@lilotux.net>
parents:
483
diff
changeset
|
974 void buddy_settype(gpointer rosterdata, guint type) |
|
21ab22a60bcb
Auto-convert a roster item to "room" type when receiving a groupchat message
Mikael Berthe <mikael@lilotux.net>
parents:
483
diff
changeset
|
975 { |
|
21ab22a60bcb
Auto-convert a roster item to "room" type when receiving a groupchat message
Mikael Berthe <mikael@lilotux.net>
parents:
483
diff
changeset
|
976 roster *roster_usr = rosterdata; |
|
21ab22a60bcb
Auto-convert a roster item to "room" type when receiving a groupchat message
Mikael Berthe <mikael@lilotux.net>
parents:
483
diff
changeset
|
977 roster_usr->type = type; |
|
21ab22a60bcb
Auto-convert a roster item to "room" type when receiving a groupchat message
Mikael Berthe <mikael@lilotux.net>
parents:
483
diff
changeset
|
978 } |
|
21ab22a60bcb
Auto-convert a roster item to "room" type when receiving a groupchat message
Mikael Berthe <mikael@lilotux.net>
parents:
483
diff
changeset
|
979 |
| 72 | 980 guint buddy_gettype(gpointer rosterdata) |
| 981 { | |
| 207 | 982 roster *roster_usr = rosterdata; |
| 983 return roster_usr->type; | |
| 72 | 984 } |
| 985 | |
| 603 | 986 guint buddy_getsubscription(gpointer rosterdata) |
| 987 { | |
| 988 roster *roster_usr = rosterdata; | |
| 989 return roster_usr->subscription; | |
| 990 } | |
| 991 | |
|
438
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
992 enum imstatus buddy_getstatus(gpointer rosterdata, const char *resname) |
| 72 | 993 { |
| 207 | 994 roster *roster_usr = rosterdata; |
|
438
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
995 res *p_res = get_resource(roster_usr, resname); |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
996 if (p_res) |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
997 return p_res->status; |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
998 return offline; |
| 72 | 999 } |
| 1000 | |
|
438
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
1001 const char *buddy_getstatusmsg(gpointer rosterdata, const char *resname) |
| 221 | 1002 { |
| 1003 roster *roster_usr = rosterdata; | |
|
438
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
1004 res *p_res = get_resource(roster_usr, resname); |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
1005 if (p_res) |
|
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
425
diff
changeset
|
1006 return p_res->status_msg; |
|
843
915a7f17474a
Remember the status message when a buddy goes offline
Mikael Berthe <mikael@lilotux.net>
parents:
819
diff
changeset
|
1007 return roster_usr->offline_status_message; |
| 221 | 1008 } |
| 1009 | |
|
625
028c01940490
Show presence timestamps in "/info" and "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
621
diff
changeset
|
1010 time_t buddy_getstatustime(gpointer rosterdata, const char *resname) |
|
028c01940490
Show presence timestamps in "/info" and "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
621
diff
changeset
|
1011 { |
|
028c01940490
Show presence timestamps in "/info" and "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
621
diff
changeset
|
1012 roster *roster_usr = rosterdata; |
|
028c01940490
Show presence timestamps in "/info" and "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
621
diff
changeset
|
1013 res *p_res = get_resource(roster_usr, resname); |
|
028c01940490
Show presence timestamps in "/info" and "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
621
diff
changeset
|
1014 if (p_res) |
|
028c01940490
Show presence timestamps in "/info" and "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
621
diff
changeset
|
1015 return p_res->status_timestamp; |
|
028c01940490
Show presence timestamps in "/info" and "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
621
diff
changeset
|
1016 return 0; |
|
028c01940490
Show presence timestamps in "/info" and "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
621
diff
changeset
|
1017 } |
|
028c01940490
Show presence timestamps in "/info" and "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
621
diff
changeset
|
1018 |
|
439
63562fd409a1
/info can show multiple resources
Mikael Berthe <mikael@lilotux.net>
parents:
438
diff
changeset
|
1019 gchar buddy_getresourceprio(gpointer rosterdata, const char *resname) |
|
63562fd409a1
/info can show multiple resources
Mikael Berthe <mikael@lilotux.net>
parents:
438
diff
changeset
|
1020 { |
|
63562fd409a1
/info can show multiple resources
Mikael Berthe <mikael@lilotux.net>
parents:
438
diff
changeset
|
1021 roster *roster_usr = rosterdata; |
|
63562fd409a1
/info can show multiple resources
Mikael Berthe <mikael@lilotux.net>
parents:
438
diff
changeset
|
1022 res *p_res = get_resource(roster_usr, resname); |
|
63562fd409a1
/info can show multiple resources
Mikael Berthe <mikael@lilotux.net>
parents:
438
diff
changeset
|
1023 if (p_res) |
|
63562fd409a1
/info can show multiple resources
Mikael Berthe <mikael@lilotux.net>
parents:
438
diff
changeset
|
1024 return p_res->prio; |
|
63562fd409a1
/info can show multiple resources
Mikael Berthe <mikael@lilotux.net>
parents:
438
diff
changeset
|
1025 return 0; |
|
63562fd409a1
/info can show multiple resources
Mikael Berthe <mikael@lilotux.net>
parents:
438
diff
changeset
|
1026 } |
|
63562fd409a1
/info can show multiple resources
Mikael Berthe <mikael@lilotux.net>
parents:
438
diff
changeset
|
1027 |
|
572
afc2bd38b15c
Implement affiliations handling, add "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
564
diff
changeset
|
1028 enum imrole buddy_getrole(gpointer rosterdata, const char *resname) |
|
afc2bd38b15c
Implement affiliations handling, add "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
564
diff
changeset
|
1029 { |
|
afc2bd38b15c
Implement affiliations handling, add "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
564
diff
changeset
|
1030 roster *roster_usr = rosterdata; |
|
afc2bd38b15c
Implement affiliations handling, add "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
564
diff
changeset
|
1031 res *p_res = get_resource(roster_usr, resname); |
|
afc2bd38b15c
Implement affiliations handling, add "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
564
diff
changeset
|
1032 if (p_res) |
|
afc2bd38b15c
Implement affiliations handling, add "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
564
diff
changeset
|
1033 return p_res->role; |
|
afc2bd38b15c
Implement affiliations handling, add "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
564
diff
changeset
|
1034 return role_none; |
|
afc2bd38b15c
Implement affiliations handling, add "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
564
diff
changeset
|
1035 } |
|
afc2bd38b15c
Implement affiliations handling, add "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
564
diff
changeset
|
1036 |
|
afc2bd38b15c
Implement affiliations handling, add "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
564
diff
changeset
|
1037 enum imaffiliation buddy_getaffil(gpointer rosterdata, const char *resname) |
|
afc2bd38b15c
Implement affiliations handling, add "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
564
diff
changeset
|
1038 { |
|
afc2bd38b15c
Implement affiliations handling, add "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
564
diff
changeset
|
1039 roster *roster_usr = rosterdata; |
|
afc2bd38b15c
Implement affiliations handling, add "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
564
diff
changeset
|
1040 res *p_res = get_resource(roster_usr, resname); |
|
afc2bd38b15c
Implement affiliations handling, add "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
564
diff
changeset
|
1041 if (p_res) |
|
afc2bd38b15c
Implement affiliations handling, add "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
564
diff
changeset
|
1042 return p_res->affil; |
|
afc2bd38b15c
Implement affiliations handling, add "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
564
diff
changeset
|
1043 return affil_none; |
|
afc2bd38b15c
Implement affiliations handling, add "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
564
diff
changeset
|
1044 } |
|
afc2bd38b15c
Implement affiliations handling, add "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
564
diff
changeset
|
1045 |
|
afc2bd38b15c
Implement affiliations handling, add "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
564
diff
changeset
|
1046 const char *buddy_getrjid(gpointer rosterdata, const char *resname) |
|
afc2bd38b15c
Implement affiliations handling, add "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
564
diff
changeset
|
1047 { |
|
afc2bd38b15c
Implement affiliations handling, add "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
564
diff
changeset
|
1048 roster *roster_usr = rosterdata; |
|
afc2bd38b15c
Implement affiliations handling, add "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
564
diff
changeset
|
1049 res *p_res = get_resource(roster_usr, resname); |
|
afc2bd38b15c
Implement affiliations handling, add "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
564
diff
changeset
|
1050 if (p_res) |
|
afc2bd38b15c
Implement affiliations handling, add "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
564
diff
changeset
|
1051 return p_res->realjid; |
|
afc2bd38b15c
Implement affiliations handling, add "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
564
diff
changeset
|
1052 return NULL; |
|
afc2bd38b15c
Implement affiliations handling, add "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
564
diff
changeset
|
1053 } |
|
afc2bd38b15c
Implement affiliations handling, add "/room whois"
Mikael Berthe <mikael@lilotux.net>
parents:
564
diff
changeset
|
1054 |
|
439
63562fd409a1
/info can show multiple resources
Mikael Berthe <mikael@lilotux.net>
parents:
438
diff
changeset
|
1055 // buddy_getresources(roster_data) |
|
63562fd409a1
/info can show multiple resources
Mikael Berthe <mikael@lilotux.net>
parents:
438
diff
changeset
|
1056 // Return a singly-linked-list of resource names |
|
63562fd409a1
/info can show multiple resources
Mikael Berthe <mikael@lilotux.net>
parents:
438
diff
changeset
|
1057 // Note: the caller should free the list (and data) after use |
|
501
7c1ca00070e8
Add COMPL_RESOURCE (resource completion category)
Mikael Berthe <mikael@lilotux.net>
parents:
494
diff
changeset
|
1058 // If roster_data is null, the current buddy is selected |
|
439
63562fd409a1
/info can show multiple resources
Mikael Berthe <mikael@lilotux.net>
parents:
438
diff
changeset
|
1059 GSList *buddy_getresources(gpointer rosterdata) |
|
63562fd409a1
/info can show multiple resources
Mikael Berthe <mikael@lilotux.net>
parents:
438
diff
changeset
|
1060 { |
|
63562fd409a1
/info can show multiple resources
Mikael Berthe <mikael@lilotux.net>
parents:
438
diff
changeset
|
1061 roster *roster_usr = rosterdata; |
|
63562fd409a1
/info can show multiple resources
Mikael Berthe <mikael@lilotux.net>
parents:
438
diff
changeset
|
1062 GSList *reslist = NULL, *lp; |
|
63562fd409a1
/info can show multiple resources
Mikael Berthe <mikael@lilotux.net>
parents:
438
diff
changeset
|
1063 |
|
501
7c1ca00070e8
Add COMPL_RESOURCE (resource completion category)
Mikael Berthe <mikael@lilotux.net>
parents:
494
diff
changeset
|
1064 if (!roster_usr) { |
|
7c1ca00070e8
Add COMPL_RESOURCE (resource completion category)
Mikael Berthe <mikael@lilotux.net>
parents:
494
diff
changeset
|
1065 if (!current_buddy) return NULL; |
|
7c1ca00070e8
Add COMPL_RESOURCE (resource completion category)
Mikael Berthe <mikael@lilotux.net>
parents:
494
diff
changeset
|
1066 roster_usr = BUDDATA(current_buddy); |
|
7c1ca00070e8
Add COMPL_RESOURCE (resource completion category)
Mikael Berthe <mikael@lilotux.net>
parents:
494
diff
changeset
|
1067 } |
|
439
63562fd409a1
/info can show multiple resources
Mikael Berthe <mikael@lilotux.net>
parents:
438
diff
changeset
|
1068 for (lp = roster_usr->resource; lp; lp = g_slist_next(lp)) |
|
63562fd409a1
/info can show multiple resources
Mikael Berthe <mikael@lilotux.net>
parents:
438
diff
changeset
|
1069 reslist = g_slist_append(reslist, g_strdup(((res*)lp->data)->name)); |
|
63562fd409a1
/info can show multiple resources
Mikael Berthe <mikael@lilotux.net>
parents:
438
diff
changeset
|
1070 |
|
63562fd409a1
/info can show multiple resources
Mikael Berthe <mikael@lilotux.net>
parents:
438
diff
changeset
|
1071 return reslist; |
|
63562fd409a1
/info can show multiple resources
Mikael Berthe <mikael@lilotux.net>
parents:
438
diff
changeset
|
1072 } |
|
63562fd409a1
/info can show multiple resources
Mikael Berthe <mikael@lilotux.net>
parents:
438
diff
changeset
|
1073 |
|
792
89ad7b530b3c
MUC: Fix completion for UTF-8 nicknames
Mikael Berthe <mikael@lilotux.net>
parents:
783
diff
changeset
|
1074 // buddy_getresources_locale(roster_data) |
|
89ad7b530b3c
MUC: Fix completion for UTF-8 nicknames
Mikael Berthe <mikael@lilotux.net>
parents:
783
diff
changeset
|
1075 // Same as buddy_getresources() but names are converted to user's locale |
|
89ad7b530b3c
MUC: Fix completion for UTF-8 nicknames
Mikael Berthe <mikael@lilotux.net>
parents:
783
diff
changeset
|
1076 // Note: the caller should free the list (and data) after use |
|
89ad7b530b3c
MUC: Fix completion for UTF-8 nicknames
Mikael Berthe <mikael@lilotux.net>
parents:
783
diff
changeset
|
1077 GSList *buddy_getresources_locale(gpointer rosterdata) |
|
89ad7b530b3c
MUC: Fix completion for UTF-8 nicknames
Mikael Berthe <mikael@lilotux.net>
parents:
783
diff
changeset
|
1078 { |
|
89ad7b530b3c
MUC: Fix completion for UTF-8 nicknames
Mikael Berthe <mikael@lilotux.net>
parents:
783
diff
changeset
|
1079 GSList *reslist, *lp; |
|
89ad7b530b3c
MUC: Fix completion for UTF-8 nicknames
Mikael Berthe <mikael@lilotux.net>
parents:
783
diff
changeset
|
1080 |
|
89ad7b530b3c
MUC: Fix completion for UTF-8 nicknames
Mikael Berthe <mikael@lilotux.net>
parents:
783
diff
changeset
|
1081 reslist = buddy_getresources(rosterdata); |
|
89ad7b530b3c
MUC: Fix completion for UTF-8 nicknames
Mikael Berthe <mikael@lilotux.net>
parents:
783
diff
changeset
|
1082 // Convert each item to UI's locale |
|
89ad7b530b3c
MUC: Fix completion for UTF-8 nicknames
Mikael Berthe <mikael@lilotux.net>
parents:
783
diff
changeset
|
1083 for (lp = reslist; lp; lp = g_slist_next(lp)) { |
|
89ad7b530b3c
MUC: Fix completion for UTF-8 nicknames
Mikael Berthe <mikael@lilotux.net>
parents:
783
diff
changeset
|
1084 gchar *oldname = lp->data; |
|
89ad7b530b3c
MUC: Fix completion for UTF-8 nicknames
Mikael Berthe <mikael@lilotux.net>
parents:
783
diff
changeset
|
1085 lp->data = from_utf8(oldname); |
|
89ad7b530b3c
MUC: Fix completion for UTF-8 nicknames
Mikael Berthe <mikael@lilotux.net>
parents:
783
diff
changeset
|
1086 if (lp->data) |
|
89ad7b530b3c
MUC: Fix completion for UTF-8 nicknames
Mikael Berthe <mikael@lilotux.net>
parents:
783
diff
changeset
|
1087 g_free(oldname); |
|
89ad7b530b3c
MUC: Fix completion for UTF-8 nicknames
Mikael Berthe <mikael@lilotux.net>
parents:
783
diff
changeset
|
1088 else |
|
89ad7b530b3c
MUC: Fix completion for UTF-8 nicknames
Mikael Berthe <mikael@lilotux.net>
parents:
783
diff
changeset
|
1089 lp->data = oldname; |
|
89ad7b530b3c
MUC: Fix completion for UTF-8 nicknames
Mikael Berthe <mikael@lilotux.net>
parents:
783
diff
changeset
|
1090 } |
|
89ad7b530b3c
MUC: Fix completion for UTF-8 nicknames
Mikael Berthe <mikael@lilotux.net>
parents:
783
diff
changeset
|
1091 return reslist; |
|
89ad7b530b3c
MUC: Fix completion for UTF-8 nicknames
Mikael Berthe <mikael@lilotux.net>
parents:
783
diff
changeset
|
1092 } |
|
89ad7b530b3c
MUC: Fix completion for UTF-8 nicknames
Mikael Berthe <mikael@lilotux.net>
parents:
783
diff
changeset
|
1093 |
|
652
b243d3b3ff1b
We do not need buddy_isresource() anymore
Mikael Berthe <mikael@lilotux.net>
parents:
649
diff
changeset
|
1094 /* |
| 539 | 1095 // buddy_isresource(roster_data) |
| 1096 // Return true if there is at least one resource | |
| 1097 // (which means, for a room, that it isn't empty) | |
| 1098 int buddy_isresource(gpointer rosterdata) | |
| 1099 { | |
| 1100 roster *roster_usr = rosterdata; | |
| 1101 if (!roster_usr) | |
| 1102 return FALSE; | |
| 1103 if (roster_usr->resource) | |
| 1104 return TRUE; | |
| 1105 return FALSE; | |
| 1106 } | |
|
652
b243d3b3ff1b
We do not need buddy_isresource() anymore
Mikael Berthe <mikael@lilotux.net>
parents:
649
diff
changeset
|
1107 */ |
| 539 | 1108 |
|
468
644b8bf9ca4d
Improve MUC presence messages handling
Mikael Berthe <mikael@lilotux.net>
parents:
447
diff
changeset
|
1109 // buddy_resource_setname(roster_data, oldname, newname) |
|
644b8bf9ca4d
Improve MUC presence messages handling
Mikael Berthe <mikael@lilotux.net>
parents:
447
diff
changeset
|
1110 // Useful for nickname change in a MUC room |
|
644b8bf9ca4d
Improve MUC presence messages handling
Mikael Berthe <mikael@lilotux.net>
parents:
447
diff
changeset
|
1111 void buddy_resource_setname(gpointer rosterdata, const char *resname, |
|
644b8bf9ca4d
Improve MUC presence messages handling
Mikael Berthe <mikael@lilotux.net>
parents:
447
diff
changeset
|
1112 const char *newname) |
|
644b8bf9ca4d
Improve MUC presence messages handling
Mikael Berthe <mikael@lilotux.net>
parents:
447
diff
changeset
|
1113 { |
|
644b8bf9ca4d
Improve MUC presence messages handling
Mikael Berthe <mikael@lilotux.net>
parents:
447
diff
changeset
|
1114 roster *roster_usr = rosterdata; |
|
644b8bf9ca4d
Improve MUC presence messages handling
Mikael Berthe <mikael@lilotux.net>
parents:
447
diff
changeset
|
1115 res *p_res = get_resource(roster_usr, resname); |
|
644b8bf9ca4d
Improve MUC presence messages handling
Mikael Berthe <mikael@lilotux.net>
parents:
447
diff
changeset
|
1116 if (p_res) { |
|
644b8bf9ca4d
Improve MUC presence messages handling
Mikael Berthe <mikael@lilotux.net>
parents:
447
diff
changeset
|
1117 if (p_res->name) { |
|
644b8bf9ca4d
Improve MUC presence messages handling
Mikael Berthe <mikael@lilotux.net>
parents:
447
diff
changeset
|
1118 g_free((gchar*)p_res->name); |
|
644b8bf9ca4d
Improve MUC presence messages handling
Mikael Berthe <mikael@lilotux.net>
parents:
447
diff
changeset
|
1119 p_res->name = NULL; |
|
644b8bf9ca4d
Improve MUC presence messages handling
Mikael Berthe <mikael@lilotux.net>
parents:
447
diff
changeset
|
1120 } |
|
644b8bf9ca4d
Improve MUC presence messages handling
Mikael Berthe <mikael@lilotux.net>
parents:
447
diff
changeset
|
1121 if (newname) |
|
644b8bf9ca4d
Improve MUC presence messages handling
Mikael Berthe <mikael@lilotux.net>
parents:
447
diff
changeset
|
1122 p_res->name = g_strdup(newname); |
|
644b8bf9ca4d
Improve MUC presence messages handling
Mikael Berthe <mikael@lilotux.net>
parents:
447
diff
changeset
|
1123 } |
|
644b8bf9ca4d
Improve MUC presence messages handling
Mikael Berthe <mikael@lilotux.net>
parents:
447
diff
changeset
|
1124 } |
|
644b8bf9ca4d
Improve MUC presence messages handling
Mikael Berthe <mikael@lilotux.net>
parents:
447
diff
changeset
|
1125 |
|
447
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
1126 // buddy_del_all_resources() |
|
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
1127 // Remove all resources from the specified buddy |
|
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
1128 void buddy_del_all_resources(gpointer rosterdata) |
|
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
1129 { |
|
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
1130 roster *roster_usr = rosterdata; |
|
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
1131 |
|
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
1132 while (roster_usr->resource) { |
|
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
1133 res *r = roster_usr->resource->data; |
|
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
1134 del_resource(roster_usr, r->name); |
|
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
1135 } |
|
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
1136 } |
|
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
1137 |
| 119 | 1138 // buddy_setflags() |
| 1139 // Set one or several flags to value (TRUE/FALSE) | |
| 1140 void buddy_setflags(gpointer rosterdata, guint flags, guint value) | |
| 1141 { | |
| 207 | 1142 roster *roster_usr = rosterdata; |
| 119 | 1143 if (value) |
| 207 | 1144 roster_usr->flags |= flags; |
| 119 | 1145 else |
| 207 | 1146 roster_usr->flags &= ~flags; |
| 119 | 1147 } |
| 1148 | |
| 72 | 1149 guint buddy_getflags(gpointer rosterdata) |
| 1150 { | |
| 207 | 1151 roster *roster_usr = rosterdata; |
| 1152 return roster_usr->flags; | |
| 72 | 1153 } |
| 1154 | |
| 480 | 1155 // buddy_search_jid(jid) |
| 1156 // Look for a buddy with specified jid. | |
| 1157 // Search begins at buddylist; if no match is found in the the buddylist, | |
| 1158 // return NULL; | |
| 1159 GList *buddy_search_jid(char *jid) | |
| 1160 { | |
| 1161 GList *buddy; | |
| 1162 roster *roster_usr; | |
| 1163 | |
| 1164 if (!buddylist) return NULL; | |
| 1165 | |
| 1166 for (buddy = buddylist; buddy; buddy = g_list_next(buddy)) { | |
| 1167 roster_usr = (roster*)buddy->data; | |
| 1168 if (roster_usr->jid && !strcasecmp(roster_usr->jid, jid)) | |
| 1169 return buddy; | |
| 1170 } | |
| 1171 return NULL; | |
| 1172 } | |
| 1173 | |
| 265 | 1174 // buddy_search(string) |
| 1175 // Look for a buddy whose name or jid contains string. | |
| 1176 // Search begins at current_buddy; if no match is found in the the buddylist, | |
| 1177 // return NULL; | |
| 1178 GList *buddy_search(char *string) | |
| 1179 { | |
| 1180 GList *buddy = current_buddy; | |
| 1181 roster *roster_usr; | |
| 1182 if (!buddylist || !current_buddy) return NULL; | |
| 1183 for (;;) { | |
|
772
464be13343a9
Store most data in UTF-8 internally
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
1184 gchar *jid_locale, *name_locale; |
|
464be13343a9
Store most data in UTF-8 internally
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
1185 char *found = NULL; |
|
464be13343a9
Store most data in UTF-8 internally
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
1186 |
| 265 | 1187 buddy = g_list_next(buddy); |
| 1188 if (!buddy) | |
| 1189 buddy = buddylist; | |
| 1190 | |
| 1191 roster_usr = (roster*)buddy->data; | |
|
772
464be13343a9
Store most data in UTF-8 internally
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
1192 |
|
464be13343a9
Store most data in UTF-8 internally
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
1193 jid_locale = from_utf8(roster_usr->jid); |
|
464be13343a9
Store most data in UTF-8 internally
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
1194 if (jid_locale) { |
|
464be13343a9
Store most data in UTF-8 internally
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
1195 found = strcasestr(jid_locale, string); |
|
464be13343a9
Store most data in UTF-8 internally
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
1196 g_free(jid_locale); |
|
464be13343a9
Store most data in UTF-8 internally
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
1197 if (found) |
|
464be13343a9
Store most data in UTF-8 internally
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
1198 return buddy; |
|
464be13343a9
Store most data in UTF-8 internally
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
1199 } |
|
464be13343a9
Store most data in UTF-8 internally
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
1200 name_locale = from_utf8(roster_usr->name); |
|
464be13343a9
Store most data in UTF-8 internally
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
1201 if (name_locale) { |
|
464be13343a9
Store most data in UTF-8 internally
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
1202 found = strcasestr(name_locale, string); |
|
464be13343a9
Store most data in UTF-8 internally
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
1203 g_free(name_locale); |
|
464be13343a9
Store most data in UTF-8 internally
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
1204 if (found) |
|
464be13343a9
Store most data in UTF-8 internally
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
1205 return buddy; |
|
464be13343a9
Store most data in UTF-8 internally
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
1206 } |
| 265 | 1207 |
| 1208 if (buddy == current_buddy) | |
| 1209 return NULL; // Back to the beginning, and no match found | |
| 1210 } | |
| 1211 } | |
| 1212 | |
|
532
2ac8d8e49e81
Send status changes to chatrooms
Mikael Berthe <mikael@lilotux.net>
parents:
520
diff
changeset
|
1213 // foreach_buddy(roster_type, pfunction, param) |
|
2ac8d8e49e81
Send status changes to chatrooms
Mikael Berthe <mikael@lilotux.net>
parents:
520
diff
changeset
|
1214 // Call pfunction(buddy, param) for each buddy from the roster with |
|
2ac8d8e49e81
Send status changes to chatrooms
Mikael Berthe <mikael@lilotux.net>
parents:
520
diff
changeset
|
1215 // type matching roster_type. |
|
2ac8d8e49e81
Send status changes to chatrooms
Mikael Berthe <mikael@lilotux.net>
parents:
520
diff
changeset
|
1216 void foreach_buddy(guint roster_type, |
|
2ac8d8e49e81
Send status changes to chatrooms
Mikael Berthe <mikael@lilotux.net>
parents:
520
diff
changeset
|
1217 void (*pfunc)(gpointer rosterdata, void *param), |
|
2ac8d8e49e81
Send status changes to chatrooms
Mikael Berthe <mikael@lilotux.net>
parents:
520
diff
changeset
|
1218 void *param) |
|
2ac8d8e49e81
Send status changes to chatrooms
Mikael Berthe <mikael@lilotux.net>
parents:
520
diff
changeset
|
1219 { |
|
2ac8d8e49e81
Send status changes to chatrooms
Mikael Berthe <mikael@lilotux.net>
parents:
520
diff
changeset
|
1220 GSList *sl_roster_elt = groups; |
|
2ac8d8e49e81
Send status changes to chatrooms
Mikael Berthe <mikael@lilotux.net>
parents:
520
diff
changeset
|
1221 roster *roster_elt; |
|
2ac8d8e49e81
Send status changes to chatrooms
Mikael Berthe <mikael@lilotux.net>
parents:
520
diff
changeset
|
1222 GSList *sl_roster_usrelt; |
|
2ac8d8e49e81
Send status changes to chatrooms
Mikael Berthe <mikael@lilotux.net>
parents:
520
diff
changeset
|
1223 roster *roster_usrelt; |
|
2ac8d8e49e81
Send status changes to chatrooms
Mikael Berthe <mikael@lilotux.net>
parents:
520
diff
changeset
|
1224 |
|
2ac8d8e49e81
Send status changes to chatrooms
Mikael Berthe <mikael@lilotux.net>
parents:
520
diff
changeset
|
1225 while (sl_roster_elt) { // group list loop |
|
2ac8d8e49e81
Send status changes to chatrooms
Mikael Berthe <mikael@lilotux.net>
parents:
520
diff
changeset
|
1226 roster_elt = (roster*) sl_roster_elt->data; |
|
848
a9161d2dc414
Introduce special buffer stuff
Mikael Berthe <mikael@lilotux.net>
parents:
843
diff
changeset
|
1227 if (roster_elt->type & ROSTER_TYPE_SPECIAL) |
|
a9161d2dc414
Introduce special buffer stuff
Mikael Berthe <mikael@lilotux.net>
parents:
843
diff
changeset
|
1228 continue; // Skip special items |
|
532
2ac8d8e49e81
Send status changes to chatrooms
Mikael Berthe <mikael@lilotux.net>
parents:
520
diff
changeset
|
1229 sl_roster_usrelt = roster_elt->list; |
|
2ac8d8e49e81
Send status changes to chatrooms
Mikael Berthe <mikael@lilotux.net>
parents:
520
diff
changeset
|
1230 while (sl_roster_usrelt) { // user list loop |
|
2ac8d8e49e81
Send status changes to chatrooms
Mikael Berthe <mikael@lilotux.net>
parents:
520
diff
changeset
|
1231 roster_usrelt = (roster*) sl_roster_usrelt->data; |
|
2ac8d8e49e81
Send status changes to chatrooms
Mikael Berthe <mikael@lilotux.net>
parents:
520
diff
changeset
|
1232 |
|
2ac8d8e49e81
Send status changes to chatrooms
Mikael Berthe <mikael@lilotux.net>
parents:
520
diff
changeset
|
1233 if (roster_usrelt->type & roster_type) |
|
2ac8d8e49e81
Send status changes to chatrooms
Mikael Berthe <mikael@lilotux.net>
parents:
520
diff
changeset
|
1234 pfunc(roster_usrelt, param); |
|
2ac8d8e49e81
Send status changes to chatrooms
Mikael Berthe <mikael@lilotux.net>
parents:
520
diff
changeset
|
1235 |
|
2ac8d8e49e81
Send status changes to chatrooms
Mikael Berthe <mikael@lilotux.net>
parents:
520
diff
changeset
|
1236 sl_roster_usrelt = g_slist_next(sl_roster_usrelt); |
|
2ac8d8e49e81
Send status changes to chatrooms
Mikael Berthe <mikael@lilotux.net>
parents:
520
diff
changeset
|
1237 } |
|
2ac8d8e49e81
Send status changes to chatrooms
Mikael Berthe <mikael@lilotux.net>
parents:
520
diff
changeset
|
1238 sl_roster_elt = g_slist_next(sl_roster_elt); |
|
2ac8d8e49e81
Send status changes to chatrooms
Mikael Berthe <mikael@lilotux.net>
parents:
520
diff
changeset
|
1239 } |
|
2ac8d8e49e81
Send status changes to chatrooms
Mikael Berthe <mikael@lilotux.net>
parents:
520
diff
changeset
|
1240 } |
|
2ac8d8e49e81
Send status changes to chatrooms
Mikael Berthe <mikael@lilotux.net>
parents:
520
diff
changeset
|
1241 |
| 225 | 1242 // compl_list(type) |
| 1243 // Returns a list of jid's or groups. (For commands completion) | |
| 1244 // type: ROSTER_TYPE_USER (jid's) or ROSTER_TYPE_GROUP (group names) | |
| 1245 // The list should be freed by the caller after use. | |
| 1246 GSList *compl_list(guint type) | |
| 1247 { | |
| 1248 GSList *list = NULL; | |
| 1249 GList *buddy = buddylist; | |
| 1250 | |
| 1251 for ( ; buddy ; buddy = g_list_next(buddy)) { | |
| 1252 guint btype = buddy_gettype(BUDDATA(buddy)); | |
| 1253 | |
| 1254 if (type == ROSTER_TYPE_GROUP) { // (group names) | |
| 1255 if (btype == ROSTER_TYPE_GROUP) { | |
| 1256 const char *bname = buddy_getname(BUDDATA(buddy)); | |
| 1257 if ((bname) && (*bname)) | |
|
772
464be13343a9
Store most data in UTF-8 internally
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
1258 list = g_slist_append(list, from_utf8(bname)); |
| 225 | 1259 } |
|
447
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
439
diff
changeset
|
1260 } else { // ROSTER_TYPE_USER (jid) (or agent, or chatroom...) |
| 225 | 1261 const char *bjid = buddy_getjid(BUDDATA(buddy)); |
| 1262 if (bjid) | |
|
772
464be13343a9
Store most data in UTF-8 internally
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
1263 list = g_slist_append(list, from_utf8(bjid)); |
| 225 | 1264 } |
| 1265 } | |
| 1266 | |
| 1267 return list; | |
| 1268 } | |
| 1269 | |
| 236 | 1270 // unread_msg(rosterdata) |
| 1271 // Return the next buddy with an unread message. If the parameter is NULL, | |
| 1272 // return the first buddy with an unread message. | |
| 1273 gpointer unread_msg(gpointer rosterdata) | |
| 1274 { | |
| 1275 GSList *unread, *next_unread; | |
| 1276 | |
| 564 | 1277 if (!unread_list) |
| 1278 return NULL; | |
| 1279 | |
| 236 | 1280 // First unread message |
| 564 | 1281 if (!rosterdata) |
| 1282 return unread_list->data; | |
| 236 | 1283 |
| 1284 unread = g_slist_find(unread_list, rosterdata); | |
| 564 | 1285 if (!unread) |
| 1286 return unread_list->data; | |
| 236 | 1287 |
| 1288 next_unread = g_slist_next(unread); | |
| 564 | 1289 if (next_unread) |
| 1290 return next_unread->data; | |
| 236 | 1291 return unread_list->data; |
| 1292 } | |
| 576 | 1293 |
|
662
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1294 |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1295 /* ### "unread_jids" functions ### |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1296 * |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1297 * The unread_jids hash table is used to keep track of the buddies with |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1298 * unread messages when a disconnection occurs. |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1299 * When removing a buddy with an unread message from the roster, the |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1300 * jid should be added to the unread_jids table. When adding a buddy to |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1301 * the roster, we check if (s)he had a pending unread message. |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1302 */ |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1303 |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1304 // unread_jid_add(jid) |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1305 // Add jid to the unread_jids hash table |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1306 void unread_jid_add(const char *jid) |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1307 { |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1308 if (!unread_jids) { |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1309 // Initialize unread_jids hash table |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1310 unread_jids = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL); |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1311 } |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1312 // The 2nd unread_jids is an arbitrary non-null pointer: |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1313 g_hash_table_insert(unread_jids, g_strdup(jid), unread_jids); |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1314 } |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1315 |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1316 // unread_jid_del(jid) |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1317 // Return TRUE if jid is found in the table (and remove it), FALSE if not |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1318 int unread_jid_del(const char *jid) |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1319 { |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1320 if (!unread_jids) |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1321 return FALSE; |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1322 return g_hash_table_remove(unread_jids, jid); |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1323 } |
|
4111ff4cdd15
Do not loose the unread_message flag when disconnecting from the server
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1324 |
| 580 | 1325 /* vim: set expandtab cindent cinoptions=>2\:2(0: For Vim users... */ |