Mercurial > pidgin.yaz
comparison gtk/gtkpounce.c @ 14191:009db0b357b5
This is a hand-crafted commit to migrate across subversion revisions
16854:16861, due to some vagaries of the way the original renames were
done. Witness that monotone can do in one revision what svn had to
spread across several.
author | Ethan Blanton <elb@pidgin.im> |
---|---|
date | Sat, 16 Dec 2006 04:59:55 +0000 |
parents | |
children | 33ac3c591b4a |
comparison
equal
deleted
inserted
replaced
14190:366be2ce35a7 | 14191:009db0b357b5 |
---|---|
1 /** | |
2 * @file gtkpounce.c GTK+ Buddy Pounce API | |
3 * @ingroup gtkui | |
4 * | |
5 * gaim | |
6 * | |
7 * Gaim is the legal property of its developers, whose names are too numerous | |
8 * to list here. Please refer to the COPYRIGHT file distributed with this | |
9 * source distribution. | |
10 * | |
11 * This program is free software; you can redistribute it and/or modify | |
12 * it under the terms of the GNU General Public License as published by | |
13 * the Free Software Foundation; either version 2 of the License, or | |
14 * (at your option) any later version. | |
15 * | |
16 * This program is distributed in the hope that it will be useful, | |
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
19 * GNU General Public License for more details. | |
20 * | |
21 * You should have received a copy of the GNU General Public License | |
22 * along with this program; if not, write to the Free Software | |
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
24 * | |
25 */ | |
26 #include "internal.h" | |
27 #include "gtkgaim.h" | |
28 | |
29 #include "account.h" | |
30 #include "conversation.h" | |
31 #include "debug.h" | |
32 #include "notify.h" | |
33 #include "prpl.h" | |
34 #include "request.h" | |
35 #include "server.h" | |
36 #include "sound.h" | |
37 #include "util.h" | |
38 | |
39 #include "gtkblist.h" | |
40 #include "gtkdialogs.h" | |
41 #include "gtkpounce.h" | |
42 #include "gaimstock.h" | |
43 #include "gtkutils.h" | |
44 | |
45 /** | |
46 * These are used for the GtkTreeView when you're scrolling through | |
47 * all your saved pounces. | |
48 */ | |
49 enum | |
50 { | |
51 /* Hidden column containing the GaimPounce */ | |
52 POUNCES_MANAGER_COLUMN_POUNCE, | |
53 POUNCES_MANAGER_COLUMN_ICON, | |
54 POUNCES_MANAGER_COLUMN_TARGET, | |
55 POUNCES_MANAGER_COLUMN_ACCOUNT, | |
56 POUNCES_MANAGER_COLUMN_RECURRING, | |
57 POUNCES_MANAGER_NUM_COLUMNS | |
58 }; | |
59 | |
60 typedef struct | |
61 { | |
62 /* Pounce data */ | |
63 GaimPounce *pounce; | |
64 GaimAccount *account; | |
65 | |
66 /* The window */ | |
67 GtkWidget *window; | |
68 | |
69 /* Pounce on Whom */ | |
70 GtkWidget *account_menu; | |
71 GtkWidget *buddy_entry; | |
72 | |
73 /* Pounce options */ | |
74 GtkWidget *on_away; | |
75 | |
76 /* Pounce When Buddy... */ | |
77 GtkWidget *signon; | |
78 GtkWidget *signoff; | |
79 GtkWidget *away; | |
80 GtkWidget *away_return; | |
81 GtkWidget *idle; | |
82 GtkWidget *idle_return; | |
83 GtkWidget *typing; | |
84 GtkWidget *typed; | |
85 GtkWidget *stop_typing; | |
86 GtkWidget *message_recv; | |
87 | |
88 /* Action */ | |
89 GtkWidget *open_win; | |
90 GtkWidget *popup; | |
91 GtkWidget *popup_entry; | |
92 GtkWidget *send_msg; | |
93 GtkWidget *send_msg_entry; | |
94 GtkWidget *exec_cmd; | |
95 GtkWidget *exec_cmd_entry; | |
96 GtkWidget *exec_cmd_browse; | |
97 GtkWidget *play_sound; | |
98 GtkWidget *play_sound_entry; | |
99 GtkWidget *play_sound_browse; | |
100 GtkWidget *play_sound_test; | |
101 | |
102 GtkWidget *save_pounce; | |
103 | |
104 /* Buttons */ | |
105 GtkWidget *save_button; | |
106 | |
107 } GaimGtkPounceDialog; | |
108 | |
109 typedef struct | |
110 { | |
111 GtkWidget *window; | |
112 GtkListStore *model; | |
113 GtkWidget *treeview; | |
114 GtkWidget *modify_button; | |
115 GtkWidget *delete_button; | |
116 } PouncesManager; | |
117 | |
118 static PouncesManager *pounces_manager = NULL; | |
119 | |
120 /************************************************************************** | |
121 * Callbacks | |
122 **************************************************************************/ | |
123 static gint | |
124 delete_win_cb(GtkWidget *w, GdkEventAny *e, GaimGtkPounceDialog *dialog) | |
125 { | |
126 gtk_widget_destroy(dialog->window); | |
127 g_free(dialog); | |
128 | |
129 return TRUE; | |
130 } | |
131 | |
132 static void | |
133 cancel_cb(GtkWidget *w, GaimGtkPounceDialog *dialog) | |
134 { | |
135 delete_win_cb(NULL, NULL, dialog); | |
136 } | |
137 | |
138 static void | |
139 pounce_update_entry_fields(void *user_data, const char *filename) | |
140 { | |
141 GtkWidget *entry = (GtkWidget *)user_data; | |
142 | |
143 gtk_entry_set_text(GTK_ENTRY(entry), filename); | |
144 } | |
145 | |
146 static void | |
147 filesel(GtkWidget *widget, gpointer data) | |
148 { | |
149 GtkWidget *entry; | |
150 const gchar *name; | |
151 | |
152 entry = (GtkWidget *)data; | |
153 name = gtk_entry_get_text(GTK_ENTRY(entry)); | |
154 | |
155 gaim_request_file(entry, _("Select a file"), name, FALSE, | |
156 G_CALLBACK(pounce_update_entry_fields), NULL, entry); | |
157 } | |
158 | |
159 static void | |
160 pounce_test_sound(GtkWidget *w, GtkWidget *entry) | |
161 { | |
162 const char *filename; | |
163 | |
164 filename = gtk_entry_get_text(GTK_ENTRY(entry)); | |
165 | |
166 if (filename != NULL && *filename != '\0') | |
167 gaim_sound_play_file(filename, NULL); | |
168 else | |
169 gaim_sound_play_event(GAIM_SOUND_POUNCE_DEFAULT, NULL); | |
170 } | |
171 | |
172 static void | |
173 add_pounce_to_treeview(GtkListStore *model, GaimPounce *pounce) | |
174 { | |
175 GtkTreeIter iter; | |
176 GaimAccount *account; | |
177 GaimPounceEvent events; | |
178 gboolean recurring; | |
179 const char *pouncer; | |
180 const char *pouncee; | |
181 GdkPixbuf *pixbuf; | |
182 | |
183 account = gaim_pounce_get_pouncer(pounce); | |
184 | |
185 if (gaim_account_is_disconnected(account)) | |
186 return; | |
187 | |
188 events = gaim_pounce_get_events(pounce); | |
189 | |
190 pixbuf = gaim_gtk_create_prpl_icon(account, 0.5); | |
191 | |
192 pouncer = gaim_account_get_username(account); | |
193 pouncee = gaim_pounce_get_pouncee(pounce); | |
194 recurring = gaim_pounce_get_save(pounce); | |
195 | |
196 gtk_list_store_append(model, &iter); | |
197 gtk_list_store_set(model, &iter, | |
198 POUNCES_MANAGER_COLUMN_POUNCE, pounce, | |
199 POUNCES_MANAGER_COLUMN_ICON, pixbuf, | |
200 POUNCES_MANAGER_COLUMN_TARGET, pouncee, | |
201 POUNCES_MANAGER_COLUMN_ACCOUNT, pouncer, | |
202 POUNCES_MANAGER_COLUMN_RECURRING, recurring, | |
203 -1); | |
204 | |
205 if (pixbuf != NULL) | |
206 g_object_unref(pixbuf); | |
207 } | |
208 | |
209 static void | |
210 populate_pounces_list(PouncesManager *dialog) | |
211 { | |
212 const GList *pounces; | |
213 | |
214 gtk_list_store_clear(dialog->model); | |
215 | |
216 for (pounces = gaim_pounces_get_all(); pounces != NULL; | |
217 pounces = g_list_next(pounces)) | |
218 { | |
219 add_pounce_to_treeview(dialog->model, pounces->data); | |
220 } | |
221 } | |
222 | |
223 static void | |
224 update_pounces(void) | |
225 { | |
226 /* Rebuild the pounces list if the pounces manager is open */ | |
227 if (pounces_manager != NULL) | |
228 { | |
229 populate_pounces_list(pounces_manager); | |
230 } | |
231 } | |
232 | |
233 static void | |
234 signed_on_off_cb(GaimConnection *gc, gpointer user_data) | |
235 { | |
236 update_pounces(); | |
237 } | |
238 | |
239 static void | |
240 save_pounce_cb(GtkWidget *w, GaimGtkPounceDialog *dialog) | |
241 { | |
242 const char *name; | |
243 const char *message, *command, *sound, *reason; | |
244 GaimPounceEvent events = GAIM_POUNCE_NONE; | |
245 GaimPounceOption options = GAIM_POUNCE_OPTION_NONE; | |
246 | |
247 name = gtk_entry_get_text(GTK_ENTRY(dialog->buddy_entry)); | |
248 | |
249 if (*name == '\0') | |
250 { | |
251 gaim_notify_error(NULL, NULL, | |
252 _("Please enter a buddy to pounce."), NULL); | |
253 return; | |
254 } | |
255 | |
256 /* Options */ | |
257 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->on_away))) | |
258 options |= GAIM_POUNCE_OPTION_AWAY; | |
259 | |
260 /* Events */ | |
261 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->signon))) | |
262 events |= GAIM_POUNCE_SIGNON; | |
263 | |
264 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->signoff))) | |
265 events |= GAIM_POUNCE_SIGNOFF; | |
266 | |
267 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->away))) | |
268 events |= GAIM_POUNCE_AWAY; | |
269 | |
270 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->away_return))) | |
271 events |= GAIM_POUNCE_AWAY_RETURN; | |
272 | |
273 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->idle))) | |
274 events |= GAIM_POUNCE_IDLE; | |
275 | |
276 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->idle_return))) | |
277 events |= GAIM_POUNCE_IDLE_RETURN; | |
278 | |
279 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->typing))) | |
280 events |= GAIM_POUNCE_TYPING; | |
281 | |
282 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->typed))) | |
283 events |= GAIM_POUNCE_TYPED; | |
284 | |
285 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->stop_typing))) | |
286 events |= GAIM_POUNCE_TYPING_STOPPED; | |
287 | |
288 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->message_recv))) | |
289 events |= GAIM_POUNCE_MESSAGE_RECEIVED; | |
290 | |
291 /* Data fields */ | |
292 message = gtk_entry_get_text(GTK_ENTRY(dialog->send_msg_entry)); | |
293 command = gtk_entry_get_text(GTK_ENTRY(dialog->exec_cmd_entry)); | |
294 sound = gtk_entry_get_text(GTK_ENTRY(dialog->play_sound_entry)); | |
295 reason = gtk_entry_get_text(GTK_ENTRY(dialog->popup_entry)); | |
296 | |
297 if (*reason == '\0') reason = NULL; | |
298 if (*message == '\0') message = NULL; | |
299 if (*command == '\0') command = NULL; | |
300 if (*sound == '\0') sound = NULL; | |
301 | |
302 if (dialog->pounce == NULL) | |
303 { | |
304 dialog->pounce = gaim_pounce_new(GAIM_GTK_UI, dialog->account, | |
305 name, events, options); | |
306 } | |
307 else { | |
308 gaim_pounce_set_events(dialog->pounce, events); | |
309 gaim_pounce_set_options(dialog->pounce, options); | |
310 gaim_pounce_set_pouncer(dialog->pounce, dialog->account); | |
311 gaim_pounce_set_pouncee(dialog->pounce, name); | |
312 } | |
313 | |
314 /* Actions */ | |
315 gaim_pounce_action_set_enabled(dialog->pounce, "open-window", | |
316 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->open_win))); | |
317 gaim_pounce_action_set_enabled(dialog->pounce, "popup-notify", | |
318 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->popup))); | |
319 gaim_pounce_action_set_enabled(dialog->pounce, "send-message", | |
320 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->send_msg))); | |
321 gaim_pounce_action_set_enabled(dialog->pounce, "execute-command", | |
322 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->exec_cmd))); | |
323 gaim_pounce_action_set_enabled(dialog->pounce, "play-sound", | |
324 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->play_sound))); | |
325 | |
326 gaim_pounce_action_set_attribute(dialog->pounce, "send-message", | |
327 "message", message); | |
328 gaim_pounce_action_set_attribute(dialog->pounce, "execute-command", | |
329 "command", command); | |
330 gaim_pounce_action_set_attribute(dialog->pounce, "play-sound", | |
331 "filename", sound); | |
332 gaim_pounce_action_set_attribute(dialog->pounce, "popup-notify", | |
333 "reason", reason); | |
334 | |
335 /* Set the defaults for next time. */ | |
336 gaim_prefs_set_bool("/gaim/gtk/pounces/default_actions/open-window", | |
337 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->open_win))); | |
338 gaim_prefs_set_bool("/gaim/gtk/pounces/default_actions/popup-notify", | |
339 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->popup))); | |
340 gaim_prefs_set_bool("/gaim/gtk/pounces/default_actions/send-message", | |
341 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->send_msg))); | |
342 gaim_prefs_set_bool("/gaim/gtk/pounces/default_actions/execute-command", | |
343 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->exec_cmd))); | |
344 gaim_prefs_set_bool("/gaim/gtk/pounces/default_actions/play-sound", | |
345 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->play_sound))); | |
346 | |
347 gaim_pounce_set_save(dialog->pounce, | |
348 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->save_pounce))); | |
349 | |
350 update_pounces(); | |
351 | |
352 delete_win_cb(NULL, NULL, dialog); | |
353 } | |
354 | |
355 static void | |
356 pounce_choose_cb(GtkWidget *item, GaimAccount *account, | |
357 GaimGtkPounceDialog *dialog) | |
358 { | |
359 dialog->account = account; | |
360 } | |
361 | |
362 static void | |
363 buddy_changed_cb(GtkEntry *entry, GaimGtkPounceDialog *dialog) | |
364 { | |
365 if (dialog->save_button == NULL) | |
366 return; | |
367 | |
368 gtk_widget_set_sensitive(dialog->save_button, | |
369 *gtk_entry_get_text(entry) != '\0'); | |
370 } | |
371 | |
372 static void | |
373 message_recv_toggle(GtkButton *message_recv, GtkWidget *send_msg) | |
374 { | |
375 gboolean active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(message_recv)); | |
376 | |
377 gtk_widget_set_sensitive(send_msg, !active); | |
378 if (active) | |
379 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(send_msg), FALSE); | |
380 } | |
381 | |
382 static void | |
383 pounce_dnd_recv(GtkWidget *widget, GdkDragContext *dc, gint x, gint y, | |
384 GtkSelectionData *sd, guint info, guint t, gpointer data) | |
385 { | |
386 GaimGtkPounceDialog *dialog; | |
387 | |
388 if (sd->target == gdk_atom_intern("GAIM_BLIST_NODE", FALSE)) | |
389 { | |
390 GaimBlistNode *node = NULL; | |
391 GaimBuddy *buddy; | |
392 | |
393 memcpy(&node, sd->data, sizeof(node)); | |
394 | |
395 if (GAIM_BLIST_NODE_IS_CONTACT(node)) | |
396 buddy = gaim_contact_get_priority_buddy((GaimContact *)node); | |
397 else if (GAIM_BLIST_NODE_IS_BUDDY(node)) | |
398 buddy = (GaimBuddy *)node; | |
399 else | |
400 return; | |
401 | |
402 dialog = (GaimGtkPounceDialog *)data; | |
403 | |
404 gtk_entry_set_text(GTK_ENTRY(dialog->buddy_entry), buddy->name); | |
405 dialog->account = buddy->account; | |
406 gaim_gtk_account_option_menu_set_selected(dialog->account_menu, buddy->account); | |
407 | |
408 gtk_drag_finish(dc, TRUE, (dc->action == GDK_ACTION_MOVE), t); | |
409 } | |
410 else if (sd->target == gdk_atom_intern("application/x-im-contact", FALSE)) | |
411 { | |
412 char *protocol = NULL; | |
413 char *username = NULL; | |
414 GaimAccount *account; | |
415 | |
416 if (gaim_gtk_parse_x_im_contact((const char *)sd->data, FALSE, &account, | |
417 &protocol, &username, NULL)) | |
418 { | |
419 if (account == NULL) | |
420 { | |
421 gaim_notify_error(NULL, NULL, | |
422 _("You are not currently signed on with an account that " | |
423 "can add that buddy."), NULL); | |
424 } | |
425 else | |
426 { | |
427 dialog = (GaimGtkPounceDialog *)data; | |
428 | |
429 gtk_entry_set_text(GTK_ENTRY(dialog->buddy_entry), username); | |
430 dialog->account = account; | |
431 gaim_gtk_account_option_menu_set_selected(dialog->account_menu, account); | |
432 } | |
433 } | |
434 | |
435 g_free(username); | |
436 g_free(protocol); | |
437 | |
438 gtk_drag_finish(dc, TRUE, (dc->action == GDK_ACTION_MOVE), t); | |
439 } | |
440 } | |
441 | |
442 static const GtkTargetEntry dnd_targets[] = | |
443 { | |
444 {"GAIM_BLIST_NODE", GTK_TARGET_SAME_APP, 0}, | |
445 {"application/x-im-contact", 0, 1} | |
446 }; | |
447 | |
448 void | |
449 gaim_gtk_pounce_editor_show(GaimAccount *account, const char *name, | |
450 GaimPounce *cur_pounce) | |
451 { | |
452 GaimGtkPounceDialog *dialog; | |
453 GtkWidget *window; | |
454 GtkWidget *label; | |
455 GtkWidget *bbox; | |
456 GtkWidget *vbox1, *vbox2; | |
457 GtkWidget *hbox; | |
458 GtkWidget *button; | |
459 GtkWidget *frame; | |
460 GtkWidget *table; | |
461 GtkSizeGroup *sg; | |
462 GPtrArray *sound_widgets; | |
463 GPtrArray *exec_widgets; | |
464 | |
465 g_return_if_fail((cur_pounce != NULL) || (account != NULL) || | |
466 (gaim_connections_get_all() != NULL)); | |
467 | |
468 dialog = g_new0(GaimGtkPounceDialog, 1); | |
469 | |
470 if (cur_pounce != NULL) | |
471 { | |
472 dialog->pounce = cur_pounce; | |
473 dialog->account = gaim_pounce_get_pouncer(cur_pounce); | |
474 } | |
475 else if (account != NULL) | |
476 { | |
477 dialog->pounce = NULL; | |
478 dialog->account = account; | |
479 } | |
480 else | |
481 { | |
482 GaimConnection *gc; | |
483 | |
484 gc = (GaimConnection *)gaim_connections_get_all()->data; | |
485 | |
486 dialog->pounce = NULL; | |
487 dialog->account = gaim_connection_get_account(gc); | |
488 } | |
489 | |
490 sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); | |
491 | |
492 /* Create the window. */ | |
493 dialog->window = window = gtk_window_new(GTK_WINDOW_TOPLEVEL); | |
494 gtk_window_set_type_hint(GTK_WINDOW(window), GDK_WINDOW_TYPE_HINT_DIALOG); | |
495 gtk_window_set_role(GTK_WINDOW(window), "buddy_pounce"); | |
496 gtk_window_set_resizable(GTK_WINDOW(window), FALSE); | |
497 gtk_window_set_title(GTK_WINDOW(window), | |
498 (cur_pounce == NULL | |
499 ? _("New Buddy Pounce") : _("Edit Buddy Pounce"))); | |
500 | |
501 gtk_container_set_border_width(GTK_CONTAINER(window), GAIM_HIG_BORDER); | |
502 | |
503 g_signal_connect(G_OBJECT(window), "delete_event", | |
504 G_CALLBACK(delete_win_cb), dialog); | |
505 | |
506 /* Create the parent vbox for everything. */ | |
507 vbox1 = gtk_vbox_new(FALSE, GAIM_HIG_BORDER); | |
508 gtk_container_add(GTK_CONTAINER(window), vbox1); | |
509 gtk_widget_show(vbox1); | |
510 | |
511 /* Create the vbox that will contain all the prefs stuff. */ | |
512 vbox2 = gtk_vbox_new(FALSE, GAIM_HIG_BOX_SPACE); | |
513 gtk_box_pack_start(GTK_BOX(vbox1), vbox2, TRUE, TRUE, 0); | |
514 | |
515 /* Create the "Pounce on Whom" frame. */ | |
516 frame = gaim_gtk_make_frame(vbox2, _("Pounce on Whom")); | |
517 | |
518 /* Account: */ | |
519 hbox = gtk_hbox_new(FALSE, GAIM_HIG_BOX_SPACE); | |
520 gtk_box_pack_start(GTK_BOX(frame), hbox, FALSE, FALSE, 0); | |
521 gtk_widget_show(hbox); | |
522 | |
523 label = gtk_label_new_with_mnemonic(_("_Account:")); | |
524 gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); | |
525 gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); | |
526 gtk_widget_show(label); | |
527 gtk_size_group_add_widget(sg, label); | |
528 | |
529 dialog->account_menu = | |
530 gaim_gtk_account_option_menu_new(dialog->account, FALSE, | |
531 G_CALLBACK(pounce_choose_cb), | |
532 NULL, dialog); | |
533 | |
534 gtk_box_pack_start(GTK_BOX(hbox), dialog->account_menu, FALSE, FALSE, 0); | |
535 gtk_widget_show(dialog->account_menu); | |
536 gaim_set_accessible_label (dialog->account_menu, label); | |
537 | |
538 /* Buddy: */ | |
539 hbox = gtk_hbox_new(FALSE, GAIM_HIG_BOX_SPACE); | |
540 gtk_box_pack_start(GTK_BOX(frame), hbox, FALSE, FALSE, 0); | |
541 gtk_widget_show(hbox); | |
542 | |
543 label = gtk_label_new_with_mnemonic(_("_Buddy name:")); | |
544 gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); | |
545 gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); | |
546 gtk_widget_show(label); | |
547 gtk_size_group_add_widget(sg, label); | |
548 | |
549 dialog->buddy_entry = gtk_entry_new(); | |
550 | |
551 gaim_gtk_setup_screenname_autocomplete(dialog->buddy_entry, dialog->account_menu, FALSE); | |
552 | |
553 gtk_box_pack_start(GTK_BOX(hbox), dialog->buddy_entry, TRUE, TRUE, 0); | |
554 gtk_widget_show(dialog->buddy_entry); | |
555 | |
556 g_signal_connect(G_OBJECT(dialog->buddy_entry), "changed", | |
557 G_CALLBACK(buddy_changed_cb), dialog); | |
558 gaim_set_accessible_label (dialog->buddy_entry, label); | |
559 | |
560 if (cur_pounce != NULL) { | |
561 gtk_entry_set_text(GTK_ENTRY(dialog->buddy_entry), | |
562 gaim_pounce_get_pouncee(cur_pounce)); | |
563 } | |
564 else if (name != NULL) { | |
565 gtk_entry_set_text(GTK_ENTRY(dialog->buddy_entry), name); | |
566 } | |
567 | |
568 /* Create the "Pounce When Buddy..." frame. */ | |
569 frame = gaim_gtk_make_frame(vbox2, _("Pounce When Buddy...")); | |
570 | |
571 table = gtk_table_new(5, 2, FALSE); | |
572 gtk_container_add(GTK_CONTAINER(frame), table); | |
573 gtk_table_set_col_spacings(GTK_TABLE(table), GAIM_HIG_BORDER); | |
574 gtk_widget_show(table); | |
575 | |
576 dialog->signon = | |
577 gtk_check_button_new_with_mnemonic(_("Si_gns on")); | |
578 dialog->signoff = | |
579 gtk_check_button_new_with_mnemonic(_("Signs o_ff")); | |
580 dialog->away = | |
581 gtk_check_button_new_with_mnemonic(_("Goes a_way")); | |
582 dialog->away_return = | |
583 gtk_check_button_new_with_mnemonic(_("Ret_urns from away")); | |
584 dialog->idle = | |
585 gtk_check_button_new_with_mnemonic(_("Becomes _idle")); | |
586 dialog->idle_return = | |
587 gtk_check_button_new_with_mnemonic(_("Is no longer i_dle")); | |
588 dialog->typing = | |
589 gtk_check_button_new_with_mnemonic(_("Starts _typing")); | |
590 dialog->typed = | |
591 gtk_check_button_new_with_mnemonic(_("P_auses while typing")); | |
592 dialog->stop_typing = | |
593 gtk_check_button_new_with_mnemonic(_("Stops t_yping")); | |
594 dialog->message_recv = | |
595 gtk_check_button_new_with_mnemonic(_("Sends a _message")); | |
596 | |
597 gtk_table_attach(GTK_TABLE(table), dialog->message_recv, 0, 1, 0, 1, | |
598 GTK_FILL, 0, 0, 0); | |
599 gtk_table_attach(GTK_TABLE(table), dialog->signon, 0, 1, 1, 2, | |
600 GTK_FILL, 0, 0, 0); | |
601 gtk_table_attach(GTK_TABLE(table), dialog->signoff, 0, 1, 2, 3, | |
602 GTK_FILL, 0, 0, 0); | |
603 gtk_table_attach(GTK_TABLE(table), dialog->away, 0, 1, 3, 4, | |
604 GTK_FILL, 0, 0, 0); | |
605 gtk_table_attach(GTK_TABLE(table), dialog->away_return, 0, 1, 4, 5, | |
606 GTK_FILL, 0, 0, 0); | |
607 gtk_table_attach(GTK_TABLE(table), dialog->idle, 1, 2, 0, 1, | |
608 GTK_FILL, 0, 0, 0); | |
609 gtk_table_attach(GTK_TABLE(table), dialog->idle_return, 1, 2, 1, 2, | |
610 GTK_FILL, 0, 0, 0); | |
611 gtk_table_attach(GTK_TABLE(table), dialog->typing, 1, 2, 2, 3, | |
612 GTK_FILL, 0, 0, 0); | |
613 gtk_table_attach(GTK_TABLE(table), dialog->typed, 1, 2, 3, 4, | |
614 GTK_FILL, 0, 0, 0); | |
615 gtk_table_attach(GTK_TABLE(table), dialog->stop_typing, 1, 2, 4, 5, | |
616 GTK_FILL, 0, 0, 0); | |
617 | |
618 gtk_widget_show(dialog->signon); | |
619 gtk_widget_show(dialog->signoff); | |
620 gtk_widget_show(dialog->away); | |
621 gtk_widget_show(dialog->away_return); | |
622 gtk_widget_show(dialog->idle); | |
623 gtk_widget_show(dialog->idle_return); | |
624 gtk_widget_show(dialog->typing); | |
625 gtk_widget_show(dialog->typed); | |
626 gtk_widget_show(dialog->stop_typing); | |
627 gtk_widget_show(dialog->message_recv); | |
628 | |
629 /* Create the "Action" frame. */ | |
630 frame = gaim_gtk_make_frame(vbox2, _("Action")); | |
631 | |
632 table = gtk_table_new(3, 5, FALSE); | |
633 gtk_container_add(GTK_CONTAINER(frame), table); | |
634 gtk_table_set_col_spacings(GTK_TABLE(table), GAIM_HIG_BORDER); | |
635 gtk_widget_show(table); | |
636 | |
637 dialog->open_win | |
638 = gtk_check_button_new_with_mnemonic(_("Ope_n an IM window")); | |
639 dialog->popup | |
640 = gtk_check_button_new_with_mnemonic(_("_Pop up a notification")); | |
641 dialog->send_msg | |
642 = gtk_check_button_new_with_mnemonic(_("Send a _message")); | |
643 dialog->exec_cmd | |
644 = gtk_check_button_new_with_mnemonic(_("E_xecute a command")); | |
645 dialog->play_sound | |
646 = gtk_check_button_new_with_mnemonic(_("P_lay a sound")); | |
647 | |
648 dialog->send_msg_entry = gtk_entry_new(); | |
649 dialog->exec_cmd_entry = gtk_entry_new(); | |
650 dialog->popup_entry = gtk_entry_new(); | |
651 dialog->exec_cmd_browse = gtk_button_new_with_mnemonic(_("Brows_e...")); | |
652 dialog->play_sound_entry = gtk_entry_new(); | |
653 dialog->play_sound_browse = gtk_button_new_with_mnemonic(_("Br_owse...")); | |
654 dialog->play_sound_test = gtk_button_new_with_mnemonic(_("Pre_view")); | |
655 | |
656 gtk_widget_set_sensitive(dialog->send_msg_entry, FALSE); | |
657 gtk_widget_set_sensitive(dialog->exec_cmd_entry, FALSE); | |
658 gtk_widget_set_sensitive(dialog->popup_entry, FALSE); | |
659 gtk_widget_set_sensitive(dialog->exec_cmd_browse, FALSE); | |
660 gtk_widget_set_sensitive(dialog->play_sound_entry, FALSE); | |
661 gtk_widget_set_sensitive(dialog->play_sound_browse, FALSE); | |
662 gtk_widget_set_sensitive(dialog->play_sound_test, FALSE); | |
663 | |
664 sg = gtk_size_group_new(GTK_SIZE_GROUP_VERTICAL); | |
665 gtk_size_group_add_widget(sg, dialog->open_win); | |
666 gtk_size_group_add_widget(sg, dialog->popup); | |
667 gtk_size_group_add_widget(sg, dialog->popup_entry); | |
668 gtk_size_group_add_widget(sg, dialog->send_msg); | |
669 gtk_size_group_add_widget(sg, dialog->send_msg_entry); | |
670 gtk_size_group_add_widget(sg, dialog->exec_cmd); | |
671 gtk_size_group_add_widget(sg, dialog->exec_cmd_entry); | |
672 gtk_size_group_add_widget(sg, dialog->exec_cmd_browse); | |
673 gtk_size_group_add_widget(sg, dialog->play_sound); | |
674 gtk_size_group_add_widget(sg, dialog->play_sound_entry); | |
675 gtk_size_group_add_widget(sg, dialog->play_sound_browse); | |
676 gtk_size_group_add_widget(sg, dialog->play_sound_test); | |
677 | |
678 gtk_table_attach(GTK_TABLE(table), dialog->open_win, 0, 1, 0, 1, | |
679 GTK_FILL, 0, 0, 0); | |
680 gtk_table_attach(GTK_TABLE(table), dialog->popup, 0, 1, 1, 2, | |
681 GTK_FILL, 0, 0, 0); | |
682 gtk_table_attach(GTK_TABLE(table), dialog->popup_entry, 1, 4, 1, 2, | |
683 GTK_FILL, 0, 0, 0); | |
684 gtk_table_attach(GTK_TABLE(table), dialog->send_msg, 0, 1, 2, 3, | |
685 GTK_FILL, 0, 0, 0); | |
686 gtk_table_attach(GTK_TABLE(table), dialog->send_msg_entry, 1, 4, 2, 3, | |
687 GTK_FILL, 0, 0, 0); | |
688 gtk_table_attach(GTK_TABLE(table), dialog->exec_cmd, 0, 1, 3, 4, | |
689 GTK_FILL, 0, 0, 0); | |
690 gtk_table_attach(GTK_TABLE(table), dialog->exec_cmd_entry, 1, 2, 3, 4, | |
691 GTK_FILL, 0, 0, 0); | |
692 gtk_table_attach(GTK_TABLE(table), dialog->exec_cmd_browse, 2, 3, 3, 4, | |
693 GTK_FILL | GTK_EXPAND, 0, 0, 0); | |
694 gtk_table_attach(GTK_TABLE(table), dialog->play_sound, 0, 1, 4, 5, | |
695 GTK_FILL, 0, 0, 0); | |
696 gtk_table_attach(GTK_TABLE(table), dialog->play_sound_entry, 1, 2, 4, 5, | |
697 GTK_FILL, 0, 0, 0); | |
698 gtk_table_attach(GTK_TABLE(table), dialog->play_sound_browse, 2, 3, 4, 5, | |
699 GTK_FILL | GTK_EXPAND, 0, 0, 0); | |
700 gtk_table_attach(GTK_TABLE(table), dialog->play_sound_test, 3, 4, 4, 5, | |
701 GTK_FILL | GTK_EXPAND, 0, 0, 0); | |
702 | |
703 gtk_table_set_row_spacings(GTK_TABLE(table), GAIM_HIG_BOX_SPACE / 2); | |
704 | |
705 gtk_widget_show(dialog->open_win); | |
706 gtk_widget_show(dialog->popup); | |
707 gtk_widget_show(dialog->popup_entry); | |
708 gtk_widget_show(dialog->send_msg); | |
709 gtk_widget_show(dialog->send_msg_entry); | |
710 gtk_widget_show(dialog->exec_cmd); | |
711 gtk_widget_show(dialog->exec_cmd_entry); | |
712 gtk_widget_show(dialog->exec_cmd_browse); | |
713 gtk_widget_show(dialog->play_sound); | |
714 gtk_widget_show(dialog->play_sound_entry); | |
715 gtk_widget_show(dialog->play_sound_browse); | |
716 gtk_widget_show(dialog->play_sound_test); | |
717 | |
718 g_signal_connect(G_OBJECT(dialog->message_recv), "clicked", | |
719 G_CALLBACK(message_recv_toggle), | |
720 dialog->send_msg); | |
721 | |
722 g_signal_connect(G_OBJECT(dialog->send_msg), "clicked", | |
723 G_CALLBACK(gaim_gtk_toggle_sensitive), | |
724 dialog->send_msg_entry); | |
725 | |
726 g_signal_connect(G_OBJECT(dialog->popup), "clicked", | |
727 G_CALLBACK(gaim_gtk_toggle_sensitive), | |
728 dialog->popup_entry); | |
729 | |
730 exec_widgets = g_ptr_array_new(); | |
731 g_ptr_array_add(exec_widgets,dialog->exec_cmd_entry); | |
732 g_ptr_array_add(exec_widgets,dialog->exec_cmd_browse); | |
733 | |
734 g_signal_connect(G_OBJECT(dialog->exec_cmd), "clicked", | |
735 G_CALLBACK(gaim_gtk_toggle_sensitive_array), | |
736 exec_widgets); | |
737 g_signal_connect(G_OBJECT(dialog->exec_cmd_browse), "clicked", | |
738 G_CALLBACK(filesel), | |
739 dialog->exec_cmd_entry); | |
740 | |
741 sound_widgets = g_ptr_array_new(); | |
742 g_ptr_array_add(sound_widgets,dialog->play_sound_entry); | |
743 g_ptr_array_add(sound_widgets,dialog->play_sound_browse); | |
744 g_ptr_array_add(sound_widgets,dialog->play_sound_test); | |
745 | |
746 g_signal_connect(G_OBJECT(dialog->play_sound), "clicked", | |
747 G_CALLBACK(gaim_gtk_toggle_sensitive_array), | |
748 sound_widgets); | |
749 g_signal_connect(G_OBJECT(dialog->play_sound_browse), "clicked", | |
750 G_CALLBACK(filesel), | |
751 dialog->play_sound_entry); | |
752 g_signal_connect(G_OBJECT(dialog->play_sound_test), "clicked", | |
753 G_CALLBACK(pounce_test_sound), | |
754 dialog->play_sound_entry); | |
755 | |
756 g_signal_connect(G_OBJECT(dialog->send_msg_entry), "activate", | |
757 G_CALLBACK(save_pounce_cb), dialog); | |
758 g_signal_connect(G_OBJECT(dialog->popup_entry), "activate", | |
759 G_CALLBACK(save_pounce_cb), dialog); | |
760 g_signal_connect(G_OBJECT(dialog->exec_cmd_entry), "activate", | |
761 G_CALLBACK(save_pounce_cb), dialog); | |
762 g_signal_connect(G_OBJECT(dialog->play_sound_entry), "activate", | |
763 G_CALLBACK(save_pounce_cb), dialog); | |
764 | |
765 /* Create the "Options" frame. */ | |
766 frame = gaim_gtk_make_frame(vbox2, _("Options")); | |
767 | |
768 table = gtk_table_new(2, 1, FALSE); | |
769 gtk_container_add(GTK_CONTAINER(frame), table); | |
770 gtk_table_set_col_spacings(GTK_TABLE(table), GAIM_HIG_BORDER); | |
771 gtk_widget_show(table); | |
772 | |
773 dialog->on_away = | |
774 gtk_check_button_new_with_mnemonic(_("P_ounce only when my status is not available")); | |
775 gtk_table_attach(GTK_TABLE(table), dialog->on_away, 0, 1, 0, 1, | |
776 GTK_FILL, 0, 0, 0); | |
777 | |
778 dialog->save_pounce = gtk_check_button_new_with_mnemonic( | |
779 _("_Recurring")); | |
780 gtk_table_attach(GTK_TABLE(table), dialog->save_pounce, 0, 1, 1, 2, | |
781 GTK_FILL, 0, 0, 0); | |
782 | |
783 gtk_widget_show(dialog->on_away); | |
784 gtk_widget_show(dialog->save_pounce); | |
785 | |
786 /* Now the button box! */ | |
787 bbox = gtk_hbutton_box_new(); | |
788 gtk_box_set_spacing(GTK_BOX(bbox), GAIM_HIG_BOX_SPACE); | |
789 gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END); | |
790 gtk_box_pack_end(GTK_BOX(vbox1), bbox, FALSE, FALSE, 0); | |
791 gtk_widget_show(bbox); | |
792 | |
793 /* Cancel button */ | |
794 button = gtk_button_new_from_stock(GTK_STOCK_CANCEL); | |
795 gtk_box_pack_start(GTK_BOX(bbox), button, FALSE, FALSE, 0); | |
796 gtk_widget_show(button); | |
797 | |
798 g_signal_connect(G_OBJECT(button), "clicked", | |
799 G_CALLBACK(cancel_cb), dialog); | |
800 | |
801 /* Save button */ | |
802 dialog->save_button = button = gtk_button_new_from_stock(GTK_STOCK_SAVE); | |
803 gtk_box_pack_start(GTK_BOX(bbox), button, FALSE, FALSE, 0); | |
804 gtk_widget_show(button); | |
805 | |
806 g_signal_connect(G_OBJECT(button), "clicked", | |
807 G_CALLBACK(save_pounce_cb), dialog); | |
808 | |
809 if (*gtk_entry_get_text(GTK_ENTRY(dialog->buddy_entry)) == '\0') | |
810 gtk_widget_set_sensitive(button, FALSE); | |
811 | |
812 /* Setup drag-and-drop */ | |
813 gtk_drag_dest_set(window, | |
814 GTK_DEST_DEFAULT_MOTION | | |
815 GTK_DEST_DEFAULT_DROP, | |
816 dnd_targets, | |
817 sizeof(dnd_targets) / sizeof(GtkTargetEntry), | |
818 GDK_ACTION_COPY); | |
819 gtk_drag_dest_set(dialog->buddy_entry, | |
820 GTK_DEST_DEFAULT_MOTION | | |
821 GTK_DEST_DEFAULT_DROP, | |
822 dnd_targets, | |
823 sizeof(dnd_targets) / sizeof(GtkTargetEntry), | |
824 GDK_ACTION_COPY); | |
825 | |
826 g_signal_connect(G_OBJECT(window), "drag_data_received", | |
827 G_CALLBACK(pounce_dnd_recv), dialog); | |
828 g_signal_connect(G_OBJECT(dialog->buddy_entry), "drag_data_received", | |
829 G_CALLBACK(pounce_dnd_recv), dialog); | |
830 | |
831 /* Set the values of stuff. */ | |
832 if (cur_pounce != NULL) | |
833 { | |
834 GaimPounceEvent events = gaim_pounce_get_events(cur_pounce); | |
835 GaimPounceOption options = gaim_pounce_get_options(cur_pounce); | |
836 const char *value; | |
837 | |
838 /* Options */ | |
839 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->on_away), | |
840 (options & GAIM_POUNCE_OPTION_AWAY)); | |
841 | |
842 /* Events */ | |
843 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->signon), | |
844 (events & GAIM_POUNCE_SIGNON)); | |
845 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->signoff), | |
846 (events & GAIM_POUNCE_SIGNOFF)); | |
847 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->away), | |
848 (events & GAIM_POUNCE_AWAY)); | |
849 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->away_return), | |
850 (events & GAIM_POUNCE_AWAY_RETURN)); | |
851 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->idle), | |
852 (events & GAIM_POUNCE_IDLE)); | |
853 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->idle_return), | |
854 (events & GAIM_POUNCE_IDLE_RETURN)); | |
855 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->typing), | |
856 (events & GAIM_POUNCE_TYPING)); | |
857 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->typed), | |
858 (events & GAIM_POUNCE_TYPED)); | |
859 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->stop_typing), | |
860 (events & GAIM_POUNCE_TYPING_STOPPED)); | |
861 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->message_recv), | |
862 (events & GAIM_POUNCE_MESSAGE_RECEIVED)); | |
863 | |
864 /* Actions */ | |
865 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->open_win), | |
866 gaim_pounce_action_is_enabled(cur_pounce, "open-window")); | |
867 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->popup), | |
868 gaim_pounce_action_is_enabled(cur_pounce, "popup-notify")); | |
869 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->send_msg), | |
870 gaim_pounce_action_is_enabled(cur_pounce, "send-message")); | |
871 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->exec_cmd), | |
872 gaim_pounce_action_is_enabled(cur_pounce, "execute-command")); | |
873 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->play_sound), | |
874 gaim_pounce_action_is_enabled(cur_pounce, "play-sound")); | |
875 | |
876 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->save_pounce), | |
877 gaim_pounce_get_save(cur_pounce)); | |
878 | |
879 if ((value = gaim_pounce_action_get_attribute(cur_pounce, | |
880 "send-message", | |
881 "message")) != NULL) | |
882 { | |
883 gtk_entry_set_text(GTK_ENTRY(dialog->send_msg_entry), value); | |
884 } | |
885 | |
886 if ((value = gaim_pounce_action_get_attribute(cur_pounce, | |
887 "popup-notify", | |
888 "reason")) != NULL) | |
889 { | |
890 gtk_entry_set_text(GTK_ENTRY(dialog->popup_entry), value); | |
891 } | |
892 | |
893 if ((value = gaim_pounce_action_get_attribute(cur_pounce, | |
894 "execute-command", | |
895 "command")) != NULL) | |
896 { | |
897 gtk_entry_set_text(GTK_ENTRY(dialog->exec_cmd_entry), value); | |
898 } | |
899 | |
900 if ((value = gaim_pounce_action_get_attribute(cur_pounce, | |
901 "play-sound", | |
902 "filename")) != NULL) | |
903 { | |
904 gtk_entry_set_text(GTK_ENTRY(dialog->play_sound_entry), value); | |
905 } | |
906 } | |
907 else | |
908 { | |
909 GaimBuddy *buddy = NULL; | |
910 | |
911 if (name != NULL) | |
912 buddy = gaim_find_buddy(account, name); | |
913 | |
914 /* Set some defaults */ | |
915 if (buddy == NULL) | |
916 { | |
917 gtk_toggle_button_set_active( | |
918 GTK_TOGGLE_BUTTON(dialog->signon), TRUE); | |
919 } | |
920 else | |
921 { | |
922 if (!GAIM_BUDDY_IS_ONLINE(buddy)) | |
923 { | |
924 gtk_toggle_button_set_active( | |
925 GTK_TOGGLE_BUTTON(dialog->signon), TRUE); | |
926 } | |
927 else | |
928 { | |
929 gboolean default_set = FALSE; | |
930 GaimPresence *presence = gaim_buddy_get_presence(buddy); | |
931 | |
932 if (gaim_presence_is_idle(presence)) | |
933 { | |
934 gtk_toggle_button_set_active( | |
935 GTK_TOGGLE_BUTTON(dialog->idle_return), TRUE); | |
936 | |
937 default_set = TRUE; | |
938 } | |
939 | |
940 if (!gaim_presence_is_available(presence)) | |
941 { | |
942 gtk_toggle_button_set_active( | |
943 GTK_TOGGLE_BUTTON(dialog->away_return), TRUE); | |
944 | |
945 default_set = TRUE; | |
946 } | |
947 | |
948 if (!default_set) | |
949 { | |
950 gtk_toggle_button_set_active( | |
951 GTK_TOGGLE_BUTTON(dialog->signon), TRUE); | |
952 } | |
953 } | |
954 } | |
955 | |
956 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->open_win), | |
957 gaim_prefs_get_bool("/gaim/gtk/pounces/default_actions/open-window")); | |
958 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->popup), | |
959 gaim_prefs_get_bool("/gaim/gtk/pounces/default_actions/popup-notify")); | |
960 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->send_msg), | |
961 gaim_prefs_get_bool("/gaim/gtk/pounces/default_actions/send-message")); | |
962 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->exec_cmd), | |
963 gaim_prefs_get_bool("/gaim/gtk/pounces/default_actions/execute-command")); | |
964 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->play_sound), | |
965 gaim_prefs_get_bool("/gaim/gtk/pounces/default_actions/play-sound")); | |
966 } | |
967 | |
968 gtk_widget_show_all(vbox2); | |
969 gtk_widget_show(window); | |
970 } | |
971 | |
972 static gboolean | |
973 pounces_manager_configure_cb(GtkWidget *widget, GdkEventConfigure *event, PouncesManager *dialog) | |
974 { | |
975 if (GTK_WIDGET_VISIBLE(widget)) { | |
976 gaim_prefs_set_int("/gaim/gtk/pounces/dialog/width", event->width); | |
977 gaim_prefs_set_int("/gaim/gtk/pounces/dialog/height", event->height); | |
978 } | |
979 | |
980 return FALSE; | |
981 } | |
982 | |
983 static gboolean | |
984 pounces_manager_find_pounce(GtkTreeIter *iter, GaimPounce *pounce) | |
985 { | |
986 GtkTreeModel *model = GTK_TREE_MODEL(pounces_manager->model); | |
987 GaimPounce *p; | |
988 | |
989 if (!gtk_tree_model_get_iter_first(model, iter)) | |
990 return FALSE; | |
991 | |
992 gtk_tree_model_get(model, iter, POUNCES_MANAGER_COLUMN_POUNCE, &p, -1); | |
993 if (pounce == p) | |
994 return TRUE; | |
995 | |
996 while (gtk_tree_model_iter_next(model, iter)) | |
997 { | |
998 gtk_tree_model_get(model, iter, POUNCES_MANAGER_COLUMN_POUNCE, &p, -1); | |
999 if (pounce == p) | |
1000 return TRUE; | |
1001 } | |
1002 | |
1003 return FALSE; | |
1004 } | |
1005 | |
1006 static gboolean | |
1007 pounces_manager_destroy_cb(GtkWidget *widget, GdkEvent *event, gpointer user_data) | |
1008 { | |
1009 PouncesManager *dialog = user_data; | |
1010 | |
1011 dialog->window = NULL; | |
1012 gaim_gtk_pounces_manager_hide(); | |
1013 | |
1014 return FALSE; | |
1015 } | |
1016 | |
1017 #if !GTK_CHECK_VERSION(2,2,0) | |
1018 static void | |
1019 count_selected_helper(GtkTreeModel *model, GtkTreePath *path, | |
1020 GtkTreeIter *iter, gpointer user_data) | |
1021 { | |
1022 (*(gint *)user_data)++; | |
1023 } | |
1024 #endif | |
1025 | |
1026 static void | |
1027 pounces_manager_connection_cb(GaimConnection *gc, GtkWidget *add_button) | |
1028 { | |
1029 gtk_widget_set_sensitive(add_button, (gaim_connections_get_all() != NULL)); | |
1030 } | |
1031 | |
1032 static void | |
1033 pounces_manager_add_cb(GtkButton *button, gpointer user_data) | |
1034 { | |
1035 gaim_gtk_pounce_editor_show(NULL, NULL, NULL); | |
1036 } | |
1037 | |
1038 static void | |
1039 pounces_manager_modify_foreach(GtkTreeModel *model, GtkTreePath *path, | |
1040 GtkTreeIter *iter, gpointer user_data) | |
1041 { | |
1042 GaimPounce *pounce; | |
1043 | |
1044 gtk_tree_model_get(model, iter, POUNCES_MANAGER_COLUMN_POUNCE, &pounce, -1); | |
1045 gaim_gtk_pounce_editor_show(NULL, NULL, pounce); | |
1046 } | |
1047 | |
1048 static void | |
1049 pounces_manager_modify_cb(GtkButton *button, gpointer user_data) | |
1050 { | |
1051 PouncesManager *dialog = user_data; | |
1052 GtkTreeSelection *selection; | |
1053 | |
1054 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dialog->treeview)); | |
1055 | |
1056 gtk_tree_selection_selected_foreach(selection, pounces_manager_modify_foreach, user_data); | |
1057 } | |
1058 | |
1059 static void | |
1060 pounces_manager_delete_confirm_cb(GaimPounce *pounce) | |
1061 { | |
1062 GtkTreeIter iter; | |
1063 | |
1064 if (pounces_manager && pounces_manager_find_pounce(&iter, pounce)) | |
1065 gtk_list_store_remove(pounces_manager->model, &iter); | |
1066 | |
1067 gaim_request_close_with_handle(pounce); | |
1068 gaim_pounce_destroy(pounce); | |
1069 } | |
1070 | |
1071 static void | |
1072 pounces_manager_delete_foreach(GtkTreeModel *model, GtkTreePath *path, | |
1073 GtkTreeIter *iter, gpointer user_data) | |
1074 { | |
1075 GaimPounce *pounce; | |
1076 GaimAccount *account; | |
1077 const char *pouncer, *pouncee; | |
1078 char *buf; | |
1079 | |
1080 gtk_tree_model_get(model, iter, POUNCES_MANAGER_COLUMN_POUNCE, &pounce, -1); | |
1081 account = gaim_pounce_get_pouncer(pounce); | |
1082 pouncer = gaim_account_get_username(account); | |
1083 pouncee = gaim_pounce_get_pouncee(pounce); | |
1084 | |
1085 buf = g_strdup_printf(_("Are you sure you want to delete the pounce on %s for %s?"), pouncee, pouncer); | |
1086 gaim_request_action(pounce, NULL, buf, NULL, 0, pounce, 2, | |
1087 _("Delete"), pounces_manager_delete_confirm_cb, | |
1088 _("Cancel"), NULL); | |
1089 g_free(buf); | |
1090 } | |
1091 | |
1092 static void | |
1093 pounces_manager_delete_cb(GtkButton *button, gpointer user_data) | |
1094 { | |
1095 PouncesManager *dialog = user_data; | |
1096 GtkTreeSelection *selection; | |
1097 | |
1098 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dialog->treeview)); | |
1099 | |
1100 gtk_tree_selection_selected_foreach(selection, pounces_manager_delete_foreach, user_data); | |
1101 } | |
1102 | |
1103 static void | |
1104 pounces_manager_close_cb(GtkButton *button, gpointer user_data) | |
1105 { | |
1106 gaim_gtk_pounces_manager_hide(); | |
1107 } | |
1108 | |
1109 static void | |
1110 pounce_selected_cb(GtkTreeSelection *sel, gpointer user_data) | |
1111 { | |
1112 PouncesManager *dialog = user_data; | |
1113 int num_selected = 0; | |
1114 | |
1115 #if GTK_CHECK_VERSION(2,2,0) | |
1116 num_selected = gtk_tree_selection_count_selected_rows(sel); | |
1117 #else | |
1118 gtk_tree_selection_selected_foreach(sel, count_selected_helper, &num_selected); | |
1119 #endif | |
1120 | |
1121 gtk_widget_set_sensitive(dialog->modify_button, (num_selected > 0)); | |
1122 gtk_widget_set_sensitive(dialog->delete_button, (num_selected > 0)); | |
1123 } | |
1124 | |
1125 static gboolean | |
1126 pounce_double_click_cb(GtkTreeView *treeview, GdkEventButton *event, gpointer user_data) | |
1127 { | |
1128 PouncesManager *dialog = user_data; | |
1129 GtkTreePath *path; | |
1130 GtkTreeIter iter; | |
1131 GaimPounce *pounce; | |
1132 | |
1133 /* Figure out which node was clicked */ | |
1134 if (!gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(dialog->treeview), event->x, event->y, &path, NULL, NULL, NULL)) | |
1135 return FALSE; | |
1136 gtk_tree_model_get_iter(GTK_TREE_MODEL(dialog->model), &iter, path); | |
1137 gtk_tree_path_free(path); | |
1138 gtk_tree_model_get(GTK_TREE_MODEL(dialog->model), &iter, POUNCES_MANAGER_COLUMN_POUNCE, &pounce, -1); | |
1139 | |
1140 if ((pounce != NULL) && (event->button == 1) && | |
1141 (event->type == GDK_2BUTTON_PRESS)) | |
1142 { | |
1143 gaim_gtk_pounce_editor_show(NULL, NULL, pounce); | |
1144 return TRUE; | |
1145 } | |
1146 | |
1147 return FALSE; | |
1148 } | |
1149 | |
1150 static void | |
1151 pounces_manager_recurring_cb(GtkCellRendererToggle *renderer, gchar *path_str, | |
1152 gpointer user_data) | |
1153 { | |
1154 PouncesManager *dialog = user_data; | |
1155 GaimPounce *pounce; | |
1156 gboolean recurring; | |
1157 GtkTreeModel *model = GTK_TREE_MODEL(dialog->model); | |
1158 GtkTreeIter iter; | |
1159 | |
1160 gtk_tree_model_get_iter_from_string(model, &iter, path_str); | |
1161 gtk_tree_model_get(model, &iter, | |
1162 POUNCES_MANAGER_COLUMN_POUNCE, &pounce, | |
1163 POUNCES_MANAGER_COLUMN_RECURRING, &recurring, | |
1164 -1); | |
1165 | |
1166 gaim_pounce_set_save(pounce, !recurring); | |
1167 | |
1168 update_pounces(); | |
1169 } | |
1170 | |
1171 static gboolean | |
1172 search_func(GtkTreeModel *model, gint column, const gchar *key, GtkTreeIter *iter, gpointer search_data) | |
1173 { | |
1174 gboolean result; | |
1175 char *haystack; | |
1176 | |
1177 gtk_tree_model_get(model, iter, column, &haystack, -1); | |
1178 | |
1179 result = (gaim_strcasestr(haystack, key) == NULL); | |
1180 | |
1181 g_free(haystack); | |
1182 | |
1183 return result; | |
1184 } | |
1185 | |
1186 static GtkWidget * | |
1187 create_pounces_list(PouncesManager *dialog) | |
1188 { | |
1189 GtkWidget *sw; | |
1190 GtkWidget *treeview; | |
1191 GtkTreeSelection *sel; | |
1192 GtkTreeViewColumn *column; | |
1193 GtkCellRenderer *renderer; | |
1194 | |
1195 /* Create the scrolled window */ | |
1196 sw = gtk_scrolled_window_new(0, 0); | |
1197 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), | |
1198 GTK_POLICY_AUTOMATIC, | |
1199 GTK_POLICY_AUTOMATIC); | |
1200 gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), | |
1201 GTK_SHADOW_IN); | |
1202 gtk_widget_show(sw); | |
1203 | |
1204 /* Create the list model */ | |
1205 dialog->model = gtk_list_store_new(POUNCES_MANAGER_NUM_COLUMNS, | |
1206 G_TYPE_POINTER, | |
1207 GDK_TYPE_PIXBUF, | |
1208 G_TYPE_STRING, | |
1209 G_TYPE_STRING, | |
1210 G_TYPE_BOOLEAN | |
1211 ); | |
1212 | |
1213 /* Create the treeview */ | |
1214 treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(dialog->model)); | |
1215 dialog->treeview = treeview; | |
1216 gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview), TRUE); | |
1217 | |
1218 sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)); | |
1219 gtk_tree_selection_set_mode(sel, GTK_SELECTION_MULTIPLE); | |
1220 g_signal_connect(G_OBJECT(sel), "changed", | |
1221 G_CALLBACK(pounce_selected_cb), dialog); | |
1222 | |
1223 /* Handle double-clicking */ | |
1224 g_signal_connect(G_OBJECT(treeview), "button_press_event", | |
1225 G_CALLBACK(pounce_double_click_cb), dialog); | |
1226 | |
1227 | |
1228 gtk_container_add(GTK_CONTAINER(sw), treeview); | |
1229 gtk_widget_show(treeview); | |
1230 | |
1231 /* Pouncee Column */ | |
1232 column = gtk_tree_view_column_new(); | |
1233 gtk_tree_view_column_set_title(column, _("Pounce Target")); | |
1234 gtk_tree_view_column_set_resizable(column, TRUE); | |
1235 gtk_tree_view_column_set_min_width(column, 200); | |
1236 gtk_tree_view_column_set_sort_column_id(column, | |
1237 POUNCES_MANAGER_COLUMN_TARGET); | |
1238 gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column); | |
1239 | |
1240 /* Icon */ | |
1241 renderer = gtk_cell_renderer_pixbuf_new(); | |
1242 gtk_tree_view_column_pack_start(column, renderer, FALSE); | |
1243 gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", | |
1244 POUNCES_MANAGER_COLUMN_ICON); | |
1245 | |
1246 /* Pouncee */ | |
1247 renderer = gtk_cell_renderer_text_new(); | |
1248 gtk_tree_view_column_pack_start(column, renderer, TRUE); | |
1249 gtk_tree_view_column_add_attribute(column, renderer, "text", | |
1250 POUNCES_MANAGER_COLUMN_TARGET); | |
1251 | |
1252 | |
1253 /* Account Column */ | |
1254 column = gtk_tree_view_column_new(); | |
1255 gtk_tree_view_column_set_title(column, _("Account")); | |
1256 gtk_tree_view_column_set_resizable(column, TRUE); | |
1257 gtk_tree_view_column_set_min_width(column, 200); | |
1258 gtk_tree_view_column_set_sort_column_id(column, | |
1259 POUNCES_MANAGER_COLUMN_ACCOUNT); | |
1260 gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column); | |
1261 renderer = gtk_cell_renderer_text_new(); | |
1262 gtk_tree_view_column_pack_start(column, renderer, TRUE); | |
1263 gtk_tree_view_column_add_attribute(column, renderer, "text", | |
1264 POUNCES_MANAGER_COLUMN_ACCOUNT); | |
1265 | |
1266 /* Recurring Column */ | |
1267 renderer = gtk_cell_renderer_toggle_new(); | |
1268 column = gtk_tree_view_column_new_with_attributes(_("Recurring"), renderer, | |
1269 "active", POUNCES_MANAGER_COLUMN_RECURRING, NULL); | |
1270 gtk_tree_view_column_set_sort_column_id(column, | |
1271 POUNCES_MANAGER_COLUMN_RECURRING); | |
1272 gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column); | |
1273 g_signal_connect(G_OBJECT(renderer), "toggled", | |
1274 G_CALLBACK(pounces_manager_recurring_cb), dialog); | |
1275 | |
1276 /* Enable CTRL+F searching */ | |
1277 gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeview), POUNCES_MANAGER_COLUMN_TARGET); | |
1278 gtk_tree_view_set_search_equal_func(GTK_TREE_VIEW(treeview), search_func, NULL, NULL); | |
1279 | |
1280 /* Sort the pouncee column by default */ | |
1281 gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(dialog->model), | |
1282 POUNCES_MANAGER_COLUMN_TARGET, | |
1283 GTK_SORT_ASCENDING); | |
1284 | |
1285 /* Populate list */ | |
1286 populate_pounces_list(dialog); | |
1287 | |
1288 return sw; | |
1289 } | |
1290 | |
1291 void | |
1292 gaim_gtk_pounces_manager_show(void) | |
1293 { | |
1294 PouncesManager *dialog; | |
1295 GtkWidget *bbox; | |
1296 GtkWidget *button; | |
1297 GtkWidget *list; | |
1298 GtkWidget *vbox; | |
1299 GtkWidget *win; | |
1300 int width, height; | |
1301 | |
1302 if (pounces_manager != NULL) { | |
1303 gtk_window_present(GTK_WINDOW(pounces_manager->window)); | |
1304 return; | |
1305 } | |
1306 | |
1307 pounces_manager = dialog = g_new0(PouncesManager, 1); | |
1308 | |
1309 width = gaim_prefs_get_int("/gaim/gtk/pounces/dialog/width"); | |
1310 height = gaim_prefs_get_int("/gaim/gtk/pounces/dialog/height"); | |
1311 | |
1312 dialog->window = win = gtk_window_new(GTK_WINDOW_TOPLEVEL); | |
1313 gtk_window_set_default_size(GTK_WINDOW(win), width, height); | |
1314 gtk_window_set_role(GTK_WINDOW(win), "pounces"); | |
1315 gtk_window_set_title(GTK_WINDOW(win), _("Buddy Pounces")); | |
1316 gtk_container_set_border_width(GTK_CONTAINER(win), GAIM_HIG_BORDER); | |
1317 | |
1318 g_signal_connect(G_OBJECT(win), "delete_event", | |
1319 G_CALLBACK(pounces_manager_destroy_cb), dialog); | |
1320 g_signal_connect(G_OBJECT(win), "configure_event", | |
1321 G_CALLBACK(pounces_manager_configure_cb), dialog); | |
1322 | |
1323 /* Setup the vbox */ | |
1324 vbox = gtk_vbox_new(FALSE, GAIM_HIG_BORDER); | |
1325 gtk_container_add(GTK_CONTAINER(win), vbox); | |
1326 gtk_widget_show(vbox); | |
1327 | |
1328 /* List of saved buddy pounces */ | |
1329 list = create_pounces_list(dialog); | |
1330 gtk_box_pack_start(GTK_BOX(vbox), list, TRUE, TRUE, 0); | |
1331 | |
1332 /* Button box. */ | |
1333 bbox = gtk_hbutton_box_new(); | |
1334 gtk_box_set_spacing(GTK_BOX(bbox), GAIM_HIG_BOX_SPACE); | |
1335 gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END); | |
1336 gtk_box_pack_end(GTK_BOX(vbox), bbox, FALSE, TRUE, 0); | |
1337 gtk_widget_show(bbox); | |
1338 | |
1339 /* Add button */ | |
1340 button = gtk_button_new_from_stock(GTK_STOCK_ADD); | |
1341 gtk_box_pack_start(GTK_BOX(bbox), button, FALSE, FALSE, 0); | |
1342 gtk_widget_set_sensitive(button, (gaim_connections_get_all() != NULL)); | |
1343 gaim_signal_connect(gaim_connections_get_handle(), "signed-on", | |
1344 pounces_manager, GAIM_CALLBACK(pounces_manager_connection_cb), button); | |
1345 gaim_signal_connect(gaim_connections_get_handle(), "signed-off", | |
1346 pounces_manager, GAIM_CALLBACK(pounces_manager_connection_cb), button); | |
1347 gtk_widget_show(button); | |
1348 | |
1349 g_signal_connect(G_OBJECT(button), "clicked", | |
1350 G_CALLBACK(pounces_manager_add_cb), dialog); | |
1351 | |
1352 /* Modify button */ | |
1353 button = gtk_button_new_from_stock(GAIM_STOCK_MODIFY); | |
1354 dialog->modify_button = button; | |
1355 gtk_box_pack_start(GTK_BOX(bbox), button, FALSE, FALSE, 0); | |
1356 gtk_widget_set_sensitive(button, FALSE); | |
1357 gtk_widget_show(button); | |
1358 | |
1359 g_signal_connect(G_OBJECT(button), "clicked", | |
1360 G_CALLBACK(pounces_manager_modify_cb), dialog); | |
1361 | |
1362 /* Delete button */ | |
1363 button = gtk_button_new_from_stock(GTK_STOCK_DELETE); | |
1364 dialog->delete_button = button; | |
1365 gtk_box_pack_start(GTK_BOX(bbox), button, FALSE, FALSE, 0); | |
1366 gtk_widget_set_sensitive(button, FALSE); | |
1367 gtk_widget_show(button); | |
1368 | |
1369 g_signal_connect(G_OBJECT(button), "clicked", | |
1370 G_CALLBACK(pounces_manager_delete_cb), dialog); | |
1371 | |
1372 /* Close button */ | |
1373 button = gtk_button_new_from_stock(GTK_STOCK_CLOSE); | |
1374 gtk_box_pack_start(GTK_BOX(bbox), button, FALSE, FALSE, 0); | |
1375 gtk_widget_show(button); | |
1376 | |
1377 g_signal_connect(G_OBJECT(button), "clicked", | |
1378 G_CALLBACK(pounces_manager_close_cb), dialog); | |
1379 | |
1380 gtk_widget_show(win); | |
1381 } | |
1382 | |
1383 void | |
1384 gaim_gtk_pounces_manager_hide(void) | |
1385 { | |
1386 if (pounces_manager == NULL) | |
1387 return; | |
1388 | |
1389 if (pounces_manager->window != NULL) | |
1390 gtk_widget_destroy(pounces_manager->window); | |
1391 | |
1392 gaim_signals_disconnect_by_handle(pounces_manager); | |
1393 | |
1394 g_free(pounces_manager); | |
1395 pounces_manager = NULL; | |
1396 } | |
1397 | |
1398 static void | |
1399 pounce_cb(GaimPounce *pounce, GaimPounceEvent events, void *data) | |
1400 { | |
1401 GaimConversation *conv; | |
1402 GaimAccount *account; | |
1403 GaimBuddy *buddy; | |
1404 const char *pouncee; | |
1405 const char *alias; | |
1406 | |
1407 pouncee = gaim_pounce_get_pouncee(pounce); | |
1408 account = gaim_pounce_get_pouncer(pounce); | |
1409 | |
1410 buddy = gaim_find_buddy(account, pouncee); | |
1411 if (buddy != NULL) | |
1412 { | |
1413 alias = gaim_buddy_get_alias(buddy); | |
1414 if (alias == NULL) | |
1415 alias = pouncee; | |
1416 } | |
1417 else | |
1418 alias = pouncee; | |
1419 | |
1420 if (gaim_pounce_action_is_enabled(pounce, "open-window")) | |
1421 { | |
1422 conv = gaim_find_conversation_with_account(GAIM_CONV_TYPE_IM, pouncee, account); | |
1423 | |
1424 if (conv == NULL) | |
1425 conv = gaim_conversation_new(GAIM_CONV_TYPE_IM, account, pouncee); | |
1426 } | |
1427 | |
1428 if (gaim_pounce_action_is_enabled(pounce, "popup-notify")) | |
1429 { | |
1430 char *tmp; | |
1431 const char *name_shown; | |
1432 const char *reason; | |
1433 reason = gaim_pounce_action_get_attribute(pounce, "popup-notify", | |
1434 "reason"); | |
1435 | |
1436 /* | |
1437 * Here we place the protocol name in the pounce dialog to lessen | |
1438 * confusion about what protocol a pounce is for. | |
1439 */ | |
1440 tmp = g_strdup_printf( | |
1441 (events & GAIM_POUNCE_TYPING) ? | |
1442 _("%s has started typing to you (%s)") : | |
1443 (events & GAIM_POUNCE_TYPED) ? | |
1444 _("%s has paused while typing to you (%s)") : | |
1445 (events & GAIM_POUNCE_SIGNON) ? | |
1446 _("%s has signed on (%s)") : | |
1447 (events & GAIM_POUNCE_IDLE_RETURN) ? | |
1448 _("%s has returned from being idle (%s)") : | |
1449 (events & GAIM_POUNCE_AWAY_RETURN) ? | |
1450 _("%s has returned from being away (%s)") : | |
1451 (events & GAIM_POUNCE_TYPING_STOPPED) ? | |
1452 _("%s has stopped typing to you (%s)") : | |
1453 (events & GAIM_POUNCE_SIGNOFF) ? | |
1454 _("%s has signed off (%s)") : | |
1455 (events & GAIM_POUNCE_IDLE) ? | |
1456 _("%s has become idle (%s)") : | |
1457 (events & GAIM_POUNCE_AWAY) ? | |
1458 _("%s has gone away. (%s)") : | |
1459 (events & GAIM_POUNCE_MESSAGE_RECEIVED) ? | |
1460 _("%s has sent you a message. (%s)") : | |
1461 _("Unknown pounce event. Please report this!"), | |
1462 alias, gaim_account_get_protocol_name(account)); | |
1463 | |
1464 /* | |
1465 * Ok here is where I change the second argument, title, from | |
1466 * NULL to the account alias if we have it or the account | |
1467 * name if that's all we have | |
1468 */ | |
1469 if ((name_shown = gaim_account_get_alias(account)) == NULL) | |
1470 name_shown = gaim_account_get_username(account); | |
1471 | |
1472 if (reason == NULL) | |
1473 { | |
1474 gaim_notify_info(NULL, name_shown, tmp, gaim_date_format_full(NULL)); | |
1475 } | |
1476 else | |
1477 { | |
1478 char *tmp2 = g_strdup_printf("%s\n\n%s", reason, gaim_date_format_full(NULL)); | |
1479 gaim_notify_info(NULL, name_shown, tmp, tmp2); | |
1480 g_free(tmp2); | |
1481 } | |
1482 g_free(tmp); | |
1483 } | |
1484 | |
1485 if (gaim_pounce_action_is_enabled(pounce, "send-message")) | |
1486 { | |
1487 const char *message; | |
1488 | |
1489 message = gaim_pounce_action_get_attribute(pounce, "send-message", | |
1490 "message"); | |
1491 | |
1492 if (message != NULL) | |
1493 { | |
1494 conv = gaim_find_conversation_with_account(GAIM_CONV_TYPE_IM, pouncee, account); | |
1495 | |
1496 if (conv == NULL) | |
1497 conv = gaim_conversation_new(GAIM_CONV_TYPE_IM, account, pouncee); | |
1498 | |
1499 gaim_conversation_write(conv, NULL, message, | |
1500 GAIM_MESSAGE_SEND, time(NULL)); | |
1501 | |
1502 serv_send_im(account->gc, (char *)pouncee, (char *)message, 0); | |
1503 } | |
1504 } | |
1505 | |
1506 if (gaim_pounce_action_is_enabled(pounce, "execute-command")) | |
1507 { | |
1508 const char *command; | |
1509 | |
1510 command = gaim_pounce_action_get_attribute(pounce, | |
1511 "execute-command", "command"); | |
1512 | |
1513 if (command != NULL) | |
1514 { | |
1515 #ifndef _WIN32 | |
1516 char *localecmd = g_locale_from_utf8(command, -1, NULL, | |
1517 NULL, NULL); | |
1518 | |
1519 if (localecmd != NULL) | |
1520 { | |
1521 int pid = fork(); | |
1522 | |
1523 if (pid == 0) { | |
1524 char *args[4]; | |
1525 | |
1526 args[0] = "sh"; | |
1527 args[1] = "-c"; | |
1528 args[2] = (char *)localecmd; | |
1529 args[3] = NULL; | |
1530 | |
1531 execvp(args[0], args); | |
1532 | |
1533 _exit(0); | |
1534 } | |
1535 g_free(localecmd); | |
1536 } | |
1537 #else /* !_WIN32 */ | |
1538 PROCESS_INFORMATION pi; | |
1539 BOOL retval; | |
1540 gchar *message = NULL; | |
1541 | |
1542 memset(&pi, 0, sizeof(pi)); | |
1543 | |
1544 if (G_WIN32_HAVE_WIDECHAR_API ()) { | |
1545 STARTUPINFOW si; | |
1546 wchar_t *wc_cmd = g_utf8_to_utf16(command, | |
1547 -1, NULL, NULL, NULL); | |
1548 | |
1549 memset(&si, 0 , sizeof(si)); | |
1550 si.cb = sizeof(si); | |
1551 | |
1552 retval = CreateProcessW(NULL, wc_cmd, NULL, | |
1553 NULL, 0, 0, NULL, NULL, | |
1554 &si, &pi); | |
1555 g_free(wc_cmd); | |
1556 } else { | |
1557 STARTUPINFOA si; | |
1558 char *l_cmd = g_locale_from_utf8(command, | |
1559 -1, NULL, NULL, NULL); | |
1560 | |
1561 memset(&si, 0 , sizeof(si)); | |
1562 si.cb = sizeof(si); | |
1563 | |
1564 retval = CreateProcessA(NULL, l_cmd, NULL, | |
1565 NULL, 0, 0, NULL, NULL, | |
1566 &si, &pi); | |
1567 g_free(l_cmd); | |
1568 } | |
1569 | |
1570 if (retval) { | |
1571 CloseHandle(pi.hProcess); | |
1572 CloseHandle(pi.hThread); | |
1573 } else { | |
1574 message = g_win32_error_message(GetLastError()); | |
1575 } | |
1576 | |
1577 gaim_debug_info("pounce", | |
1578 "Pounce execute command called for: " | |
1579 "%s\n%s%s%s", | |
1580 command, | |
1581 retval ? "" : "Error: ", | |
1582 retval ? "" : message, | |
1583 retval ? "" : "\n"); | |
1584 g_free(message); | |
1585 #endif /* !_WIN32 */ | |
1586 } | |
1587 } | |
1588 | |
1589 if (gaim_pounce_action_is_enabled(pounce, "play-sound")) | |
1590 { | |
1591 const char *sound; | |
1592 | |
1593 sound = gaim_pounce_action_get_attribute(pounce, | |
1594 "play-sound", "filename"); | |
1595 | |
1596 if (sound != NULL) | |
1597 gaim_sound_play_file(sound, account); | |
1598 else | |
1599 gaim_sound_play_event(GAIM_SOUND_POUNCE_DEFAULT, account); | |
1600 } | |
1601 } | |
1602 | |
1603 static void | |
1604 free_pounce(GaimPounce *pounce) | |
1605 { | |
1606 update_pounces(); | |
1607 } | |
1608 | |
1609 static void | |
1610 new_pounce(GaimPounce *pounce) | |
1611 { | |
1612 gaim_pounce_action_register(pounce, "open-window"); | |
1613 gaim_pounce_action_register(pounce, "popup-notify"); | |
1614 gaim_pounce_action_register(pounce, "send-message"); | |
1615 gaim_pounce_action_register(pounce, "execute-command"); | |
1616 gaim_pounce_action_register(pounce, "play-sound"); | |
1617 | |
1618 update_pounces(); | |
1619 } | |
1620 | |
1621 void * | |
1622 gaim_gtk_pounces_get_handle() { | |
1623 static int handle; | |
1624 | |
1625 return &handle; | |
1626 } | |
1627 | |
1628 void | |
1629 gaim_gtk_pounces_init(void) | |
1630 { | |
1631 gaim_pounces_register_handler(GAIM_GTK_UI, pounce_cb, new_pounce, | |
1632 free_pounce); | |
1633 | |
1634 gaim_prefs_add_none("/gaim/gtk/pounces"); | |
1635 gaim_prefs_add_none("/gaim/gtk/pounces/default_actions"); | |
1636 gaim_prefs_add_bool("/gaim/gtk/pounces/default_actions/open-window", | |
1637 FALSE); | |
1638 gaim_prefs_add_bool("/gaim/gtk/pounces/default_actions/popup-notify", | |
1639 TRUE); | |
1640 gaim_prefs_add_bool("/gaim/gtk/pounces/default_actions/send-message", | |
1641 FALSE); | |
1642 gaim_prefs_add_bool("/gaim/gtk/pounces/default_actions/execute-command", | |
1643 FALSE); | |
1644 gaim_prefs_add_bool("/gaim/gtk/pounces/default_actions/play-sound", | |
1645 FALSE); | |
1646 gaim_prefs_add_none("/gaim/gtk/pounces/dialog"); | |
1647 gaim_prefs_add_int("/gaim/gtk/pounces/dialog/width", 520); | |
1648 gaim_prefs_add_int("/gaim/gtk/pounces/dialog/height", 321); | |
1649 | |
1650 gaim_signal_connect(gaim_connections_get_handle(), "signed-on", | |
1651 gaim_gtk_pounces_get_handle(), | |
1652 GAIM_CALLBACK(signed_on_off_cb), NULL); | |
1653 gaim_signal_connect(gaim_connections_get_handle(), "signed-off", | |
1654 gaim_gtk_pounces_get_handle(), | |
1655 GAIM_CALLBACK(signed_on_off_cb), NULL); | |
1656 } |