Mercurial > pidgin3 / file comparison

comparison: pidgin/gtklog.c

pidgin/gtklog.c

branch
cpw.khc.msnp14
changeset 20478
46933dc62880
parent 20472
6a6d2ef151e6
parent 15931
716b5fac1895
child 20481
65485e2ed8a3
equal deleted inserted replaced
20476:198222e01a7d 20478:46933dc62880
1 /**
2 * @file gtklog.c GTK+ Log viewer
3 * @ingroup gtkui
4 *
5 * pidgin
6 *
7 * Pidgin 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 #include "internal.h"
26 #include "pidgin.h"
27
28 #include "account.h"
29 #include "debug.h"
30 #include "log.h"
31 #include "notify.h"
32 #include "request.h"
33 #include "util.h"
34
35 #include "pidginstock.h"
36 #include "gtkblist.h"
37 #include "gtkimhtml.h"
38 #include "gtklog.h"
39 #include "gtkutils.h"
40
41 static GHashTable *log_viewers = NULL;
42 static void populate_log_tree(PidginLogViewer *lv);
43 static PidginLogViewer *syslog_viewer = NULL;
44
45 struct log_viewer_hash_t {
46 PurpleLogType type;
47 char *screenname;
48 PurpleAccount *account;
49 PurpleContact *contact;
50 };
51
52 static guint log_viewer_hash(gconstpointer data)
53 {
54 const struct log_viewer_hash_t *viewer = data;
55
56 if (viewer->contact != NULL)
57 return g_direct_hash(viewer->contact);
58
59 return g_str_hash(viewer->screenname) +
60 g_str_hash(purple_account_get_username(viewer->account));
61 }
62
63 static gboolean log_viewer_equal(gconstpointer y, gconstpointer z)
64 {
65 const struct log_viewer_hash_t *a, *b;
66 int ret;
67 char *normal;
68
69 a = y;
70 b = z;
71
72 if (a->contact != NULL) {
73 if (b->contact != NULL)
74 return (a->contact == b->contact);
75 else
76 return FALSE;
77 } else {
78 if (b->contact != NULL)
79 return FALSE;
80 }
81
82 normal = g_strdup(purple_normalize(a->account, a->screenname));
83 ret = (a->account == b->account) &&
84 !strcmp(normal, purple_normalize(b->account, b->screenname));
85 g_free(normal);
86
87 return ret;
88 }
89
90 static void select_first_log(PidginLogViewer *lv)
91 {
92 GtkTreeModel *model;
93 GtkTreeIter iter, it;
94 GtkTreePath *path;
95
96 model = GTK_TREE_MODEL(lv->treestore);
97
98 if (!gtk_tree_model_get_iter_first(model, &iter))
99 return;
100
101 path = gtk_tree_model_get_path(model, &iter);
102 if (gtk_tree_model_iter_children(model, &it, &iter))
103 {
104 gtk_tree_view_expand_row(GTK_TREE_VIEW(lv->treeview), path, TRUE);
105 path = gtk_tree_model_get_path(model, &it);
106 }
107
108 gtk_tree_selection_select_path(gtk_tree_view_get_selection(GTK_TREE_VIEW(lv->treeview)), path);
109
110 gtk_tree_path_free(path);
111 }
112
113 static const char *log_get_date(PurpleLog *log)
114 {
115 if (log->tm)
116 return purple_date_format_full(log->tm);
117 else
118 return purple_date_format_full(localtime(&log->time));
119 }
120
121 static void search_cb(GtkWidget *button, PidginLogViewer *lv)
122 {
123 const char *search_term = gtk_entry_get_text(GTK_ENTRY(lv->entry));
124 GList *logs;
125
126 if (!(*search_term)) {
127 /* reset the tree */
128 gtk_tree_store_clear(lv->treestore);
129 populate_log_tree(lv);
130 g_free(lv->search);
131 lv->search = NULL;
132 gtk_imhtml_search_clear(GTK_IMHTML(lv->imhtml));
133 select_first_log(lv);
134 return;
135 }
136
137 if (lv->search != NULL && !strcmp(lv->search, search_term))
138 {
139 /* Searching for the same term acts as "Find Next" */
140 gtk_imhtml_search_find(GTK_IMHTML(lv->imhtml), lv->search);
141 return;
142 }
143
144 pidgin_set_cursor(lv->window, GDK_WATCH);
145
146 g_free(lv->search);
147 lv->search = g_strdup(search_term);
148
149 gtk_tree_store_clear(lv->treestore);
150 gtk_imhtml_clear(GTK_IMHTML(lv->imhtml));
151
152 for (logs = lv->logs; logs != NULL; logs = logs->next) {
153 char *read = purple_log_read((PurpleLog*)logs->data, NULL);
154 if (read && *read && purple_strcasestr(read, search_term)) {
155 GtkTreeIter iter;
156 PurpleLog *log = logs->data;
157
158 gtk_tree_store_append (lv->treestore, &iter, NULL);
159 gtk_tree_store_set(lv->treestore, &iter,
160 0, log_get_date(log),
161 1, log, -1);
162 }
163 g_free(read);
164 }
165
166 select_first_log(lv);
167 pidgin_clear_cursor(lv->window);
168 }
169
170 static void destroy_cb(GtkWidget *w, gint resp, struct log_viewer_hash_t *ht) {
171 PidginLogViewer *lv = syslog_viewer;
172
173 #ifdef _WIN32
174 if (resp == GTK_RESPONSE_HELP) {
175 char *logdir = g_build_filename(purple_user_dir(), "logs", NULL);
176 winpidgin_shell_execute(logdir, "explore", NULL);
177 g_free(logdir);
178 return;
179 }
180 #endif
181
182 if (ht != NULL) {
183 lv = g_hash_table_lookup(log_viewers, ht);
184 g_hash_table_remove(log_viewers, ht);
185
186 g_free(ht->screenname);
187 g_free(ht);
188 } else
189 syslog_viewer = NULL;
190
191 purple_request_close_with_handle(lv);
192
193 g_list_foreach(lv->logs, (GFunc)purple_log_free, NULL);
194 g_list_free(lv->logs);
195
196 g_free(lv->search);
197 g_free(lv);
198
199 gtk_widget_destroy(w);
200 }
201
202 static void log_row_activated_cb(GtkTreeView *tv, GtkTreePath *path, GtkTreeViewColumn *col, PidginLogViewer *viewer) {
203 if (gtk_tree_view_row_expanded(tv, path))
204 gtk_tree_view_collapse_row(tv, path);
205 else
206 gtk_tree_view_expand_row(tv, path, FALSE);
207 }
208
209 static void delete_log_cleanup_cb(gpointer *data)
210 {
211 g_free(data[1]); /* iter */
212 g_free(data);
213 }
214
215 static void delete_log_cb(gpointer *data)
216 {
217 if (!purple_log_delete((PurpleLog *)data[2]))
218 {
219 purple_notify_error(NULL, NULL, "Log Deletion Failed",
220 "Check permissions and try again.");
221 }
222 else
223 {
224 GtkTreeStore *treestore = data[0];
225 GtkTreeIter *iter = (GtkTreeIter *)data[1];
226 GtkTreePath *path = gtk_tree_model_get_path(GTK_TREE_MODEL(treestore), iter);
227 gboolean first = !gtk_tree_path_prev(path);
228
229 if (!gtk_tree_store_remove(treestore, iter) && first)
230 {
231 /* iter was the last child at its level */
232
233 if (gtk_tree_path_up(path))
234 {
235 gtk_tree_model_get_iter(GTK_TREE_MODEL(treestore), iter, path);
236 gtk_tree_store_remove(treestore, iter);
237 }
238 }
239 gtk_tree_path_free(path);
240 }
241
242 delete_log_cleanup_cb(data);
243 }
244
245 static void log_delete_log_cb(GtkWidget *menuitem, gpointer *data)
246 {
247 PidginLogViewer *lv = data[0];
248 PurpleLog *log = data[1];
249 const char *time = log_get_date(log);
250 const char *name;
251 char *tmp;
252 gpointer *data2;
253
254 if (log->type == PURPLE_LOG_IM)
255 {
256 PurpleBuddy *buddy = purple_find_buddy(log->account, log->name);
257 if (buddy != NULL)
258 name = purple_buddy_get_contact_alias(buddy);
259 else
260 name = log->name;
261
262 tmp = g_strdup_printf(_("Are you sure you want to permanently delete the log of the "
263 "conversation with %s which started at %s?"), name, time);
264 }
265 else if (log->type == PURPLE_LOG_CHAT)
266 {
267 PurpleChat *chat = purple_blist_find_chat(log->account, log->name);
268 if (chat != NULL)
269 name = purple_chat_get_name(chat);
270 else
271 name = log->name;
272
273 tmp = g_strdup_printf(_("Are you sure you want to permanently delete the log of the "
274 "conversation in %s which started at %s?"), name, time);
275 }
276 else if (log->type == PURPLE_LOG_SYSTEM)
277 {
278 tmp = g_strdup_printf(_("Are you sure you want to permanently delete the system log "
279 "which started at %s?"), time);
280 }
281 else
282 g_return_if_reached();
283
284 /* The only way to free data in all cases is to tie it to the menuitem with
285 * g_object_set_data_full(). But, since we need to get some data down to
286 * delete_log_cb() to delete the log from the log viewer after the file is
287 * deleted, we have to allocate a new data array and make sure it gets freed
288 * either way. */
289 data2 = g_new(gpointer, 3);
290 data2[0] = lv->treestore;
291 data2[1] = data[3]; /* iter */
292 data2[2] = log;
293 purple_request_action(lv, NULL, "Delete Log?", tmp,
294 0, data2, 2, _("Delete"), delete_log_cb, _("Cancel"), delete_log_cleanup_cb);
295 g_free(tmp);
296 }
297
298 static void log_show_popup_menu(GtkWidget *treeview, GdkEventButton *event, gpointer *data)
299 {
300 GtkWidget *menu = gtk_menu_new();
301 GtkWidget *menuitem = gtk_menu_item_new_with_label("Delete Log...");
302
303 if (!purple_log_is_deletable((PurpleLog *)data[1]))
304 gtk_widget_set_sensitive(menuitem, FALSE);
305
306 g_signal_connect(menuitem, "activate", G_CALLBACK(log_delete_log_cb), data);
307 g_object_set_data_full(G_OBJECT(menuitem), "log-viewer-data", data, g_free);
308 gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
309 gtk_widget_show_all(menu);
310
311 gtk_menu_popup(GTK_MENU(menu), NULL, NULL, (GtkMenuPositionFunc)data[2], NULL,
312 (event != NULL) ? event->button : 0,
313 gdk_event_get_time((GdkEvent *)event));
314 }
315
316 static gboolean log_button_press_cb(GtkWidget *treeview, GdkEventButton *event, PidginLogViewer *lv)
317 {
318 if (event->type == GDK_BUTTON_PRESS && event->button == 3)
319 {
320 GtkTreePath *path;
321 GtkTreeIter *iter;
322 GValue val;
323 PurpleLog *log;
324 gpointer *data;
325
326 if (!gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(treeview), event->x, event->y, &path, NULL, NULL, NULL))
327 return FALSE;
328 iter = g_new(GtkTreeIter, 1);
329 gtk_tree_model_get_iter(GTK_TREE_MODEL(lv->treestore), iter, path);
330 val.g_type = 0;
331 gtk_tree_model_get_value(GTK_TREE_MODEL(lv->treestore), iter, 1, &val);
332
333 log = g_value_get_pointer(&val);
334
335 if (log == NULL)
336 {
337 g_free(iter);
338 return FALSE;
339 }
340
341 data = g_new(gpointer, 4);
342 data[0] = lv;
343 data[1] = log;
344 data[2] = NULL;
345 data[3] = iter;
346
347 log_show_popup_menu(treeview, event, data);
348 return TRUE;
349 }
350
351 return FALSE;
352 }
353
354 static gboolean log_popup_menu_cb(GtkWidget *treeview, PidginLogViewer *lv)
355 {
356 GtkTreeSelection *sel;
357 GtkTreeIter *iter;
358 GValue val;
359 PurpleLog *log;
360 gpointer *data;
361
362 iter = g_new(GtkTreeIter, 1);
363 sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(lv));
364 if (!gtk_tree_selection_get_selected(sel, NULL, iter))
365 {
366 return FALSE;
367 }
368
369 val.g_type = 0;
370 gtk_tree_model_get_value(GTK_TREE_MODEL(lv->treestore),
371 iter, NODE_COLUMN, &val);
372
373 log = g_value_get_pointer(&val);
374
375 if (log == NULL)
376 return FALSE;
377
378 data = g_new(gpointer, 4);
379 data[0] = lv;
380 data[1] = log;
381 data[2] = pidgin_treeview_popup_menu_position_func;
382 data[3] = iter;
383
384 log_show_popup_menu(treeview, NULL, data);
385 return TRUE;
386 }
387
388 static gboolean search_find_cb(gpointer data)
389 {
390 PidginLogViewer *viewer = data;
391 gtk_imhtml_search_find(GTK_IMHTML(viewer->imhtml), viewer->search);
392 return FALSE;
393 }
394
395 static void log_select_cb(GtkTreeSelection *sel, PidginLogViewer *viewer) {
396 GtkTreeIter iter;
397 GValue val;
398 GtkTreeModel *model = GTK_TREE_MODEL(viewer->treestore);
399 PurpleLog *log = NULL;
400 PurpleLogReadFlags flags;
401 char *read = NULL;
402
403 if (!gtk_tree_selection_get_selected(sel, &model, &iter))
404 return;
405
406 val.g_type = 0;
407 gtk_tree_model_get_value (model, &iter, 1, &val);
408 log = g_value_get_pointer(&val);
409 g_value_unset(&val);
410
411 if (log == NULL)
412 return;
413
414 pidgin_set_cursor(viewer->window, GDK_WATCH);
415
416 if (log->type != PURPLE_LOG_SYSTEM) {
417 char *title;
418 if (log->type == PURPLE_LOG_CHAT)
419 title = g_strdup_printf(_("<span size='larger' weight='bold'>Conversation in %s on %s</span>"),
420 log->name, log_get_date(log));
421 else
422 title = g_strdup_printf(_("<span size='larger' weight='bold'>Conversation with %s on %s</span>"),
423 log->name, log_get_date(log));
424
425 gtk_label_set_markup(GTK_LABEL(viewer->label), title);
426 g_free(title);
427 }
428
429 read = purple_log_read(log, &flags);
430 viewer->flags = flags;
431
432 gtk_imhtml_clear(GTK_IMHTML(viewer->imhtml));
433 gtk_imhtml_set_protocol_name(GTK_IMHTML(viewer->imhtml),
434 purple_account_get_protocol_name(log->account));
435
436 purple_signal_emit(pidgin_log_get_handle(), "log-displaying", viewer, log);
437
438 gtk_imhtml_append_text(GTK_IMHTML(viewer->imhtml), read,
439 GTK_IMHTML_NO_COMMENTS | GTK_IMHTML_NO_TITLE | GTK_IMHTML_NO_SCROLL |
440 ((flags & PURPLE_LOG_READ_NO_NEWLINE) ? GTK_IMHTML_NO_NEWLINE : 0));
441 g_free(read);
442
443 if (viewer->search != NULL) {
444 gtk_imhtml_search_clear(GTK_IMHTML(viewer->imhtml));
445 g_idle_add(search_find_cb, viewer);
446 }
447
448 pidgin_clear_cursor(viewer->window);
449 }
450
451 /* I want to make this smarter, but haven't come up with a cool algorithm to do so, yet.
452 * I want the tree to be divided into groups like "Today," "Yesterday," "Last week,"
453 * "August," "2002," etc. based on how many conversation took place in each subdivision.
454 *
455 * For now, I'll just make it a flat list.
456 */
457 static void populate_log_tree(PidginLogViewer *lv)
458 /* Logs are made from trees in real life.
459 This is a tree made from logs */
460 {
461 const char *month;
462 char prev_top_month[30] = "";
463 GtkTreeIter toplevel, child;
464 GList *logs = lv->logs;
465
466 while (logs != NULL) {
467 PurpleLog *log = logs->data;
468
469 month = purple_utf8_strftime(_("%B %Y"),
470 log->tm ? log->tm : localtime(&log->time));
471
472 if (strcmp(month, prev_top_month) != 0)
473 {
474 /* top level */
475 gtk_tree_store_append(lv->treestore, &toplevel, NULL);
476 gtk_tree_store_set(lv->treestore, &toplevel, 0, month, 1, NULL, -1);
477
478 strncpy(prev_top_month, month, sizeof(prev_top_month));
479 }
480
481 /* sub */
482 gtk_tree_store_append(lv->treestore, &child, &toplevel);
483 gtk_tree_store_set(lv->treestore, &child,
484 0, log_get_date(log),
485 1, log,
486 -1);
487
488 logs = logs->next;
489 }
490 }
491
492 static PidginLogViewer *display_log_viewer(struct log_viewer_hash_t *ht, GList *logs,
493 const char *title, GtkWidget *icon, int log_size)
494 {
495 PidginLogViewer *lv;
496 GtkWidget *title_box;
497 char *text;
498 GtkWidget *pane;
499 GtkWidget *sw;
500 GtkCellRenderer *rend;
501 GtkTreeViewColumn *col;
502 GtkTreeSelection *sel;
503 GtkWidget *vbox;
504 GtkWidget *frame;
505 GtkWidget *hbox;
506 GtkWidget *find_button;
507 GtkWidget *size_label;
508
509 if (logs == NULL)
510 {
511 /* No logs were found. */
512 const char *log_preferences = NULL;
513
514 if (ht == NULL) {
515 if (!purple_prefs_get_bool("/core/logging/log_system"))
516 log_preferences = _("System events will only be logged if the \"Log all status changes to system log\" preference is enabled.");
517 } else {
518 if (ht->type == PURPLE_LOG_IM) {
519 if (!purple_prefs_get_bool("/core/logging/log_ims"))
520 log_preferences = _("Instant messages will only be logged if the \"Log all instant messages\" preference is enabled.");
521 } else if (ht->type == PURPLE_LOG_CHAT) {
522 if (!purple_prefs_get_bool("/core/logging/log_chats"))
523 log_preferences = _("Chats will only be logged if the \"Log all chats\" preference is enabled.");
524 }
525 }
526
527 purple_notify_info(NULL, title, _("No logs were found"), log_preferences);
528 return NULL;
529 }
530
531 lv = g_new0(PidginLogViewer, 1);
532 lv->logs = logs;
533
534 if (ht != NULL)
535 g_hash_table_insert(log_viewers, ht, lv);
536
537 /* Window ***********/
538 lv->window = gtk_dialog_new_with_buttons(title, NULL, 0,
539 GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL);
540 #ifdef _WIN32
541 /* Steal the "HELP" response and use it to trigger browsing to the logs folder */
542 gtk_dialog_add_button(GTK_DIALOG(lv->window), _("_Browse logs folder"), GTK_RESPONSE_HELP);
543 #endif
544 gtk_container_set_border_width (GTK_CONTAINER(lv->window), PIDGIN_HIG_BOX_SPACE);
545 gtk_dialog_set_has_separator(GTK_DIALOG(lv->window), FALSE);
546 gtk_box_set_spacing(GTK_BOX(GTK_DIALOG(lv->window)->vbox), 0);
547 g_signal_connect(G_OBJECT(lv->window), "response",
548 G_CALLBACK(destroy_cb), ht);
549 gtk_window_set_role(GTK_WINDOW(lv->window), "log_viewer");
550
551 /* Icon *************/
552 if (icon != NULL) {
553 title_box = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
554 gtk_container_set_border_width(GTK_CONTAINER(title_box), PIDGIN_HIG_BOX_SPACE);
555 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(lv->window)->vbox), title_box, FALSE, FALSE, 0);
556
557 gtk_box_pack_start(GTK_BOX(title_box), icon, FALSE, FALSE, 0);
558 } else
559 title_box = GTK_DIALOG(lv->window)->vbox;
560
561 /* Label ************/
562 lv->label = gtk_label_new(NULL);
563
564 text = g_strdup_printf("<span size='larger' weight='bold'>%s</span>", title);
565
566 gtk_label_set_markup(GTK_LABEL(lv->label), text);
567 gtk_misc_set_alignment(GTK_MISC(lv->label), 0, 0);
568 gtk_box_pack_start(GTK_BOX(title_box), lv->label, FALSE, FALSE, 0);
569 g_free(text);
570
571 /* Pane *************/
572 pane = gtk_hpaned_new();
573 gtk_container_set_border_width(GTK_CONTAINER(pane), PIDGIN_HIG_BOX_SPACE);
574 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(lv->window)->vbox), pane, TRUE, TRUE, 0);
575
576 /* List *************/
577 sw = gtk_scrolled_window_new (NULL, NULL);
578 gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN);
579 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
580 gtk_paned_add1(GTK_PANED(pane), sw);
581 lv->treestore = gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_POINTER);
582 lv->treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (lv->treestore));
583 rend = gtk_cell_renderer_text_new();
584 col = gtk_tree_view_column_new_with_attributes ("time", rend, "markup", 0, NULL);
585 gtk_tree_view_append_column (GTK_TREE_VIEW(lv->treeview), col);
586 gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (lv->treeview), FALSE);
587 gtk_container_add (GTK_CONTAINER (sw), lv->treeview);
588
589 populate_log_tree(lv);
590
591 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (lv->treeview));
592 g_signal_connect (G_OBJECT (sel), "changed",
593 G_CALLBACK (log_select_cb),
594 lv);
595 g_signal_connect (G_OBJECT(lv->treeview), "row-activated",
596 G_CALLBACK(log_row_activated_cb),
597 lv);
598 pidgin_set_accessible_label(lv->treeview, lv->label);
599
600 g_signal_connect(lv->treeview, "button-press-event", G_CALLBACK(log_button_press_cb), lv);
601 g_signal_connect(lv->treeview, "popup-menu", G_CALLBACK(log_popup_menu_cb), lv);
602
603 /* Log size ************/
604 if(log_size) {
605 char *sz_txt = purple_str_size_to_units(log_size);
606 text = g_strdup_printf("<span weight='bold'>%s</span> %s", _("Total log size:"), sz_txt);
607 size_label = gtk_label_new(NULL);
608 gtk_label_set_markup(GTK_LABEL(size_label), text);
609 /* gtk_paned_add1(GTK_PANED(pane), size_label); */
610 gtk_misc_set_alignment(GTK_MISC(size_label), 0, 0);
611 gtk_box_pack_end(GTK_BOX(GTK_DIALOG(lv->window)->vbox), size_label, FALSE, FALSE, 0);
612 g_free(sz_txt);
613 g_free(text);
614 }
615
616 /* A fancy little box ************/
617 vbox = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
618 gtk_paned_add2(GTK_PANED(pane), vbox);
619
620 /* Viewer ************/
621 frame = pidgin_create_imhtml(FALSE, &lv->imhtml, NULL, NULL);
622 gtk_widget_set_name(lv->imhtml, "pidginlog_imhtml");
623 gtk_widget_set_size_request(lv->imhtml, 320, 200);
624 gtk_box_pack_start(GTK_BOX(vbox), frame, TRUE, TRUE, 0);
625 gtk_widget_show(frame);
626
627 /* Search box **********/
628 hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
629 gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
630 lv->entry = gtk_entry_new();
631 gtk_box_pack_start(GTK_BOX(hbox), lv->entry, TRUE, TRUE, 0);
632 find_button = gtk_button_new_from_stock(GTK_STOCK_FIND);
633 gtk_box_pack_start(GTK_BOX(hbox), find_button, FALSE, FALSE, 0);
634 g_signal_connect(GTK_ENTRY(lv->entry), "activate", G_CALLBACK(search_cb), lv);
635 g_signal_connect(GTK_BUTTON(find_button), "clicked", G_CALLBACK(search_cb), lv);
636
637 select_first_log(lv);
638
639 gtk_widget_show_all(lv->window);
640
641 return lv;
642 }
643
644 void pidgin_log_show(PurpleLogType type, const char *screenname, PurpleAccount *account) {
645 struct log_viewer_hash_t *ht;
646 PidginLogViewer *lv = NULL;
647 const char *name = screenname;
648 char *title;
649
650 g_return_if_fail(account != NULL);
651 g_return_if_fail(screenname != NULL);
652
653 ht = g_new0(struct log_viewer_hash_t, 1);
654
655 ht->type = type;
656 ht->screenname = g_strdup(screenname);
657 ht->account = account;
658
659 if (log_viewers == NULL) {
660 log_viewers = g_hash_table_new(log_viewer_hash, log_viewer_equal);
661 } else if ((lv = g_hash_table_lookup(log_viewers, ht))) {
662 gtk_window_present(GTK_WINDOW(lv->window));
663 g_free(ht->screenname);
664 g_free(ht);
665 return;
666 }
667
668 if (type == PURPLE_LOG_CHAT) {
669 PurpleChat *chat;
670
671 chat = purple_blist_find_chat(account, screenname);
672 if (chat != NULL)
673 name = purple_chat_get_name(chat);
674
675 title = g_strdup_printf(_("Conversations in %s"), name);
676 } else {
677 PurpleBuddy *buddy;
678
679 buddy = purple_find_buddy(account, screenname);
680 if (buddy != NULL)
681 name = purple_buddy_get_contact_alias(buddy);
682
683 title = g_strdup_printf(_("Conversations with %s"), name);
684 }
685
686 display_log_viewer(ht, purple_log_get_logs(type, screenname, account),
687 title, gtk_image_new_from_pixbuf(pidgin_create_prpl_icon(account, PIDGIN_PRPL_ICON_MEDIUM)),
688 purple_log_get_total_size(type, screenname, account));
689 g_free(title);
690 }
691
692 void pidgin_log_show_contact(PurpleContact *contact) {
693 struct log_viewer_hash_t *ht = g_new0(struct log_viewer_hash_t, 1);
694 PurpleBlistNode *child;
695 PidginLogViewer *lv = NULL;
696 GList *logs = NULL;
697 GdkPixbuf *pixbuf;
698 GtkWidget *image = gtk_image_new();
699 const char *name = NULL;
700 char *title;
701 int total_log_size = 0;
702
703 g_return_if_fail(contact != NULL);
704
705 ht->type = PURPLE_LOG_IM;
706 ht->contact = contact;
707
708 if (log_viewers == NULL) {
709 log_viewers = g_hash_table_new(log_viewer_hash, log_viewer_equal);
710 } else if ((lv = g_hash_table_lookup(log_viewers, ht))) {
711 gtk_window_present(GTK_WINDOW(lv->window));
712 g_free(ht);
713 return;
714 }
715
716 for (child = contact->node.child ; child ; child = child->next) {
717 if (!PURPLE_BLIST_NODE_IS_BUDDY(child))
718 continue;
719
720 logs = g_list_concat(purple_log_get_logs(PURPLE_LOG_IM, ((PurpleBuddy *)child)->name,
721 ((PurpleBuddy *)child)->account), logs);
722 total_log_size += purple_log_get_total_size(PURPLE_LOG_IM, ((PurpleBuddy *)child)->name, ((PurpleBuddy *)child)->account);
723 }
724 logs = g_list_sort(logs, purple_log_compare);
725
726 pixbuf = gtk_widget_render_icon (image, PIDGIN_STOCK_STATUS_PERSON,
727 gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_SMALL), "GtkWindow");
728 gtk_image_set_from_pixbuf(GTK_IMAGE(image), pixbuf);
729
730 if (contact->alias != NULL)
731 name = contact->alias;
732 else if (contact->priority != NULL)
733 name = purple_buddy_get_contact_alias(contact->priority);
734
735 title = g_strdup_printf(_("Conversations with %s"), name);
736 display_log_viewer(ht, logs, title, image, total_log_size);
737 g_free(title);
738 }
739
740 void pidgin_syslog_show()
741 {
742 GList *accounts = NULL;
743 GList *logs = NULL;
744
745 if (syslog_viewer != NULL) {
746 gtk_window_present(GTK_WINDOW(syslog_viewer->window));
747 return;
748 }
749
750 for(accounts = purple_accounts_get_all(); accounts != NULL; accounts = accounts->next) {
751
752 PurpleAccount *account = (PurpleAccount *)accounts->data;
753 if(purple_find_prpl(purple_account_get_protocol_id(account)) == NULL)
754 continue;
755
756 logs = g_list_concat(purple_log_get_system_logs(account), logs);
757 }
758 logs = g_list_sort(logs, purple_log_compare);
759
760 syslog_viewer = display_log_viewer(NULL, logs, _("System Log"), NULL, 0);
761 }
762
763 /****************************************************************************
764 * GTK+ LOG SUBSYSTEM *******************************************************
765 ****************************************************************************/
766
767 void *
768 pidgin_log_get_handle(void)
769 {
770 static int handle;
771
772 return &handle;
773 }
774
775 void pidgin_log_init(void)
776 {
777 void *handle = pidgin_log_get_handle();
778
779 purple_signal_register(handle, "log-displaying",
780 purple_marshal_VOID__POINTER_POINTER,
781 NULL, 2,
782 purple_value_new(PURPLE_TYPE_BOXED,
783 "PidginLogViewer *"),
784 purple_value_new(PURPLE_TYPE_SUBTYPE,
785 PURPLE_SUBTYPE_LOG));
786 }
787
788 void
789 pidgin_log_uninit(void)
790 {
791 purple_signals_unregister_by_instance(pidgin_log_get_handle());
792 }

Mercurial Repository: pidgin3

mercurial