if (icon->img)

{

if (len != NULL)

return purple_image_get_data(icon->img);

}

g_value_set_boxed(value, purple_image_get_contents(image));

break;

case PROP_SIZE:

break;

default:

G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, param_id, pspec);

g_return_val_if_fail(path[0] != '\0', FALSE);

data = purple_image_get_data(image);

g_return_val_if_fail(data != NULL, FALSE);

g_return_val_if_fail(len > 0, FALSE);

}

gsize

PurpleImagePrivate *priv;

g_return_val_if_fail(PURPLE_IS_IMAGE(image), 0);

if (priv->extension)

return priv->extension;

return NULL;

data = purple_image_get_data(image);

ext = purple_image_get_extension(image);

data = purple_image_get_data(image);

g_return_val_if_fail(ext != NULL, NULL);

g_return_val_if_fail(data != NULL, NULL);

return purple_image_generate_filename(image);

}

\ No newline at end of file

const gchar *purple_image_get_path(PurpleImage *image);

/**

* @image: the image.

*

* Returns the size of @image's data.

*

* Returns: the size of data, or 0 in case of failure.

*/

/**

* purple_image_get_data:

}

image_data = purple_image_get_data(image);

dir = purple_log_get_log_dir(log->type, log->name, log->account);

new_filename = purple_image_generate_filename(image);

gsize avatar_len;

avatar_data = purple_image_get_data(img);

if (_mdns_set_buddy_icon_data(data, avatar_data, avatar_len)) {

g_free(data->phsh);

own_data->img = NULL;

img_data = purple_base64_encode(purple_image_get_data(img),

img_data_e = g_uri_escape_string(img_data, NULL, FALSE);

g_free(img_data);

request_data = g_strdup_printf("uin=%d&photo=%s", uin, img_data_e);

g_return_val_if_fail(image, GGP_IMAGE_PREPARE_FAILURE);

if (image_size > GGP_IMAGE_SIZE_MAX) {

purple_debug_warning("gg", "ggp_image_prepare: image "

gg_image_reply(accdata->session, image_request->sender,

gg_filename,

purple_image_get_data(sent_image->image),

g_free(gg_filename);

conv = purple_conversations_find_with_account(

if (image != NULL) {

js->initial_avatar_hash = jabber_calculate_data_hash(

purple_image_get_data(image),

g_object_unref(image);

} else {

js->initial_avatar_hash = NULL;

}

avatar_data = purple_image_get_data(img);

/* Get rid of an old PHOTO if one exists.

* TODO: This may want to be modified to remove all old PHOTO

* children, at the moment some people have managed to get

if (image != NULL) {

js->initial_avatar_hash = jabber_calculate_data_hash(

purple_image_get_data(image),

g_object_unref(image);

}

it_next = g_list_next(it);

has_too_large_smiley = TRUE;

valid = FALSE;

purple_debug_warning("jabber", "Refusing to send "

jdata = jabber_data_create_from_data(

purple_image_get_data(PURPLE_IMAGE(smiley)),

mimetype, FALSE, jm->js);

purple_debug_info("jabber", "cache local smiley alt=%s, cid=%s",

} ihdr;

} *png = NULL;

png = purple_image_get_data(img);

/* check if the data is a valid png file (well, at least to some extent) */

/* compute the sha1 hash */

char *hash = jabber_calculate_data_hash(

purple_image_get_data(img),

char *base64avatar = purple_base64_encode(

purple_image_get_data(img),

publish = purple_xmlnode_new("publish");

purple_xmlnode_set_attrib(publish, "node", NS_AVATAR_1_1_DATA);

g_free(base64avatar);

lengthstring = g_strdup_printf("%" G_GSIZE_FORMAT,

widthstring = g_strdup_printf("%u", width);

heightstring = g_strdup_printf("%u", height);

if (img == NULL)

return NULL;

data = purple_image_get_data(img);

/* New object */

if (my_obj != NULL) {

PurpleImage *img = msn_object_get_image(my_obj);

data = purple_image_get_data(img);

info = msn_object_get_sha1(my_obj);

}

g_return_if_fail(slpmsg->buffer == NULL);

g_return_if_fail(slpmsg->ft == FALSE);

slpmsg->buffer = g_memdup(purple_image_get_data(img), slpmsg->size);

}

gchar* enc;

img_data = purple_image_get_data(image);

enc = purple_base64_encode( img_data, img_size );

mxit_set_avatar(session, NULL, 0);

else {

mxit_set_avatar(session, purple_image_get_data(img),

}

}

"Uploading icon to icon server\n");

aim_bart_upload(od,

purple_image_get_data(img),

g_object_unref(img);

}

}

