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);
}
