static void pidgin_mini_dialog_set_property(GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { PidginMiniDialog *self = PIDGIN_MINI_DIALOG(object); PidginMiniDialogPrivate *priv = PIDGIN_MINI_DIALOG_GET_PRIVATE(self); switch (property_id) { case PROP_TITLE: mini_dialog_set_title(self, g_value_get_string(value)); break; case PROP_DESCRIPTION: mini_dialog_set_description(self, g_value_get_string(value)); break; case PROP_ICON_NAME: gtk_image_set_from_stock(priv->icon, g_value_get_string(value), gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_EXTRA_SMALL)); break; case PROP_CUSTOM_ICON: gtk_image_set_from_pixbuf(priv->icon, g_value_get_object(value)); break; case PROP_ENABLE_DESCRIPTION_MARKUP: priv->enable_description_markup = g_value_get_boolean(value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); } }
static GtkIconSize _new_size(Panel * panel, PanelPosition position) { GtkIconSize ret = GTK_ICON_SIZE_INVALID; char const * variable = NULL; char const * p = NULL; switch(position) { case PANEL_POSITION_BOTTOM: variable = "bottom_size"; break; case PANEL_POSITION_TOP: variable = "top_size"; break; } if(variable != NULL) p = config_get(panel->config, NULL, variable); if(p == NULL) p = config_get(panel->config, NULL, "size"); if(p != NULL) ret = gtk_icon_size_from_name(p); if(ret == GTK_ICON_SIZE_INVALID) ret = GTK_ICON_SIZE_SMALL_TOOLBAR; return ret; }
static PidginStatusIconTheme * create_icon_theme(GtkWidget *window) { int s, i, j; const char *dirname = g_get_tmp_dir(); PidginStatusIconTheme *theme; const char *author; #ifndef _WIN32 author = getlogin(); #else author = "user"; #endif theme = g_object_new(PIDGIN_TYPE_STATUS_ICON_THEME, "type", "status-icon", "author", author, "directory", dirname, NULL); for (s = 0; sections[s].heading; s++) { GtkWidget *vbox = g_object_get_data(G_OBJECT(window), sections[s].heading); for (i = 0; sections[s].options[i].stockid; i++) { GtkWidget *image = g_object_get_data(G_OBJECT(vbox), sections[s].options[i].stockid); GdkPixbuf *pixbuf = g_object_get_data(G_OBJECT(image), "pixbuf"); if (!pixbuf) continue; pidgin_icon_theme_set_icon(PIDGIN_ICON_THEME(theme), sections[s].options[i].stockid, sections[s].options[i].stockid); for (j = 0; stocksizes[j]; j++) { int width, height; GtkIconSize iconsize; char size[8]; char *name; GdkPixbuf *scale; GError *error = NULL; if (!(sections[s].flags & (1 << j))) continue; iconsize = gtk_icon_size_from_name(stocksizes[j]); gtk_icon_size_lookup(iconsize, &width, &height); g_snprintf(size, sizeof(size), "%d", width); if (i == 0) { name = g_build_filename(dirname, size, NULL); purple_build_dir(name, S_IRUSR | S_IWUSR | S_IXUSR); g_free(name); } name = g_build_filename(dirname, size, sections[s].options[i].stockid, NULL); scale = gdk_pixbuf_scale_simple(pixbuf, width, height, GDK_INTERP_BILINEAR); gdk_pixbuf_save(scale, name, "png", &error, "compression", "9", NULL); g_free(name); g_object_unref(G_OBJECT(scale)); if (error) g_error_free(error); } } } return theme; }
static void add_sized_icon(GtkIconSet *iconset, GtkIconSize sizeid, PidginIconTheme *theme, const char *size, SizedStockIcon sized_icon, gboolean translucent) { char *filename; GtkIconSource *source; GdkPixbuf *pixbuf; filename = find_icon_file(theme, size, sized_icon, FALSE); g_return_if_fail(filename != NULL); pixbuf = gdk_pixbuf_new_from_file(filename, NULL); if (translucent) do_alphashift(pixbuf, pixbuf); source = gtk_icon_source_new(); gtk_icon_source_set_pixbuf(source, pixbuf); gtk_icon_source_set_direction(source, GTK_TEXT_DIR_LTR); gtk_icon_source_set_direction_wildcarded(source, !sized_icon.rtl); gtk_icon_source_set_size(source, sizeid); gtk_icon_source_set_size_wildcarded(source, FALSE); gtk_icon_source_set_state_wildcarded(source, TRUE); gtk_icon_set_add_source(iconset, source); gtk_icon_source_free(source); if (sizeid == gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_EXTRA_SMALL)) { source = gtk_icon_source_new(); gtk_icon_source_set_pixbuf(source, pixbuf); gtk_icon_source_set_direction_wildcarded(source, TRUE); gtk_icon_source_set_size(source, GTK_ICON_SIZE_MENU); gtk_icon_source_set_size_wildcarded(source, FALSE); gtk_icon_source_set_state_wildcarded(source, TRUE); gtk_icon_set_add_source(iconset, source); gtk_icon_source_free(source); } g_free(filename); g_object_unref(pixbuf); if (sized_icon.rtl) { filename = find_icon_file(theme, size, sized_icon, TRUE); g_return_if_fail(filename != NULL); pixbuf = gdk_pixbuf_new_from_file(filename, NULL); if (translucent) do_alphashift(pixbuf, pixbuf); source = gtk_icon_source_new(); gtk_icon_source_set_pixbuf(source, pixbuf); gtk_icon_source_set_filename(source, filename); gtk_icon_source_set_direction(source, GTK_TEXT_DIR_RTL); gtk_icon_source_set_size(source, sizeid); gtk_icon_source_set_size_wildcarded(source, FALSE); gtk_icon_source_set_state_wildcarded(source, TRUE); gtk_icon_set_add_source(iconset, source); g_free(filename); g_object_unref(pixbuf); gtk_icon_source_free(source); } }
static GtkIconSize SvGtkIconSize (SV * sv) { GtkIconSize size; if (gperl_try_convert_enum (GTK_TYPE_ICON_SIZE, sv, (gint*)&size)) return size; /* fall back... */ return gtk_icon_size_from_name (SvPV_nolen (sv)); }
static void stock_icon_selected(const char *filename, gpointer image) { GError *error = NULL; GdkPixbuf *scale; int i; GdkPixbuf *pixbuf; if (!filename) return; pixbuf = gdk_pixbuf_new_from_file(filename, &error); if (error || !pixbuf) { purple_debug_error("theme-editor-icon", "Unable to load icon file '%s' (%s)\n", filename, error ? error->message : "Reason unknown"); if (error) g_error_free(error); return; } scale = gdk_pixbuf_scale_simple(pixbuf, 16, 16, GDK_INTERP_BILINEAR); gtk_image_set_from_pixbuf(GTK_IMAGE(image), scale); g_object_unref(G_OBJECT(scale)); /* Update the size previews */ for (i = 0; stocksizes[i]; i++) { int width, height; GtkIconSize iconsize; GtkWidget *prev = g_object_get_data(G_OBJECT(image), stocksizes[i]); if (!prev) continue; iconsize = gtk_icon_size_from_name(stocksizes[i]); gtk_icon_size_lookup(iconsize, &width, &height); scale = gdk_pixbuf_scale_simple(pixbuf, width, height, GDK_INTERP_BILINEAR); gtk_image_set_from_pixbuf(GTK_IMAGE(prev), scale); g_object_unref(G_OBJECT(scale)); } /* Save the original pixbuf so we can use it for resizing later */ g_object_set_data_full(G_OBJECT(image), "pixbuf", pixbuf, (GDestroyNotify)g_object_unref); }
static void buddy_ticker_set_pixmap(PurpleContact *c) { TickerData *td = buddy_ticker_find_contact(c); PurpleBuddy *buddy; PurplePresence *presence; const char *stock; if(!td) return; buddy = purple_contact_get_priority_buddy(c); presence = purple_buddy_get_presence(buddy); stock = pidgin_stock_id_from_presence(presence); if(!td->icon) { td->icon = gtk_image_new(); g_object_set(G_OBJECT(td->icon), "stock", stock, "icon-size", gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_MICROSCOPIC), NULL); } else { g_object_set(G_OBJECT(td->icon), "stock", stock, NULL); } }
static void from_stock (GtkSourcePixbufHelper *helper, GtkWidget *widget, gint size) { GtkIconSize icon_size; gchar *name; name = g_strdup_printf ("GtkSourcePixbufHelper%d", size); icon_size = gtk_icon_size_from_name (name); if (icon_size == GTK_ICON_SIZE_INVALID) { icon_size = gtk_icon_size_register (name, size, size); } g_free (name); set_cache (helper, gtk_widget_render_icon_pixbuf (widget, helper->stock_id, icon_size)); }
static void _new_prefs(Config * config, GdkScreen * screen, PanelPrefs * prefs, PanelPrefs const * user) { size_t i; gint width; gint height; char const * p; char * q; for(i = 0; i < sizeof(_panel_sizes) / sizeof(*_panel_sizes); i++) { if(gtk_icon_size_from_name(_panel_sizes[i].name) != GTK_ICON_SIZE_INVALID) continue; if(gtk_icon_size_lookup(_panel_sizes[i].iconsize, &width, &height) != TRUE) width = height = _panel_sizes[i].size; gtk_icon_size_register(_panel_sizes[i].name, width, height); } if(user != NULL) memcpy(prefs, user, sizeof(*prefs)); else { prefs->iconsize = PANEL_ICON_SIZE_DEFAULT; prefs->monitor = -1; } if((p = config_get(config, NULL, "monitor")) != NULL) { prefs->monitor = strtol(p, &q, 0); if(p[0] == '\0' || *q != '\0') prefs->monitor = -1; } #if GTK_CHECK_VERSION(2, 20, 0) if(prefs->monitor == -1) prefs->monitor = gdk_screen_get_primary_monitor(screen); #endif }
static void menu_style_set_cb (GtkWidget *menu, GtkStyle *old_style, ShellStatusMenu *status) { ShellStatusMenuPrivate *priv = status->priv; GtkSettings *settings; int width; int height; priv->icon_size = gtk_icon_size_from_name ("panel-menu"); if (priv->icon_size == GTK_ICON_SIZE_INVALID) priv->icon_size = gtk_icon_size_register ("panel-menu", 24, 24); if (gtk_widget_has_screen (menu)) settings = gtk_settings_get_for_screen (gtk_widget_get_screen (menu)); else settings = gtk_settings_get_default (); if (!gtk_icon_size_lookup_for_settings (settings, priv->icon_size, &width, &height)) priv->pixel_size = -1; else priv->pixel_size = MAX(width, height); }
static void * pidgin_notify_emails(PurpleConnection *gc, size_t count, gboolean detailed, const char **subjects, const char **froms, const char **tos, const char **urls) { GtkWidget *dialog = NULL; char *notification; PurpleAccount *account; PidginNotifyMailData *data = NULL, *data2; gboolean new_data; /* Don't bother updating if there aren't new emails and we don't have any displayed currently */ if (count == 0 && mail_dialog == NULL) return NULL; account = purple_connection_get_account(gc); dialog = pidgin_get_mail_dialog(); /* This creates mail_dialog if necessary */ mail_dialog->total_count += count; if (detailed) { while (count--) { char *to_text = NULL; char *from_text = NULL; char *subject_text = NULL; char *tmp; gboolean first = TRUE; if (tos != NULL) { tmp = g_markup_escape_text(*tos, -1); to_text = g_strdup_printf("<b>%s</b>: %s\n", _("Account"), tmp); g_free(tmp); first = FALSE; tos++; } if (froms != NULL) { tmp = g_markup_escape_text(*froms, -1); from_text = g_strdup_printf("%s<b>%s</b>: %s\n", first ? "<br>" : "", _("Sender"), tmp); g_free(tmp); first = FALSE; froms++; } if (subjects != NULL) { tmp = g_markup_escape_text(*subjects, -1); subject_text = g_strdup_printf("%s<b>%s</b>: %s", first ? "<br>" : "", _("Subject"), tmp); g_free(tmp); first = FALSE; subjects++; } #define SAFE(x) ((x) ? (x) : "") notification = g_strdup_printf("%s%s%s", SAFE(to_text), SAFE(from_text), SAFE(subject_text)); #undef SAFE g_free(to_text); g_free(from_text); g_free(subject_text); /* If we don't keep track of this, will leak "data" for each of the notifications except the last */ data2 = pidgin_notify_add_mail(mail_dialog->treemodel, account, notification, urls ? *urls : NULL, 0, FALSE, &new_data); if (new_data) { if (data) data->purple_has_handle = FALSE; data = data2; } g_free(notification); if (urls != NULL) urls++; } } else { if (count > 0) { notification = g_strdup_printf(ngettext("%s has %d new message.", "%s has %d new messages.", (int)count), *tos, (int)count); data2 = pidgin_notify_add_mail(mail_dialog->treemodel, account, notification, urls ? *urls : NULL, count, FALSE, &new_data); if (new_data) { if (data) data->purple_has_handle = FALSE; data = data2; } g_free(notification); } else { GtkTreeIter iter; /* Clear out all mails for the account */ pidgin_notify_add_mail(mail_dialog->treemodel, account, NULL, NULL, 0, TRUE, NULL); if (!gtk_tree_model_get_iter_first(GTK_TREE_MODEL(mail_dialog->treemodel), &iter)) { /* There is no API to clear the headline specifically */ /* This will trigger reset_mail_dialog() */ pidgin_blist_set_headline(NULL, NULL, NULL, NULL, NULL); return NULL; } } } if (!GTK_WIDGET_VISIBLE(dialog)) { GdkPixbuf *pixbuf = gtk_widget_render_icon(dialog, PIDGIN_STOCK_DIALOG_MAIL, gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_EXTRA_SMALL), NULL); char *label_text = g_strdup_printf(ngettext("<b>%d new email.</b>", "<b>%d new emails.</b>", mail_dialog->total_count), mail_dialog->total_count); mail_dialog->in_use = TRUE; /* So that _set_headline doesn't accidentally remove the notifications when replacing an old notification. */ pidgin_blist_set_headline(label_text, pixbuf, G_CALLBACK(gtk_widget_show_all), dialog, (GDestroyNotify)reset_mail_dialog); mail_dialog->in_use = FALSE; g_free(label_text); if (pixbuf) g_object_unref(pixbuf); } else if (!GTK_WIDGET_HAS_FOCUS(dialog)) pidgin_set_urgent(GTK_WINDOW(dialog), TRUE); return data; }
/* part stolen from pidgin/gtkconv.c */ static GtkWidget * capture_rename (PurplePlugin * plugin, const gchar * entry_init) { GdkColor red = { 0, 65535, 0, 0 }; GtkWidget *dlgbox_rename; GtkWidget *hbox; GtkWidget *label; GtkWidget *entry; GtkWidget *warn_label; GtkWidget *gtkconv_window; GtkWidget *blist_window; GtkWidget *img; GtkWidget *content_area; img = gtk_image_new_from_stock (PIDGIN_STOCK_DIALOG_QUESTION, gtk_icon_size_from_name (PIDGIN_ICON_SIZE_TANGO_HUGE)); gtkconv_window = get_receiver_window (plugin); blist_window = pidgin_blist_get_default_gtk_blist ()->window; dlgbox_rename = gtk_dialog_new_with_buttons (DLGBOX_CAPNAME_TITLE, GTK_WINDOW ((gtkconv_window) ? gtkconv_window : blist_window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); #if GTK_CHECK_VERSION(2,14,0) content_area = gtk_dialog_get_content_area (GTK_DIALOG (dlgbox_rename)); #else content_area = GTK_DIALOG (dlgbox_rename)->vbox; #endif gtk_dialog_set_default_response (GTK_DIALOG (dlgbox_rename), GTK_RESPONSE_OK); gtk_container_set_border_width (GTK_CONTAINER (dlgbox_rename), PIDGIN_HIG_BOX_SPACE); gtk_window_set_resizable (GTK_WINDOW (dlgbox_rename), FALSE); gtk_dialog_set_has_separator (GTK_DIALOG (dlgbox_rename), FALSE); gtk_box_set_spacing (GTK_BOX (content_area), PIDGIN_HIG_BORDER); gtk_container_set_border_width (GTK_CONTAINER (content_area), PIDGIN_HIG_BOX_SPACE); hbox = gtk_hbox_new (FALSE, PIDGIN_HIG_BORDER); gtk_container_add (GTK_CONTAINER (content_area), hbox); gtk_box_pack_start (GTK_BOX (hbox), img, FALSE, FALSE, 0); gtk_misc_set_alignment (GTK_MISC (img), 0, 0); label = gtk_label_new (DLGBOX_CAPNAME_LABEL); warn_label = gtk_label_new (NULL); gtk_widget_modify_fg (warn_label, GTK_STATE_NORMAL, &red); gtk_label_set_text (GTK_LABEL (warn_label), DLGBOX_CAPNAME_WARNEXISTS); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (content_area), warn_label, FALSE, FALSE, 0); entry = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (entry), entry_init); gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE); g_object_set (gtk_widget_get_settings (entry), "gtk-entry-select-on-focus", FALSE, NULL); g_signal_connect (G_OBJECT (entry), "changed", G_CALLBACK (set_sensitive_if_input_and_noexist), dlgbox_rename /* plugin */ ); g_signal_connect (G_OBJECT (entry), "focus-out-event", G_CALLBACK (entry_select_filename_in_focus_cb), plugin); g_signal_connect (G_OBJECT (entry), "focus-in-event", G_CALLBACK (entry_select_filename_in_focus_cb), plugin); gtk_box_pack_start (GTK_BOX (hbox), entry, FALSE, FALSE, 0); gtk_widget_show (label); gtk_widget_show (entry); gtk_widget_show (img); gtk_widget_show (hbox); gtk_widget_show (content_area); g_object_set_data (G_OBJECT (dlgbox_rename), "entry", entry); g_object_set_data (G_OBJECT (dlgbox_rename), "warn-label", warn_label); return dlgbox_rename; }
void show_countdown_dialog (PurplePlugin * plugin) { GtkWidget *content_area; GtkWidget *img; GtkWidget *hbox, *vbox; GtkWidget *progress_bar; GtkWidget *gtkconv_window; GtkWidget *blist_window; GtkWidget *label = NULL; g_assert (plugin != NULL && plugin->extra != NULL); g_assert (PLUGIN (countdown_dialog) == NULL); progress_bar = gtk_progress_bar_new (); img = gtk_image_new_from_stock (PIDGIN_STOCK_INFO, gtk_icon_size_from_name (PIDGIN_ICON_SIZE_TANGO_SMALL)); hbox = gtk_hbox_new (FALSE, PIDGIN_HIG_BOX_SPACE); vbox = gtk_vbox_new (FALSE, PIDGIN_HIG_BOX_SPACE); gtkconv_window = get_receiver_window (plugin); blist_window = pidgin_blist_get_default_gtk_blist ()->window; PLUGIN (countdown_dialog) = gtk_dialog_new_with_buttons (PLUGIN_NAME, GTK_WINDOW ((gtkconv_window) ? gtkconv_window : blist_window), 0, GTK_STOCK_EXECUTE, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL); gtk_window_set_resizable (GTK_WINDOW (PLUGIN (countdown_dialog)), FALSE); gtk_progress_bar_set_pulse_step (GTK_PROGRESS_BAR (progress_bar), 0.05); g_object_set_data (G_OBJECT (PLUGIN (countdown_dialog)), "progress-bar", progress_bar); label = gtk_label_new (COUNTDOWN_MSG); gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress_bar), 0); #if GTK_CHECK_VERSION (2,14,0) content_area = gtk_dialog_get_content_area (GTK_DIALOG (PLUGIN (countdown_dialog))); #else content_area = (GTK_DIALOG (PLUGIN (countdown_dialog)))->vbox; #endif gtk_window_set_deletable (GTK_WINDOW (PLUGIN (countdown_dialog)), FALSE); gtk_box_pack_start (GTK_BOX (content_area), vbox, FALSE, FALSE, 0); gtk_box_pack_start_defaults (GTK_BOX (vbox), hbox); gtk_box_pack_start (GTK_BOX (hbox), img, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), progress_bar, FALSE, FALSE, 0); gtk_widget_show_all (PLUGIN (countdown_dialog)); purple_timeout_add (250, (GSourceFunc) update_countdown, plugin); g_signal_connect_swapped (G_OBJECT (PLUGIN (countdown_dialog)), "response", G_CALLBACK (on_countdown_dialog_response_cb), plugin); }
void pidgin_icon_theme_edit(PurplePluginAction *unused) { GtkWidget *dialog; GtkWidget *box, *vbox; GtkWidget *notebook; GtkSizeGroup *sizegroup; int s, i, j; dialog = pidgin_create_dialog(_("Pidgin Icon Theme Editor"), 0, "theme-editor-icon", FALSE); box = pidgin_dialog_get_vbox_with_properties(GTK_DIALOG(dialog), FALSE, PIDGIN_HIG_BOX_SPACE); notebook = gtk_notebook_new(); gtk_box_pack_start(GTK_BOX(box), notebook, TRUE, TRUE, PIDGIN_HIG_BOX_SPACE); sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); for (s = 0; sections[s].heading; s++) { const char *heading = sections[s].heading; box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), box, gtk_label_new(heading)); vbox = pidgin_make_frame(box, heading); g_object_set_data(G_OBJECT(dialog), heading, vbox); for (i = 0; sections[s].options[i].stockid; i++) { const char *id = sections[s].options[i].stockid; const char *text = _(sections[s].options[i].text); GtkWidget *hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_CAT_SPACE); GtkWidget *label = gtk_label_new(text); GtkWidget *image = gtk_image_new_from_stock(id, gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_EXTRA_SMALL)); GtkWidget *ebox = gtk_event_box_new(); gtk_container_add(GTK_CONTAINER(ebox), image); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); g_signal_connect(G_OBJECT(ebox), "button-press-event", G_CALLBACK(change_stock_image), image); g_object_set_data(G_OBJECT(image), "property-name", (gpointer)id); g_object_set_data(G_OBJECT(image), "localized-name", (gpointer)text); gtk_size_group_add_widget(sizegroup, label); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), ebox, FALSE, FALSE, 0); for (j = 0; stocksizes[j]; j++) { GtkWidget *sh; if (!(sections[s].flags & (1 << j))) continue; sh = gtk_image_new_from_stock(id, gtk_icon_size_from_name(stocksizes[j])); gtk_box_pack_start(GTK_BOX(hbox), sh, FALSE, FALSE, 0); g_object_set_data(G_OBJECT(image), stocksizes[j], sh); } gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); g_object_set_data(G_OBJECT(vbox), id, image); } } #ifdef NOT_SADRUL pidgin_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_SAVE, G_CALLBACK(save_icon_theme), dialog); #endif pidgin_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_APPLY, G_CALLBACK(use_icon_theme), dialog); pidgin_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CLOSE, G_CALLBACK(close_icon_theme), dialog); gtk_widget_show_all(dialog); g_object_unref(sizegroup); }
void pidgin_log_show_contact(PurpleContact *contact) { struct log_viewer_hash_t *ht; PurpleBlistNode *child; PidginLogViewer *lv = NULL; GList *logs = NULL; GdkPixbuf *pixbuf; GtkWidget *image; const char *name = NULL; char *title; int total_log_size = 0; g_return_if_fail(contact != NULL); ht = g_new0(struct log_viewer_hash_t, 1); ht->type = PURPLE_LOG_IM; ht->contact = contact; if (log_viewers == NULL) { log_viewers = g_hash_table_new(log_viewer_hash, log_viewer_equal); } else if ((lv = g_hash_table_lookup(log_viewers, ht))) { gtk_window_present(GTK_WINDOW(lv->window)); g_free(ht); return; } for (child = contact->node.child ; child ; child = child->next) { if (!PURPLE_BLIST_NODE_IS_BUDDY(child)) continue; logs = g_list_concat(purple_log_get_logs(PURPLE_LOG_IM, ((PurpleBuddy *)child)->name, ((PurpleBuddy *)child)->account), logs); total_log_size += purple_log_get_total_size(PURPLE_LOG_IM, ((PurpleBuddy *)child)->name, ((PurpleBuddy *)child)->account); } logs = g_list_sort(logs, purple_log_compare); image = gtk_image_new(); pixbuf = gtk_widget_render_icon(image, PIDGIN_STOCK_STATUS_PERSON, gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_SMALL), "GtkWindow"); if (pixbuf) { gtk_image_set_from_pixbuf(GTK_IMAGE(image), pixbuf); g_object_unref(pixbuf); } else { gtk_widget_destroy(image); image = NULL; } if (contact->alias != NULL) name = contact->alias; else if (contact->priority != NULL) name = purple_buddy_get_contact_alias(contact->priority); /* This will happen if the contact doesn't have an alias, * and none of the contact's buddies are online. * There is probably a better way to deal with this. */ if (name == NULL) { if (contact->node.child != NULL && PURPLE_BLIST_NODE_IS_BUDDY(contact->node.child)) name = purple_buddy_get_contact_alias((PurpleBuddy *) contact->node.child); if (name == NULL) name = ""; } title = g_strdup_printf(_("Conversations with %s"), name); display_log_viewer(ht, logs, title, image, total_log_size); g_free(title); }
void show_login() { GtkWidget *image; GtkWidget *hbox_toplevel; GtkWidget *vbox; GtkWidget *button; GtkWidget *hbox; GtkWidget *label; GtkWidget *vbox2; GtkWidget *table; #ifdef GAIM_SMALL_SCREEN #ifdef ENABLE_HILDON GtkWidget *hbox1; GtkWidget *vbox1; #endif GtkWidget *hseparator; #endif /* Do we already have a main window opened? If so, bring it back, baby... ribs... yeah */ #ifdef ENABLE_HILDON if (login_app_view) { hildon_app_set_appview(HILDON_APP(app), HILDON_APPVIEW(login_app_view)); g_object_unref(login_app_view); return; } mainwindow = current_app_view = login_app_view = hildon_appview_new(_("Login")); hildon_app_set_appview(HILDON_APP(app), HILDON_APPVIEW(login_app_view)); hbox_toplevel = gtk_hbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(login_app_view), hbox_toplevel); g_signal_connect(G_OBJECT(login_app_view), "delete_event", G_CALLBACK(login_window_closed), login_app_view); #else if (mainwindow) { gtk_window_present(GTK_WINDOW(mainwindow)); return; } #ifdef GAIM_SMALL_SCREEN mainwindow = gtk_dialog_new(); gtk_window_set_modal(GTK_WINDOW(mainwindow), TRUE); gtk_dialog_set_has_separator(mainwindow, FALSE); #else mainwindow = gtk_window_new(GTK_WINDOW_TOPLEVEL); #endif gtk_window_set_role(GTK_WINDOW(mainwindow), "login"); gtk_window_set_resizable(GTK_WINDOW(mainwindow), FALSE); gtk_window_set_title(GTK_WINDOW(mainwindow), _("Login")); gtk_container_set_border_width(GTK_CONTAINER(mainwindow), 5); g_signal_connect(G_OBJECT(mainwindow), "delete_event", G_CALLBACK(login_window_closed), mainwindow); hbox_toplevel = gtk_hbox_new(FALSE, 0); #ifdef GAIM_SMALL_SCREEN gtk_container_add(GTK_CONTAINER(GTK_DIALOG(mainwindow)->vbox), hbox_toplevel); #else gtk_container_add(GTK_CONTAINER(mainwindow), hbox_toplevel); #endif #endif vbox_toplevel = vbox = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox_toplevel), vbox, FALSE, FALSE, BOX_SPACING); #ifdef GAIM_SMALL_SCREEN /* Now for the button box */ hbox = gtk_hbox_new(FALSE, 0); #ifdef ENABLE_HILDON hbox1 = gtk_hbox_new(FALSE, BOX_SPACING); vbox1 = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox1, TRUE, FALSE, 0); gtk_box_pack_end(GTK_BOX(hbox1), vbox1, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox1), hbox, FALSE, FALSE, 0); vbox = vbox1; #else gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); #endif /* lets put the image also in the hbox */ image = gtk_image_new_from_stock(GAIM_STOCK_LOGO, gtk_icon_size_from_name(GAIM_ICON_SIZE_LOGO)); #ifdef ENABLE_HILDON gtk_box_pack_start(GTK_BOX(hbox1), image, FALSE, FALSE, 0); #else gtk_box_pack_start(GTK_BOX(hbox), image, FALSE, FALSE, 0); #endif /* And now for the buttons */ button = gaim_pixbuf_button_from_stock(_("A_ccounts"), GAIM_STOCK_ACCOUNTS, GAIM_BUTTON_VERTICAL); gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(gaim_gtk_accounts_window_show), mainwindow); gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0); button = gaim_pixbuf_button_from_stock(_("P_references"), GTK_STOCK_PREFERENCES, GAIM_BUTTON_VERTICAL); gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(gaim_gtk_prefs_show), mainwindow); gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0); button = gaim_pixbuf_button_from_stock(_("_Sign on"), GAIM_STOCK_SIGN_ON, GAIM_BUTTON_VERTICAL); gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(dologin), mainwindow); g_signal_connect(G_OBJECT(button), "button-press-event", G_CALLBACK(domiddleclick), NULL); gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_box_pack_start (GTK_BOX (vbox), hseparator, FALSE, TRUE, 2); #else image = gtk_image_new_from_stock(GAIM_STOCK_LOGO, gtk_icon_size_from_name(GAIM_ICON_SIZE_LOGO)); gtk_box_pack_start(GTK_BOX(vbox), image, FALSE, FALSE, 0); #endif table = gtk_table_new (2, 2, FALSE); gtk_widget_show (table); gtk_box_pack_start (GTK_BOX (vbox), table, TRUE, TRUE, 0); gtk_table_set_row_spacings (GTK_TABLE (table), 2); gtk_table_set_col_spacings (GTK_TABLE (table), 2); /* why isn't there a gtk_label_new_with_markup? */ label = gtk_label_new(NULL); gtk_widget_show (label); gtk_label_set_markup_with_mnemonic(GTK_LABEL(label), _("<b>_Account:</b>")); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); name = gaim_gtk_account_option_menu_new(NULL, TRUE, G_CALLBACK(combo_changed), NULL, NULL); gtk_label_set_mnemonic_widget(GTK_LABEL(label), name); gtk_widget_show (name); gtk_table_attach (GTK_TABLE (table), name, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); label = gtk_label_new(NULL); gtk_widget_show (label); gtk_label_set_markup_with_mnemonic(GTK_LABEL(label), _("<b>_Password:</b>")); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); pass = gtk_entry_new(); gtk_label_set_mnemonic_widget(GTK_LABEL(label), pass); gtk_entry_set_visibility(GTK_ENTRY(pass), FALSE); gtk_table_attach (GTK_TABLE (table), pass, 1, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); #ifndef GAIM_SMALL_SCREEN g_signal_connect(G_OBJECT(pass), "activate", G_CALLBACK(dologin), mainwindow); /* gtk_box_pack_start(GTK_BOX(vbox2), pass, FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), vbox2, FALSE, TRUE, 0); */ /* Now for the button box */ hbox = gtk_hbox_new(TRUE, 0); /* gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 5); */ gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5); /* And now for the buttons */ button = gaim_pixbuf_button_from_stock(_("A_ccounts"), GAIM_STOCK_ACCOUNTS, GAIM_BUTTON_VERTICAL); gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(gaim_gtk_accounts_window_show), mainwindow); gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0); button = gaim_pixbuf_button_from_stock(_("P_references"), GTK_STOCK_PREFERENCES, GAIM_BUTTON_VERTICAL); gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(gaim_gtk_prefs_show), mainwindow); gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0); button = gaim_pixbuf_button_from_stock(_("_Sign on"), GAIM_STOCK_SIGN_ON, GAIM_BUTTON_VERTICAL); gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(dologin), mainwindow); g_signal_connect(G_OBJECT(button), "button-press-event", G_CALLBACK(domiddleclick), NULL); gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0); #endif /* Now grab the focus that we need */ if (gaim_accounts_get_all()) { GaimAccount *account = gaim_accounts_get_all()->data; if (gaim_account_get_remember_password(account)) { combo_changed(NULL, account, NULL); gtk_widget_grab_focus(button); } else { gtk_widget_grab_focus(pass); } } else { gaim_gtk_accounts_window_show(); gtk_widget_grab_focus(button); } #ifndef ENABLE_HILDON /* And raise the curtain! */ gtk_widget_show_all(mainwindow); #else gtk_widget_show_all(login_app_view); #endif }
static void nemo_status_bar_constructed (GObject *object) { NemoStatusBar *bar = NEMO_STATUS_BAR (object); G_OBJECT_CLASS (nemo_status_bar_parent_class)->constructed (object); GtkToolbar *toolbar; GtkWidget *widget_box; GtkToolItem *item; GtkWidget *statusbar = gtk_statusbar_new (); GtkActionGroup *action_group; GtkStyleContext *context; bar->real_statusbar = statusbar; GtkIconSize size = gtk_icon_size_from_name (NEMO_STATUSBAR_ICON_SIZE_NAME); context = gtk_widget_get_style_context (GTK_WIDGET (bar)); gtk_style_context_add_class (context, GTK_STYLE_CLASS_TOOLBAR); gtk_container_set_border_width (GTK_CONTAINER (bar), 1); GtkWidget *button, *icon; button = gtk_toggle_button_new (); icon = gtk_image_new_from_icon_name ("sidebar-places-symbolic", size); gtk_button_set_image (GTK_BUTTON (button), icon); gtk_widget_set_tooltip_text (GTK_WIDGET (button), _("Show Places")); bar->places_button = button; gtk_box_pack_start (GTK_BOX (bar), button, FALSE, FALSE, 2); g_signal_connect (GTK_BUTTON (button), "clicked", G_CALLBACK (action_places_toggle_callback), bar); button = gtk_toggle_button_new (); icon = gtk_image_new_from_icon_name ("sidebar-tree-symbolic", size); gtk_button_set_image (GTK_BUTTON (button), icon); gtk_widget_set_tooltip_text (GTK_WIDGET (button), _("Show Treeview")); bar->tree_button = button; gtk_box_pack_start (GTK_BOX (bar), button, FALSE, FALSE, 2); g_signal_connect (GTK_BUTTON (button), "clicked", G_CALLBACK (action_treeview_toggle_callback), bar); GtkWidget *sep = gtk_separator_new (GTK_ORIENTATION_VERTICAL); gtk_box_pack_start (GTK_BOX (bar), sep, FALSE, FALSE, 6); gtk_widget_show (sep); bar->separator = sep; button = gtk_button_new (); icon = gtk_image_new_from_icon_name ("sidebar-hide-symbolic", size); gtk_button_set_image (GTK_BUTTON (button), icon); gtk_widget_set_tooltip_text (GTK_WIDGET (button), _("Hide the Sidebar (F9)")); bar->hide_button = button; gtk_box_pack_start (GTK_BOX (bar), button, FALSE, FALSE, 2); g_signal_connect (GTK_BUTTON (button), "clicked", G_CALLBACK (action_hide_sidebar_callback), bar); button = gtk_button_new (); icon = gtk_image_new_from_icon_name ("sidebar-show-symbolic", size); gtk_button_set_image (GTK_BUTTON (button), icon); gtk_widget_set_tooltip_text (GTK_WIDGET (button), _("Show the Sidebar (F9)")); bar->show_button = button; gtk_box_pack_start (GTK_BOX (bar), button, FALSE, FALSE, 2); g_signal_connect (GTK_BUTTON (button), "clicked", G_CALLBACK (action_show_sidebar_callback), bar); gtk_box_pack_start (GTK_BOX (bar), statusbar, TRUE, TRUE, 10); GtkWidget *zoom_slider = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 6.0, 1.0); gtk_widget_set_tooltip_text (GTK_WIDGET (zoom_slider), _("Adjust zoom level")); bar->zoom_slider = zoom_slider; gtk_box_pack_start (GTK_BOX (bar), zoom_slider, FALSE, FALSE, 2); gtk_widget_set_size_request (GTK_WIDGET (zoom_slider), SLIDER_WIDTH, 0); gtk_scale_set_draw_value (GTK_SCALE (zoom_slider), FALSE); gtk_range_set_increments (GTK_RANGE (zoom_slider), 1.0, 1.0); gtk_range_set_round_digits (GTK_RANGE (zoom_slider), 0); gtk_widget_show_all (GTK_WIDGET (bar)); g_signal_connect_object (NEMO_WINDOW (bar->window), "notify::show-sidebar", G_CALLBACK (sidebar_state_changed_cb), bar, G_CONNECT_AFTER); g_signal_connect_object (NEMO_WINDOW (bar->window), "notify::sidebar-view-id", G_CALLBACK (sidebar_type_changed_cb), bar, G_CONNECT_AFTER); g_signal_connect (GTK_RANGE (zoom_slider), "value-changed", G_CALLBACK (on_slider_changed_cb), bar); GtkWidget *cont = gtk_statusbar_get_message_area (GTK_STATUSBAR (statusbar)); GList *children = gtk_container_get_children (GTK_CONTAINER (cont)); gtk_box_set_child_packing (GTK_BOX (cont), GTK_WIDGET (children->data), TRUE, FALSE, 10, GTK_PACK_START); nemo_status_bar_sync_button_states (bar); }
Panel * panel_new(PanelPrefs const * prefs) { Panel * panel; GdkRectangle rect; GtkIconSize iconsize; char const * p; gboolean focus; gboolean above; if((panel = object_new(sizeof(*panel))) == NULL) return NULL; panel->screen = gdk_screen_get_default(); if(_new_config(panel) == 0) _new_prefs(panel->config, panel->screen, &panel->prefs, prefs); panel->top_helper.panel = panel; panel->top_helper.type = PANEL_APPLET_TYPE_NORMAL; panel->top_helper.icon_size = GTK_ICON_SIZE_LARGE_TOOLBAR; panel->top_helper.config_get = _panel_helper_config_get; panel->top_helper.config_set = _panel_helper_config_set; panel->top_helper.error = _panel_helper_error; panel->top_helper.about_dialog = _panel_helper_about_dialog; panel->top_helper.lock = _panel_helper_lock; #ifndef EMBEDDED panel->top_helper.logout_dialog = _panel_helper_logout_dialog; #else panel->top_helper.logout_dialog = NULL; #endif panel->top_helper.position_menu = _panel_helper_position_menu_top; panel->top_helper.preferences_dialog = _panel_helper_preferences_dialog; panel->top_helper.rotate_screen = _panel_helper_rotate_screen; panel->top_helper.shutdown_dialog = _panel_helper_shutdown_dialog; panel->top_helper.suspend = (_panel_can_suspend()) ? _panel_helper_suspend : NULL; panel->top = NULL; panel->bottom_helper = panel->top_helper; panel->bottom_helper.position_menu = _panel_helper_position_menu_bottom; panel->bottom = NULL; iconsize = GTK_ICON_SIZE_INVALID; if(panel->prefs.iconsize != NULL) iconsize = gtk_icon_size_from_name(panel->prefs.iconsize); if(iconsize == GTK_ICON_SIZE_INVALID) { panel->top_helper.icon_size = _new_size(panel, PANEL_POSITION_TOP); panel->bottom_helper.icon_size = _new_size(panel, PANEL_POSITION_BOTTOM); } else { panel->top_helper.icon_size = iconsize; panel->bottom_helper.icon_size = iconsize; } panel->pr_window = NULL; panel->ab_window = NULL; #ifndef EMBEDDED panel->lo_window = NULL; #endif panel->sh_window = NULL; if(panel->config == NULL) { panel_error(NULL, error_get(), 0); /* XXX put up a dialog box */ panel_delete(panel); return NULL; } /* root window */ panel->root = gdk_screen_get_root_window(panel->screen); _panel_reset(panel, &rect); focus = ((p = config_get(panel->config, NULL, "accept_focus")) == NULL || strcmp(p, "1") == 0) ? TRUE : FALSE; above = ((p = config_get(panel->config, NULL, "keep_above")) == NULL || strcmp(p, "1") == 0) ? TRUE : FALSE; panel->source = 0; /* top panel */ if(config_get(panel->config, NULL, "top") != NULL) { panel->top = panel_window_new(PANEL_POSITION_TOP, &panel->top_helper, &rect); panel_window_set_accept_focus(panel->top, focus); panel_window_set_keep_above(panel->top, above); } /* bottom panel */ if(config_get(panel->config, NULL, "bottom") != NULL || config_get(panel->config, NULL, "top") == NULL) { panel->bottom = panel_window_new(PANEL_POSITION_BOTTOM, &panel->bottom_helper, &rect); panel_window_set_accept_focus(panel->bottom, focus); panel_window_set_keep_above(panel->bottom, above); } /* messages */ desktop_message_register(PANEL_CLIENT_MESSAGE, _new_on_message, panel); /* manage root window events */ gdk_window_set_events(panel->root, gdk_window_get_events( panel->root) | GDK_PROPERTY_CHANGE_MASK); gdk_window_add_filter(panel->root, _on_root_event, panel); /* load plug-ins when idle */ panel->source = g_idle_add(_on_idle, panel); return panel; }
static void * pidgin_notify_message(PurpleNotifyMsgType type, const char *title, const char *primary, const char *secondary) { GtkWidget *dialog; GtkWidget *hbox; GtkWidget *label; GtkWidget *img = NULL; char label_text[2048]; const char *icon_name = NULL; char *primary_esc, *secondary_esc; switch (type) { case PURPLE_NOTIFY_MSG_ERROR: icon_name = PIDGIN_STOCK_DIALOG_ERROR; break; case PURPLE_NOTIFY_MSG_WARNING: icon_name = PIDGIN_STOCK_DIALOG_WARNING; break; case PURPLE_NOTIFY_MSG_INFO: icon_name = PIDGIN_STOCK_DIALOG_INFO; break; default: icon_name = NULL; break; } if (icon_name != NULL) { img = gtk_image_new_from_stock(icon_name, gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_HUGE)); gtk_misc_set_alignment(GTK_MISC(img), 0, 0); } dialog = gtk_dialog_new_with_buttons(title ? title : PIDGIN_ALERT_TITLE, NULL, 0, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); gtk_window_set_role(GTK_WINDOW(dialog), "notify_dialog"); g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(message_response_cb), dialog); gtk_container_set_border_width(GTK_CONTAINER(dialog), PIDGIN_HIG_BORDER); gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE); gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE); gtk_box_set_spacing(GTK_BOX(GTK_DIALOG(dialog)->vbox), PIDGIN_HIG_BORDER); gtk_container_set_border_width(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), PIDGIN_HIG_BOX_SPACE); hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BORDER); gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), hbox); if (img != NULL) gtk_box_pack_start(GTK_BOX(hbox), img, FALSE, FALSE, 0); primary_esc = g_markup_escape_text(primary, -1); secondary_esc = (secondary != NULL) ? g_markup_escape_text(secondary, -1) : NULL; g_snprintf(label_text, sizeof(label_text), "<span weight=\"bold\" size=\"larger\">%s</span>%s%s", primary_esc, (secondary ? "\n\n" : ""), (secondary ? secondary_esc : "")); g_free(primary_esc); g_free(secondary_esc); label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(label), label_text); gtk_label_set_line_wrap(GTK_LABEL(label), TRUE); gtk_label_set_selectable(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); pidgin_auto_parent_window(dialog); gtk_widget_show_all(dialog); return dialog; }
static void pidgin_media_ready_cb(PurpleMedia *media, PidginMedia *gtkmedia, const gchar *sid) { GtkWidget *send_widget = NULL, *recv_widget = NULL, *button_widget = NULL; PurpleMediaSessionType type = purple_media_get_session_type(media, sid); GdkPixbuf *icon = NULL; if (gtkmedia->priv->recv_widget == NULL && type & (PURPLE_MEDIA_RECV_VIDEO | PURPLE_MEDIA_RECV_AUDIO)) { recv_widget = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE); gtk_box_pack_start(GTK_BOX(gtkmedia->priv->display), recv_widget, TRUE, TRUE, 0); gtk_widget_show(recv_widget); } else { recv_widget = gtkmedia->priv->recv_widget; } if (gtkmedia->priv->send_widget == NULL && type & (PURPLE_MEDIA_SEND_VIDEO | PURPLE_MEDIA_SEND_AUDIO)) { send_widget = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE); gtk_box_pack_start(GTK_BOX(gtkmedia->priv->display), send_widget, FALSE, TRUE, 0); button_widget = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE); gtk_box_pack_end(GTK_BOX(recv_widget), button_widget, FALSE, TRUE, 0); gtk_widget_show(send_widget); /* Hold button */ gtkmedia->priv->hold = gtk_toggle_button_new_with_mnemonic("_Hold"); gtk_box_pack_end(GTK_BOX(button_widget), gtkmedia->priv->hold, FALSE, FALSE, 0); gtk_widget_show(gtkmedia->priv->hold); g_signal_connect(gtkmedia->priv->hold, "toggled", G_CALLBACK(pidgin_media_hold_toggled), gtkmedia); } else { send_widget = gtkmedia->priv->send_widget; button_widget = gtkmedia->priv->button_widget; } if (type & PURPLE_MEDIA_RECV_VIDEO) { PidginMediaRealizeData *data; GtkWidget *aspect; GtkWidget *remote_video; GdkColor color = {0, 0, 0, 0}; aspect = gtk_aspect_frame_new(NULL, 0, 0, 4.0/3.0, FALSE); gtk_frame_set_shadow_type(GTK_FRAME(aspect), GTK_SHADOW_IN); gtk_box_pack_start(GTK_BOX(recv_widget), aspect, TRUE, TRUE, 0); data = g_new0(PidginMediaRealizeData, 1); data->gtkmedia = gtkmedia; data->session_id = g_strdup(sid); data->participant = g_strdup(gtkmedia->priv->screenname); remote_video = gtk_drawing_area_new(); gtk_widget_modify_bg(remote_video, GTK_STATE_NORMAL, &color); g_signal_connect(G_OBJECT(remote_video), "realize", G_CALLBACK(realize_cb), data); gtk_container_add(GTK_CONTAINER(aspect), remote_video); gtk_widget_set_size_request (GTK_WIDGET(remote_video), 320, 240); gtk_widget_show(remote_video); gtk_widget_show(aspect); gtkmedia->priv->remote_video = remote_video; } if (type & PURPLE_MEDIA_SEND_VIDEO) { PidginMediaRealizeData *data; GtkWidget *aspect; GtkWidget *local_video; GdkColor color = {0, 0, 0, 0}; aspect = gtk_aspect_frame_new(NULL, 0, 0, 4.0/3.0, TRUE); gtk_frame_set_shadow_type(GTK_FRAME(aspect), GTK_SHADOW_IN); gtk_box_pack_start(GTK_BOX(send_widget), aspect, FALSE, TRUE, 0); data = g_new0(PidginMediaRealizeData, 1); data->gtkmedia = gtkmedia; data->session_id = g_strdup(sid); data->participant = NULL; local_video = gtk_drawing_area_new(); gtk_widget_modify_bg(local_video, GTK_STATE_NORMAL, &color); g_signal_connect(G_OBJECT(local_video), "realize", G_CALLBACK(realize_cb), data); gtk_container_add(GTK_CONTAINER(aspect), local_video); gtk_widget_set_size_request (GTK_WIDGET(local_video), 80, 60); gtk_widget_show(local_video); gtk_widget_show(aspect); gtkmedia->priv->pause = gtk_toggle_button_new_with_mnemonic(_("_Pause")); gtk_box_pack_end(GTK_BOX(button_widget), gtkmedia->priv->pause, FALSE, FALSE, 0); gtk_widget_show(gtkmedia->priv->pause); g_signal_connect(gtkmedia->priv->pause, "toggled", G_CALLBACK(pidgin_media_pause_toggled), gtkmedia); gtkmedia->priv->local_video = local_video; } if (type & PURPLE_MEDIA_RECV_AUDIO) { gtk_box_pack_end(GTK_BOX(recv_widget), pidgin_media_add_audio_widget(gtkmedia, PURPLE_MEDIA_RECV_AUDIO), FALSE, FALSE, 0); } if (type & PURPLE_MEDIA_SEND_AUDIO) { gtkmedia->priv->mute = gtk_toggle_button_new_with_mnemonic("_Mute"); gtk_box_pack_end(GTK_BOX(button_widget), gtkmedia->priv->mute, FALSE, FALSE, 0); gtk_widget_show(gtkmedia->priv->mute); g_signal_connect(gtkmedia->priv->mute, "toggled", G_CALLBACK(pidgin_media_mute_toggled), gtkmedia); gtk_box_pack_end(GTK_BOX(recv_widget), pidgin_media_add_audio_widget(gtkmedia, PURPLE_MEDIA_SEND_AUDIO), FALSE, FALSE, 0); } if (type & PURPLE_MEDIA_AUDIO && gtkmedia->priv->level_handler_id == 0) { gtkmedia->priv->level_handler_id = g_signal_connect( media, "level", G_CALLBACK(level_message_cb), gtkmedia); } if (send_widget != NULL) gtkmedia->priv->send_widget = send_widget; if (recv_widget != NULL) gtkmedia->priv->recv_widget = recv_widget; if (button_widget != NULL) { gtkmedia->priv->button_widget = button_widget; gtk_widget_show(GTK_WIDGET(button_widget)); } if (purple_media_is_initiator(media, sid, NULL) == FALSE) { if (gtkmedia->priv->timeout_id != 0) g_source_remove(gtkmedia->priv->timeout_id); gtkmedia->priv->request_type |= type; gtkmedia->priv->timeout_id = g_timeout_add(500, (GSourceFunc)pidgin_request_timeout_cb, gtkmedia); } /* set the window icon according to the type */ if (type & PURPLE_MEDIA_VIDEO) { icon = gtk_widget_render_icon(GTK_WIDGET(gtkmedia), PIDGIN_STOCK_TOOLBAR_VIDEO_CALL, gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_LARGE), NULL); } else if (type & PURPLE_MEDIA_AUDIO) { icon = gtk_widget_render_icon(GTK_WIDGET(gtkmedia), PIDGIN_STOCK_TOOLBAR_AUDIO_CALL, gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_LARGE), NULL); } if (icon) { gtk_window_set_icon(GTK_WINDOW(gtkmedia), icon); g_object_unref(icon); } gtk_widget_show(gtkmedia->priv->display); }