if ((img != NULL) &&

(args->icbmflags & AIM_IMFLAGS_BUDDYREQ) && !bi->ico_sent && bi->ico_informed) {

gconstpointer data = purple_image_get_data(img);

purple_debug_info("oscar",

"Sending buddy icon to %s (%" G_GSIZE_FORMAT " bytes)\n",

userinfo->bn, len);

purple_debug_info("oscar",

"Uploading icon to icon server");

aim_bart_upload(od, purple_image_get_data(img),

g_object_unref(img);

}

od->set_icon = FALSE;

/* ... if it refers to a valid purple image ... */

if (image) {

/* ... append the message from start to the tag ... */

const gchar *filename = purple_image_get_friendly_filename(image);

gconstpointer imgdata = purple_image_get_data(image);

img = purple_buddy_icons_find_account_icon(account);

if (img) {

gconstpointer data = purple_image_get_data(img);

args.iconsum = aimutil_iconsum(data, args.iconlen);

args.iconstamp = purple_buddy_icons_get_account_icon_timestamp(account);

PurpleHash *hash;

guchar md5[16];

gconstpointer data = purple_image_get_data(img);

hash = purple_md5_hash_new();

purple_hash_append(hash, data, len);

/* obtain and base64 encode the image data, and put it in the

mime part */

data = purple_base64_encode(purple_image_get_data(img), size);

purple_mime_part_set_data(part, data);

g_free(data);

silc_mime_add_field(mime, "Content-Type", type);

silc_mime_add_data(mime, purple_image_get_data(img),

silc_client_attribute_add(client, conn, SILC_ATTRIBUTE_USER_ICON,

mime, sizeof(*mime));

if (uri)

image = purple_image_store_get_from_uri(uri);

if (uri) {

gconstpointer img = purple_image_get_data(image);

const gchar *type;

} else {

gconstpointer data = purple_image_get_data(img);

GString *s = g_string_new_len(data, len);

struct yahoo_buddy_icon_upload_data *d;

int oldcksum = purple_account_get_int(account, YAHOO_PICCKSUM_SETTING, 0);

return g_compute_checksum_for_data(G_CHECKSUM_SHA1,

purple_image_get_data(img),

}

img = purple_buddy_icons_find_account_icon(dialog->account);

if (img)

{

data = g_memdup(purple_image_get_data(img), len);

}

set_dialog_icon(dialog, data, len,

{

if (dialog->icon_img)

{

purple_buddy_icons_set_account_icon(account,

g_memdup(purple_image_get_data(dialog->icon_img), len), len);

purple_account_set_buddy_icon_path(account,

if (custom_img) {

data = purple_image_get_data(custom_img);

}

if (data == NULL) {

account ? purple_account_get_username(account) : "(no account)",

account ? purple_account_get_protocol_id(account) : "(no account)",

buddy ? purple_buddy_get_name(buddy) : "(no buddy)",

if (custom_img)

g_object_unref(custom_img);

return NULL;

if (custom_img) {

/* There is a custom icon for this user */

data = purple_image_get_data(custom_img);

}

}

}

g_signal_connect(G_OBJECT(loader), "size-prepared", G_CALLBACK(pixbuf_size_prepared_cb), NULL);

if (!gdk_pixbuf_loader_write(loader,

purple_image_get_data(status_box->buddy_icon_img),

&error) || error)

{

purple_debug_warning("gtkstatusbox",

"gdk_pixbuf_loader_write() failed with size=%"

status_box->buddy_icon_img),

error ? error->message : "(no error message)");

if (error)

purple_debug_warning("gtkstatusbox",

"gdk_pixbuf_loader_close() failed for image of "

"size %" G_GSIZE_FORMAT ": %s",

error ? error->message : "(no error message)");

if (error)

g_error_free(error);

pidgin_pixbuf_from_image(PurpleImage *image)

{

return pidgin_pixbuf_from_data(purple_image_get_data(image),

}

GdkPixbuf *pidgin_pixbuf_new_from_file(const gchar *filename)

b64 = purple_base64_encode(

purple_image_get_data(img),

type = purple_image_get_mimetype(img);

src = g_strdup_printf("data:%s;base64,%s", type, b64);

g_free(b64);

/* TODO: make it a plain, multipart/form-data request */

img_data = purple_base64_encode(purple_image_get_data(image),

img_data_e = g_uri_escape_string(img_data, NULL, FALSE);

g_free(img_data);

req_data = g_strdup_printf("type=base64&image=%s", img_data_e);