/**
* dbusmenu_menuitem_property_set_image:
* @menuitem: The #DbusmenuMenuitem to set the property on.
* @property: Name of the property to set.
* @data: The image to place on the property.
*
* This function takes the pixbuf that is stored in @data and
* turns it into a base64 encoded PNG so that it can be placed
* onto a standard #DbusmenuMenuitem property.
*
* Return value: Whether the function was able to set the property
* or not.
*/
gboolean
dbusmenu_menuitem_property_set_image (DbusmenuMenuitem * menuitem, const gchar * property, const GdkPixbuf * data)
{
g_return_val_if_fail(GDK_IS_PIXBUF(data), FALSE);
g_return_val_if_fail(DBUSMENU_IS_MENUITEM(menuitem), FALSE);
g_return_val_if_fail(property != NULL && property[0] != '\0', FALSE);
GError * error = NULL;
gchar * png_data;
gsize png_data_len;
if (!gdk_pixbuf_save_to_buffer((GdkPixbuf *)data, &png_data, &png_data_len, "png", &error, NULL)) {
if (error == NULL) {
g_warning("Unable to create pixbuf data stream: %d", (gint)png_data_len);
} else {
g_warning("Unable to create pixbuf data stream: %s", error->message);
g_error_free(error);
error = NULL;
}
return FALSE;
}
gboolean propreturn = FALSE;
propreturn = dbusmenu_menuitem_property_set_byte_array(menuitem, property, (guchar *)png_data, png_data_len);
g_free(png_data);
return propreturn;
}
gboolean
hd_pixbuf_utils_save (GFile *file,
GdkPixbuf *pixbuf,
const gchar *type,
GCancellable *cancellable,
GError **error)
{
gchar *buffer = NULL;
gsize buffer_size;
gboolean result;
if (!gdk_pixbuf_save_to_buffer (pixbuf,
&buffer,
&buffer_size,
type,
error,
NULL))
return FALSE;
result = g_file_replace_contents (file,
buffer,
buffer_size,
NULL,
FALSE,
G_FILE_CREATE_NONE,
NULL,
cancellable,
error);
g_free (buffer);
return result;
}
static bool encodeImage(cairo_surface_t* surface, const String& mimeType, std::optional<double> quality, GUniqueOutPtr<gchar>& buffer, gsize& bufferSize)
{
// List of supported image encoding types comes from the GdkPixbuf documentation.
// http://developer.gnome.org/gdk-pixbuf/stable/gdk-pixbuf-File-saving.html#gdk-pixbuf-save-to-bufferv
String type = mimeType.substring(sizeof "image");
if (type != "jpeg" && type != "png" && type != "tiff" && type != "ico" && type != "bmp")
return false;
GRefPtr<GdkPixbuf> pixbuf;
if (type == "jpeg") {
// JPEG doesn't support alpha channel. The <canvas> spec states that toDataURL() must encode a Porter-Duff
// composite source-over black for image types that do not support alpha.
RefPtr<cairo_surface_t> newSurface;
if (cairo_surface_get_type(surface) == CAIRO_SURFACE_TYPE_IMAGE) {
newSurface = adoptRef(cairo_image_surface_create_for_data(cairo_image_surface_get_data(surface),
CAIRO_FORMAT_RGB24,
cairo_image_surface_get_width(surface),
cairo_image_surface_get_height(surface),
cairo_image_surface_get_stride(surface)));
} else {
IntSize size = cairoSurfaceSize(surface);
newSurface = adoptRef(cairo_image_surface_create(CAIRO_FORMAT_RGB24, size.width(), size.height()));
RefPtr<cairo_t> cr = adoptRef(cairo_create(newSurface.get()));
cairo_set_source_surface(cr.get(), surface, 0, 0);
cairo_paint(cr.get());
}
pixbuf = adoptGRef(cairoSurfaceToGdkPixbuf(newSurface.get()));
} else
pixbuf = adoptGRef(cairoSurfaceToGdkPixbuf(surface));
if (!pixbuf)
return false;
GUniqueOutPtr<GError> error;
if (type == "jpeg" && quality && *quality >= 0.0 && *quality <= 1.0) {
String qualityString = String::format("%d", static_cast<int>(*quality * 100.0 + 0.5));
gdk_pixbuf_save_to_buffer(pixbuf.get(), &buffer.outPtr(), &bufferSize, type.utf8().data(), &error.outPtr(), "quality", qualityString.utf8().data(), NULL);
} else
gdk_pixbuf_save_to_buffer(pixbuf.get(), &buffer.outPtr(), &bufferSize, type.utf8().data(), &error.outPtr(), NULL);
return !error;
}
static GBytes *
gdk_pixbuf_make_bytes (GdkPixbuf *pixbuf,
GError **error)
{
gchar *buffer;
gsize size;
if (!gdk_pixbuf_save_to_buffer (pixbuf, &buffer, &size, "png", error, NULL))
return NULL;
return g_bytes_new_take (buffer, size);
}
/**
* gtk_selection_data_set_pixbuf:
* @selection_data: a #GtkSelectionData
* @pixbuf: a #GdkPixbuf
*
* Sets the contents of the selection from a #GdkPixbuf
* The pixbuf is converted to the form determined by
* @selection_data->target.
*
* Returns: %TRUE if the selection was successfully set,
* otherwise %FALSE.
**/
gboolean
gtk_selection_data_set_pixbuf (GtkSelectionData *selection_data,
GdkPixbuf *pixbuf)
{
GSList *formats, *f;
gchar **mimes, **m;
GdkAtom atom;
gboolean result;
gchar *str, *type;
gsize len;
g_return_val_if_fail (selection_data != NULL, FALSE);
g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), FALSE);
formats = gdk_pixbuf_get_formats ();
for (f = formats; f; f = f->next)
{
GdkPixbufFormat *fmt = f->data;
mimes = gdk_pixbuf_format_get_mime_types (fmt);
for (m = mimes; *m; m++)
{
atom = g_intern_string (*m);
if (selection_data->target == atom)
{
str = NULL;
type = gdk_pixbuf_format_get_name (fmt);
result = gdk_pixbuf_save_to_buffer (pixbuf, &str, &len,
type, NULL,
((strcmp (type, "png") == 0) ?
"compression" : NULL), "2",
NULL);
if (result)
gtk_selection_data_set (selection_data,
atom, 8, (guchar *)str, len);
g_free (type);
g_free (str);
g_strfreev (mimes);
g_slist_free (formats);
return result;
}
}
g_strfreev (mimes);
}
g_slist_free (formats);
return FALSE;
}
String ImageBuffer::toDataURL(const String& mimeType, const double* quality) const
{
ASSERT(MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType));
if (!mimeType.startsWith("image/"))
return "data:,";
// List of supported image types comes from the GdkPixbuf documentation.
// http://library.gnome.org/devel/gdk-pixbuf/stable/gdk-pixbuf-file-saving.html#gdk-pixbuf-save-to-bufferv
String type = mimeType.substring(sizeof "image");
if (type != "jpeg" && type != "png" && type != "tiff" && type != "ico" && type != "bmp")
return "data:,";
PlatformRefPtr<GdkPixbuf> pixbuf = cairoImageSurfaceToGdkPixbuf(m_data.m_surface);
if (!pixbuf)
return "data:,";
GOwnPtr<gchar> buffer(0);
gsize bufferSize;
GError* error = 0;
gboolean success = FALSE;
if (type == "jpeg" && quality && *quality >= 0.0 && *quality <= 1.0) {
String qualityString = String::format("%f", *quality);
success = gdk_pixbuf_save_to_buffer(pixbuf.get(), &buffer.outPtr(), &bufferSize,
type.utf8().data(), &error, "quality", qualityString.utf8().data(), NULL);
} else {
success = gdk_pixbuf_save_to_buffer(pixbuf.get(), &buffer.outPtr(), &bufferSize, type.utf8().data(), &error, NULL);
}
if (!success)
return "data:,";
Vector<char> out;
base64Encode(reinterpret_cast<const char*>(buffer.get()), bufferSize, out);
out.append('\0');
return String::format("data:%s;base64,%s", mimeType.utf8().data(), out.data());
}
static void
set_album_image (RBMtpThread *thread, RBMtpThreadTask *task)
{
LIBMTP_filesampledata_t *albumart;
LIBMTP_album_t *album;
GError *error = NULL;
char *image_data;
gsize image_size;
int ret;
album = g_hash_table_lookup (thread->albums, task->album);
if (album == NULL) {
rb_debug ("Couldn't find an album for %s", task->album);
return;
}
/* probably should scale the image down, since some devices have a size limit and they all have
* tiny displays anyway.
*/
if (gdk_pixbuf_save_to_buffer (task->image, &image_data, &image_size, "jpeg", &error, NULL) == FALSE) {
rb_debug ("unable to convert album art image to a JPEG buffer: %s", error->message);
g_error_free (error);
return;
}
albumart = LIBMTP_new_filesampledata_t ();
albumart->filetype = LIBMTP_FILETYPE_JPEG;
albumart->data = image_data;
albumart->size = image_size;
ret = LIBMTP_Send_Representative_Sample (thread->device, album->album_id, albumart);
if (ret != 0) {
rb_mtp_thread_report_errors (thread, TRUE);
} else {
rb_debug ("successfully set album art for %s (%" G_GSIZE_FORMAT " bytes)", task->album, image_size);
}
/* libmtp will try to free this if we don't clear the pointer */
albumart->data = NULL;
LIBMTP_destroy_filesampledata_t (albumart);
}
void sp_embed_image(Inkscape::XML::Node *image_node, Inkscape::Pixbuf *pb)
{
bool free_data = false;
// check whether the pixbuf has MIME data
guchar *data = NULL;
gsize len = 0;
std::string data_mimetype;
data = const_cast<guchar *>(pb->getMimeData(len, data_mimetype));
if (data == NULL) {
// if there is no supported MIME data, embed as PNG
data_mimetype = "image/png";
gdk_pixbuf_save_to_buffer(pb->getPixbufRaw(), reinterpret_cast<gchar**>(&data), &len, "png", NULL, NULL);
free_data = true;
}
// Save base64 encoded data in image node
// this formula taken from Glib docs
gsize needed_size = len * 4 / 3 + len * 4 / (3 * 72) + 7;
needed_size += 5 + 8 + data_mimetype.size(); // 5 bytes for data: + 8 for ;base64,
gchar *buffer = (gchar *) g_malloc(needed_size);
gchar *buf_work = buffer;
buf_work += g_sprintf(buffer, "data:%s;base64,", data_mimetype.c_str());
gint state = 0;
gint save = 0;
gsize written = 0;
written += g_base64_encode_step(data, len, TRUE, buf_work, &state, &save);
written += g_base64_encode_close(TRUE, buf_work + written, &state, &save);
buf_work[written] = 0; // null terminate
// TODO: this is very wasteful memory-wise.
// It would be better to only keep the binary data around,
// and base64 encode on the fly when saving the XML.
image_node->setAttribute("xlink:href", buffer);
g_free(buffer);
if (free_data) g_free(data);
}
QIcon GnomeIconProvider::icon(const QFileInfo& info) const
{
if (info.fileName().endsWith(".png", Qt::CaseInsensitive))
{
return QIcon(info.absoluteFilePath());
}
if (info.fileName().endsWith(".ico", Qt::CaseInsensitive))
return QIcon(info.absoluteFilePath());
gdk_threads_enter();
GnomeIconLookupResultFlags resultFlags;
char* file = gnome_icon_lookup_sync(gtk_icon_theme_get_default(),
NULL,
info.absoluteFilePath().toLocal8Bit().data(),
NULL,
GNOME_ICON_LOOKUP_FLAGS_NONE,
&resultFlags);
GtkIconInfo* icinfo = gtk_icon_theme_lookup_icon(gtk_icon_theme_get_default(),
file,
32,
GTK_ICON_LOOKUP_NO_SVG);
GdkPixbuf* buff = gtk_icon_info_load_icon(icinfo, NULL);
gchar* pixmap;
gsize buflen;
gdk_pixbuf_save_to_buffer (buff,
&pixmap,
&buflen,
"png",
NULL, NULL);
QPixmap qp;
qp.loadFromData((const uchar*) pixmap, buflen, "png");
QIcon qico(qp);
free(pixmap);
g_object_unref(buff);
gdk_threads_leave();
return qp;
}
static void
set_avatar(AvatarManipulation *self)
{
AvatarManipulationPrivate *priv = AVATAR_MANIPULATION_GET_PRIVATE(self);
gchar* png_buffer_signed = nullptr;
gsize png_buffer_size;
GError* error = nullptr;
/* get the cropped area */
GdkPixbuf *selector_pixbuf = cc_crop_area_get_picture(CC_CROP_AREA(priv->crop_area));
/* scale it */
GdkPixbuf* pixbuf_frame_resized = gdk_pixbuf_scale_simple(selector_pixbuf, AVATAR_WIDTH, AVATAR_HEIGHT,
GDK_INTERP_HYPER);
/* save the png in memory */
gdk_pixbuf_save_to_buffer(pixbuf_frame_resized, &png_buffer_signed, &png_buffer_size, "png", &error, NULL);
if (!png_buffer_signed) {
g_warning("(set_avatar) failed to save pixbuffer to png: %s\n", error->message);
g_error_free(error);
return;
}
/* convert buffer to QByteArray in base 64*/
QByteArray png_q_byte_array = QByteArray::fromRawData(png_buffer_signed, png_buffer_size).toBase64();
/* save in profile */
QVariant photo = GlobalInstances::pixmapManipulator().personPhoto(png_q_byte_array);
ProfileModel::instance().selectedProfile()->person()->setPhoto(photo);
ProfileModel::instance().selectedProfile()->save();
g_free(png_buffer_signed);
g_object_unref(selector_pixbuf);
g_object_unref(pixbuf_frame_resized);
set_state(self, AVATAR_MANIPULATION_STATE_CURRENT);
}
char* get_data_uri_by_pixbuf(GdkPixbuf* pixbuf)
{
gchar* buf = NULL;
gsize size = 0;
GError *error = NULL;
gdk_pixbuf_save_to_buffer(pixbuf, &buf, &size, "png", &error, NULL);
g_assert(buf != NULL);
if (error != NULL) {
g_warning("%s\n", error->message);
g_error_free(error);
g_free(buf);
return NULL;
}
char* base64 = g_base64_encode((const guchar*)buf, size);
g_free(buf);
char* data = g_strconcat("data:image/png;base64,", base64, NULL);
g_free(base64);
return data;
}
static gboolean dnd_source_set_image(GdkWindow *requestor, GdkAtom property, GdkAtom target)
{
jobject pixels = dnd_source_get_data("application/x-java-rawimage");
if (!pixels) {
return FALSE;
}
gchar *buffer;
gsize size;
const char * type;
GdkPixbuf *pixbuf = NULL;
gboolean result = FALSE;
if (target == TARGET_MIME_PNG_ATOM) {
type = "png";
} else if (target == TARGET_MIME_JPEG_ATOM) {
type = "jpeg";
} else if (target == TARGET_MIME_TIFF_ATOM) {
type = "tiff";
} else if (target == TARGET_MIME_BMP_ATOM) {
type = "bmp";
} else {
return FALSE;
}
mainEnv->CallVoidMethod(pixels, jPixelsAttachData, PTR_TO_JLONG(&pixbuf));
if (!EXCEPTION_OCCURED(mainEnv)
&& gdk_pixbuf_save_to_buffer(pixbuf, &buffer, &size, type, NULL, NULL)) {
gdk_property_change(requestor, property, target,
8, GDK_PROP_MODE_REPLACE, (guchar *)buffer, size);
result = TRUE;
}
g_object_unref(pixbuf);
return result;
}
static EmpathyAvatar *
avatar_chooser_maybe_convert_and_scale (EmpathyAvatarChooser *chooser,
GdkPixbuf *pixbuf,
EmpathyAvatar *avatar)
{
EmpathyAvatarChooserPriv *priv = GET_PRIV (chooser);
guint max_width = 0, max_height = 0, max_size = 0;
gchar **mime_types = NULL;
gboolean needs_conversion = FALSE;
gint width, height;
gchar *new_format_name = NULL;
gchar *new_mime_type = NULL;
gdouble min_factor, max_factor;
gdouble factor;
gchar *converted_image_data = NULL;
gsize converted_image_size = 0;
g_object_get (priv->factory,
"avatar-mime-types", &mime_types, /* Needs g_strfreev-ing */
"avatar-max-width", &max_width,
"avatar-max-height", &max_height,
"avatar-max-size", &max_size,
NULL);
/* Smaller is the factor, smaller will be the image.
* 0 is an empty image, 1 is the full size. */
min_factor = 0;
max_factor = 1;
factor = 1;
/* Check if we need to convert to another image format */
if (avatar_chooser_need_mime_type_conversion (avatar->format,
mime_types,
&new_format_name,
&new_mime_type)) {
DEBUG ("Format conversion needed, we'll use mime type '%s' "
"and format name '%s'. Current mime type is '%s'",
new_mime_type, new_format_name, avatar->format);
needs_conversion = TRUE;
}
g_strfreev (mime_types);
/* If there is no format we can use, report error to the user. */
if (new_mime_type == NULL || new_format_name == NULL) {
avatar_chooser_error_show (chooser, _("Couldn't convert image"),
_("None of the accepted image formats is "
"supported on your system"));
return NULL;
}
/* If width or height are too big, it needs converting. */
width = gdk_pixbuf_get_width (pixbuf);
height = gdk_pixbuf_get_height (pixbuf);
if ((max_width > 0 && width > max_width) ||
(max_height > 0 && height > max_height)) {
gdouble h_factor, v_factor;
h_factor = (gdouble) max_width / width;
v_factor = (gdouble) max_height / height;
factor = max_factor = MIN (h_factor, v_factor);
DEBUG ("Image dimensions (%dx%d) are too big. Max is %dx%d.",
width, height, max_width, max_height);
needs_conversion = TRUE;
}
/* If the data len is too big and no other conversion is needed,
* try with a lower factor. */
if (max_size > 0 && avatar->len > max_size && !needs_conversion) {
DEBUG ("Image data (%"G_GSIZE_FORMAT" bytes) is too big "
"(max is %u bytes), conversion needed.",
avatar->len, max_size);
factor = 0.5;
needs_conversion = TRUE;
}
/* If no conversion is needed, return the avatar */
if (!needs_conversion) {
g_free (new_format_name);
g_free (new_mime_type);
return empathy_avatar_ref (avatar);
}
do {
GdkPixbuf *pixbuf_scaled = NULL;
gboolean saved;
gint new_width, new_height;
GError *error = NULL;
g_free (converted_image_data);
if (factor != 1) {
new_width = width * factor;
new_height = height * factor;
pixbuf_scaled = gdk_pixbuf_scale_simple (pixbuf,
new_width,
new_height,
GDK_INTERP_HYPER);
} else {
new_width = width;
new_height = height;
pixbuf_scaled = g_object_ref (pixbuf);
}
DEBUG ("Trying with factor %f (%dx%d) and format %s...", factor,
new_width, new_height, new_format_name);
saved = gdk_pixbuf_save_to_buffer (pixbuf_scaled,
&converted_image_data,
&converted_image_size,
new_format_name,
&error, NULL);
g_object_unref (pixbuf_scaled);
if (!saved) {
g_free (new_format_name);
g_free (new_mime_type);
avatar_chooser_error_show (chooser,
_("Couldn't convert image"),
error ? error->message : NULL);
g_clear_error (&error);
return NULL;
}
DEBUG ("Produced an image data of %"G_GSIZE_FORMAT" bytes.",
converted_image_size);
if (max_size == 0)
break;
/* Make a binary search for the bigest factor that produce
* an image data size less than max_size */
if (converted_image_size > max_size)
max_factor = factor;
if (converted_image_size < max_size)
min_factor = factor;
factor = (min_factor + max_factor)/2;
/* We are done if either:
* - min_factor == max_factor. That happens if we resized to
* the max required dimension and the produced data size is
* less than max_size.
* - The data size is close enough to max_size. Here we accept
* a difference of 1k.
*/
} while (min_factor != max_factor &&
ABS (max_size - converted_image_size) > 1024);
g_free (new_format_name);
/* Takes ownership of new_mime_type and converted_image_data */
avatar = empathy_avatar_new (converted_image_data,
converted_image_size, new_mime_type, NULL, NULL);
return avatar;
}
void selection_to_clip(void)
{
struct XojSelectionData *sel;
int bufsz, nitems, val;
char *p;
GList *list;
struct Item *item;
GtkTargetList *targetlist;
GtkTargetEntry *targets;
int n_targets;
if (ui.selection == NULL) return;
bufsz = 2*sizeof(int) // bufsz, nitems
+ sizeof(struct BBox); // bbox
nitems = 0;
for (list = ui.selection->items; list != NULL; list = list->next) {
item = (struct Item *)list->data;
nitems++;
if (item->type == ITEM_STROKE) {
bufsz+= sizeof(int) // type
+ sizeof(struct Brush) // brush
+ sizeof(int) // num_points
+ 2*item->path->num_points*sizeof(double); // the points
if (item->brush.variable_width)
bufsz += (item->path->num_points-1)*sizeof(double); // the widths
}
else if (item->type == ITEM_TEXT) {
bufsz+= sizeof(int) // type
+ sizeof(struct Brush) // brush
+ 2*sizeof(double) // bbox upper-left
+ sizeof(int) // text len
+ strlen(item->text)+1 // text
+ sizeof(int) // font_name len
+ strlen(item->font_name)+1 // font_name
+ sizeof(double); // font_size
}
else if (item->type == ITEM_IMAGE) {
if (item->image_png == NULL) {
set_cursor_busy(TRUE);
if (!gdk_pixbuf_save_to_buffer(item->image, &item->image_png, &item->image_png_len, "png", NULL, NULL))
item->image_png_len = 0; // failed for some reason, so forget it
set_cursor_busy(FALSE);
}
bufsz+= sizeof(int) // type
+ sizeof(struct BBox)
+ sizeof(gsize) // png_buflen
+ item->image_png_len;
}
else bufsz+= sizeof(int); // type
}
// allocate selection data structure and buffer
sel = g_malloc(sizeof(struct XojSelectionData));
sel->xo_data_len = bufsz;
sel->xo_data = g_malloc(bufsz);
sel->image_data = NULL;
sel->text_data = NULL;
// fill in the data
p = sel->xo_data;
g_memmove(p, &bufsz, sizeof(int)); p+= sizeof(int);
g_memmove(p, &nitems, sizeof(int)); p+= sizeof(int);
g_memmove(p, &ui.selection->bbox, sizeof(struct BBox)); p+= sizeof(struct BBox);
for (list = ui.selection->items; list != NULL; list = list->next) {
item = (struct Item *)list->data;
g_memmove(p, &item->type, sizeof(int)); p+= sizeof(int);
if (item->type == ITEM_STROKE) {
g_memmove(p, &item->brush, sizeof(struct Brush)); p+= sizeof(struct Brush);
g_memmove(p, &item->path->num_points, sizeof(int)); p+= sizeof(int);
g_memmove(p, item->path->coords, 2*item->path->num_points*sizeof(double));
p+= 2*item->path->num_points*sizeof(double);
if (item->brush.variable_width) {
g_memmove(p, item->widths, (item->path->num_points-1)*sizeof(double));
p+= (item->path->num_points-1)*sizeof(double);
}
}
if (item->type == ITEM_TEXT) {
g_memmove(p, &item->brush, sizeof(struct Brush)); p+= sizeof(struct Brush);
g_memmove(p, &item->bbox.left, sizeof(double)); p+= sizeof(double);
g_memmove(p, &item->bbox.top, sizeof(double)); p+= sizeof(double);
val = strlen(item->text);
g_memmove(p, &val, sizeof(int)); p+= sizeof(int);
g_memmove(p, item->text, val+1); p+= val+1;
val = strlen(item->font_name);
g_memmove(p, &val, sizeof(int)); p+= sizeof(int);
g_memmove(p, item->font_name, val+1); p+= val+1;
g_memmove(p, &item->font_size, sizeof(double)); p+= sizeof(double);
if (nitems==1) sel->text_data = g_strdup(item->text); // single text item
}
if (item->type == ITEM_IMAGE) {
g_memmove(p, &item->bbox, sizeof(struct BBox)); p+= sizeof(struct BBox);
g_memmove(p, &item->image_png_len, sizeof(gsize)); p+= sizeof(gsize);
if (item->image_png_len > 0) {
g_memmove(p, item->image_png, item->image_png_len); p+= item->image_png_len;
}
if (nitems==1) sel->image_data = gdk_pixbuf_copy(item->image); // single image
}
}
/* build list of valid targets */
targetlist = gtk_target_list_new(NULL, 0);
gtk_target_list_add(targetlist,
gdk_atom_intern(XOURNAL_TARGET_ATOM, FALSE), 0, TARGET_XOURNAL);
if (sel->image_data!=NULL)
gtk_target_list_add_image_targets(targetlist, TARGET_PIXBUF, TRUE);
if (sel->text_data!=NULL)
gtk_target_list_add_text_targets(targetlist, TARGET_TEXT);
targets = gtk_target_table_new_from_list(targetlist, &n_targets);
gtk_target_list_unref(targetlist);
gtk_clipboard_set_with_data(gtk_clipboard_get(GDK_SELECTION_CLIPBOARD),
targets, n_targets,
callback_clipboard_get, callback_clipboard_clear, sel);
gtk_target_table_free(targets, n_targets);
}
static void
artwork_notify_cb (RhythmDB *db,
RhythmDBEntry *entry,
const char *property_name,
const GValue *metadata,
RBMtpSource *source)
{
RBMtpSourcePrivate *priv = MTP_SOURCE_GET_PRIVATE (source);
GdkPixbuf *pixbuf;
LIBMTP_album_t *album;
LIBMTP_filesampledata_t *albumart;
GError *error = NULL;
const char *album_name;
char *image_data;
gsize image_size;
int ret;
album_name = rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_ALBUM);
/* check if we're looking for art for this entry, and if we actually got some */
if (g_hash_table_remove (priv->artwork_request_map, album_name) == FALSE)
return;
if (G_VALUE_HOLDS (metadata, GDK_TYPE_PIXBUF) == FALSE)
return;
pixbuf = GDK_PIXBUF (g_value_get_object (metadata));
/* we should already have created an album object */
album = g_hash_table_lookup (priv->album_map, album_name);
if (album == NULL) {
rb_debug ("couldn't find an album for %s", album_name);
return;
}
/* probably should scale the image down, since some devices have a size limit and they all have
* tiny displays anyway.
*/
if (gdk_pixbuf_save_to_buffer (pixbuf, &image_data, &image_size, "jpeg", &error, NULL) == FALSE) {
rb_debug ("unable to convert album art image to a JPEG buffer: %s", error->message);
g_error_free (error);
return;
}
albumart = LIBMTP_new_filesampledata_t ();
albumart->filetype = LIBMTP_FILETYPE_JPEG;
albumart->data = image_data;
albumart->size = image_size;
ret = LIBMTP_Send_Representative_Sample (priv->device, album->album_id, albumart);
if (ret != 0) {
report_libmtp_errors (priv->device, TRUE);
} else {
rb_debug ("successfully set album art for %s (%" G_GSIZE_FORMAT " bytes)", album_name, image_size);
}
/* libmtp will try to free this if we don't clear the pointer */
albumart->data = NULL;
LIBMTP_destroy_filesampledata_t (albumart);
g_free (image_data);
}
void
dacp_share_ctrl_int (DMAPShare * share,
SoupServer * server,
SoupMessage * message,
const char *path,
GHashTable * query, SoupClientContext * context)
{
const char *rest_of_path;
DACPShare *dacp_share = DACP_SHARE (share);
g_debug ("Path is %s.", path);
if (query) {
g_hash_table_foreach (query, debug_param, NULL);
}
rest_of_path = strchr (path + 1, '/');
/* If calling /ctrl-int without args, the client doesnt need a
* session-id, otherwise it does and it should be validated. */
if ((rest_of_path != NULL)
&&
(!_dmap_share_session_id_validate
(share, context, message, query, NULL))) {
soup_message_set_status (message, SOUP_STATUS_FORBIDDEN);
return;
}
if (rest_of_path == NULL) {
/* CACI control-int
* MSTT status
* MUTY update type
* MTCO specified total count
* MRCO returned count
* MLCL listing
* MLIT listing item
* MIID item id
* CMIK Unknown (TRUE)
* CMSP Unknown (TRUE)
* CMSV Unknown (TRUE)
* CASS Unknown (TRUE)
* CASU Unknown (TRUE)
* CASG Unknown (TRUE)
*/
GNode *caci;
GNode *mlcl;
GNode *mlit;
// dacp.controlint
caci = dmap_structure_add (NULL, DMAP_CC_CACI);
// dmap.status
dmap_structure_add (caci, DMAP_CC_MSTT,
(gint32) DMAP_STATUS_OK);
// dmap.updatetype
dmap_structure_add (caci, DMAP_CC_MUTY, 0);
// dmap.specifiedtotalcount
dmap_structure_add (caci, DMAP_CC_MTCO, (gint32) 1);
// dmap.returnedcount
dmap_structure_add (caci, DMAP_CC_MRCO, (gint32) 1);
// dmap.listing
mlcl = dmap_structure_add (caci, DMAP_CC_MLCL);
// dmap.listingitem
mlit = dmap_structure_add (mlcl, DMAP_CC_MLIT);
// dmap.itemid
dmap_structure_add (mlit, DMAP_CC_MIID, (gint32) 1);
// Unknown (TRUE)
dmap_structure_add (mlit, DMAP_CC_CMIK, (gint32) 1);
// Unknown (TRUE)
dmap_structure_add (mlit, DMAP_CC_CMSP, (gint32) 1);
// Unknown (TRUE)
dmap_structure_add (mlit, DMAP_CC_CMSV, (gint32) 1);
// Unknown (TRUE)
dmap_structure_add (mlit, DMAP_CC_CASS, (gint32) 1);
// Unknown (TRUE)
dmap_structure_add (mlit, DMAP_CC_CASU, (gint32) 1);
// Unknown (TRUE)
dmap_structure_add (mlit, DMAP_CC_CASG, (gint32) 1);
_dmap_share_message_set_from_dmap_structure (share, message,
caci);
dmap_structure_destroy (caci);
} else if (g_ascii_strcasecmp ("/1/getproperty", rest_of_path) == 0) {
gchar *properties_query, **properties, **property;
GNode *cmgt;
properties_query = g_hash_table_lookup (query, "properties");
if (!properties_query) {
g_warning ("No property specified");
return;
}
cmgt = dmap_structure_add (NULL, DMAP_CC_CMGT);
dmap_structure_add (cmgt, DMAP_CC_MSTT, DMAP_STATUS_OK);
properties = g_strsplit (properties_query, ",", -1);
for (property = properties; *property; property++) {
if (g_ascii_strcasecmp (*property, "dmcp.volume") ==
0) {
gulong volume;
g_object_get (dacp_share->priv->player,
"volume", &volume, NULL);
//g_debug ("Sending volume: %lu", volume);
dmap_structure_add (cmgt, DMAP_CC_CMVO,
volume);
} else {
g_warning ("Unhandled property %s",
*property);
}
}
g_strfreev (properties);
_dmap_share_message_set_from_dmap_structure (share, message,
cmgt);
dmap_structure_destroy (cmgt);
} else if (g_ascii_strcasecmp ("/1/setproperty", rest_of_path) == 0) {
if (g_hash_table_lookup (query, "dmcp.volume")) {
gdouble volume =
strtod (g_hash_table_lookup
(query, "dmcp.volume"), NULL);
g_object_set (dacp_share->priv->player, "volume",
(gulong) volume, NULL);
}
soup_message_set_status (message, SOUP_STATUS_NO_CONTENT);
} else if (g_ascii_strcasecmp ("/1/getspeakers", rest_of_path) == 0) {
GNode *casp;
casp = dmap_structure_add (NULL, DMAP_CC_CASP);
dmap_structure_add (casp, DMAP_CC_MSTT,
(gint32) DMAP_STATUS_OK);
dmap_structure_add (casp, DMAP_CC_MDCL);
dmap_structure_add (casp, DMAP_CC_CAIA, TRUE);
dmap_structure_add (casp, DMAP_CC_MINM, "Computer");
dmap_structure_add (casp, DMAP_CC_MSMA, (gint32) 0);
_dmap_share_message_set_from_dmap_structure (share, message,
casp);
dmap_structure_destroy (casp);
} else if (g_ascii_strcasecmp ("/1/playstatusupdate", rest_of_path) ==
0) {
gchar *revision =
g_hash_table_lookup (query, "revision-number");
gint revision_number = atoi (revision);
if (revision_number >= dacp_share->priv->current_revision) {
g_object_ref (message);
dacp_share->priv->update_queue =
g_slist_prepend (dacp_share->
priv->update_queue, message);
g_signal_connect_object (message, "finished",
G_CALLBACK
(status_update_message_finished),
dacp_share, 0);
soup_server_pause_message (server, message);
} else {
dacp_share_fill_playstatusupdate (dacp_share,
message);
}
} else if (g_ascii_strcasecmp ("/1/playpause", rest_of_path) == 0) {
dacp_player_play_pause (dacp_share->priv->player);
soup_message_set_status (message, SOUP_STATUS_NO_CONTENT);
} else if (g_ascii_strcasecmp ("/1/pause", rest_of_path) == 0) {
dacp_player_pause (dacp_share->priv->player);
soup_message_set_status (message, SOUP_STATUS_NO_CONTENT);
} else if (g_ascii_strcasecmp ("/1/nextitem", rest_of_path) == 0) {
dacp_player_next_item (dacp_share->priv->player);
soup_message_set_status (message, SOUP_STATUS_NO_CONTENT);
} else if (g_ascii_strcasecmp ("/1/previtem", rest_of_path) == 0) {
dacp_player_prev_item (dacp_share->priv->player);
soup_message_set_status (message, SOUP_STATUS_NO_CONTENT);
} else if (g_ascii_strcasecmp ("/1/nowplayingartwork", rest_of_path)
== 0) {
guint width = 320;
guint height = 320;
gchar *artwork_filename;
gchar *buffer;
gsize buffer_len;
if (g_hash_table_lookup (query, "mw"))
width = atoi (g_hash_table_lookup (query, "mw"));
if (g_hash_table_lookup (query, "mh"))
height = atoi (g_hash_table_lookup (query, "mh"));
artwork_filename =
dacp_player_now_playing_artwork (dacp_share->
priv->player, width,
height);
if (!artwork_filename) {
g_debug ("No artwork for currently playing song");
soup_message_set_status (message,
SOUP_STATUS_NOT_FOUND);
return;
}
#ifdef HAVE_GDKPIXBUF
GdkPixbuf *artwork =
gdk_pixbuf_new_from_file_at_scale (artwork_filename,
width, height,
TRUE, NULL);
if (!artwork) {
g_debug ("Error loading image file");
g_free (artwork_filename);
soup_message_set_status (message,
SOUP_STATUS_INTERNAL_SERVER_ERROR);
return;
}
if (!gdk_pixbuf_save_to_buffer
(artwork, &buffer, &buffer_len, "png", NULL, NULL)) {
g_debug ("Error saving artwork to PNG");
g_object_unref (artwork);
g_free (artwork_filename);
soup_message_set_status (message,
SOUP_STATUS_INTERNAL_SERVER_ERROR);
return;
}
g_object_unref (artwork);
#else
if (!g_file_get_contents
(artwork_filename, &buffer, &buffer_len, NULL)) {
g_debug ("Error getting artwork data");
g_free (artwork_filename);
soup_message_set_status (message,
SOUP_STATUS_INTERNAL_SERVER_ERROR);
return;
}
#endif
g_free (artwork_filename);
soup_message_set_status (message, SOUP_STATUS_OK);
soup_message_set_response (message, "image/png",
SOUP_MEMORY_TAKE, buffer,
buffer_len);
} else if (g_ascii_strcasecmp ("/1/cue", rest_of_path) == 0) {
gchar *command;
command = g_hash_table_lookup (query, "command");
if (!command) {
g_debug ("No CUE command specified");
soup_message_set_status (message,
SOUP_STATUS_NO_CONTENT);
return;
} else if (g_ascii_strcasecmp ("clear", command) == 0) {
dacp_player_cue_clear (dacp_share->priv->player);
soup_message_set_status (message,
SOUP_STATUS_NO_CONTENT);
} else if (g_ascii_strcasecmp ("play", command) == 0) {
GNode *cacr;
gchar *record_query;
gchar *sort_by;
GHashTable *records;
GList *sorted_records;
GSList *filter_def;
DMAPDb *db;
gint index =
atoi (g_hash_table_lookup (query, "index"));
g_object_get (share, "db", &db, NULL);
record_query = g_hash_table_lookup (query, "query");
filter_def = _dmap_share_build_filter (record_query);
records = dmap_db_apply_filter (db, filter_def);
sorted_records = g_hash_table_get_values (records);
sort_by = g_hash_table_lookup (query, "sort");
if (g_strcmp0 (sort_by, "album") == 0) {
sorted_records =
g_list_sort_with_data (sorted_records,
(GCompareDataFunc)
daap_record_cmp_by_album,
db);
} else if (sort_by != NULL) {
g_warning ("Unknown sort column: %s",
sort_by);
}
dacp_player_cue_play (dacp_share->priv->player,
sorted_records, index);
g_list_free (sorted_records);
g_hash_table_unref (records);
dmap_share_free_filter (filter_def);
cacr = dmap_structure_add (NULL, DMAP_CC_CACR);
dmap_structure_add (cacr, DMAP_CC_MSTT,
DMAP_STATUS_OK);
dmap_structure_add (cacr, DMAP_CC_MIID, index);
_dmap_share_message_set_from_dmap_structure (share,
message,
cacr);
dmap_structure_destroy (cacr);
} else {
g_warning ("Unhandled cue command: %s", command);
soup_message_set_status (message,
SOUP_STATUS_NO_CONTENT);
return;
}
} else {
g_warning ("Unhandled ctrl-int command: %s", rest_of_path);
soup_message_set_status (message, SOUP_STATUS_BAD_REQUEST);
}
}
void remmina_rdp_cliprdr_get_clipboard_data(RemminaProtocolWidget* gp, RemminaPluginRdpUiObject* ui)
{
RDP_CB_DATA_RESPONSE_EVENT* event;
GtkClipboard* clipboard;
UINT8* inbuf = NULL;
UINT8* outbuf = NULL;
GdkPixbuf *image = NULL;
int size = 0;
rfContext* rfi = GET_DATA(gp);
clipboard = gtk_widget_get_clipboard(rfi->drawing_area, GDK_SELECTION_CLIPBOARD);
if (clipboard)
{
switch (ui->clipboard.format)
{
case CB_FORMAT_TEXT:
case CB_FORMAT_UNICODETEXT:
case CB_FORMAT_HTML:
{
inbuf = (UINT8*)gtk_clipboard_wait_for_text(clipboard);
break;
}
case CB_FORMAT_PNG:
case CB_FORMAT_JPEG:
case CB_FORMAT_DIB:
{
image = gtk_clipboard_wait_for_image(clipboard);
break;
}
}
}
/* No data received, send nothing */
if (inbuf != NULL || image != NULL)
{
switch (ui->clipboard.format)
{
case CB_FORMAT_TEXT:
case CB_FORMAT_HTML:
{
size = strlen((char*)inbuf);
outbuf = lf2crlf(inbuf, &size);
break;
}
case CB_FORMAT_UNICODETEXT:
{
size = strlen((char*)inbuf);
inbuf = lf2crlf(inbuf, &size);
size = (ConvertToUnicode(CP_UTF8, 0, (CHAR*)inbuf, -1, (WCHAR**)&outbuf, 0) + 1) * 2;
g_free(inbuf);
break;
}
case CB_FORMAT_PNG:
{
gchar* data;
gsize buffersize;
gdk_pixbuf_save_to_buffer(image, &data, &buffersize, "png", NULL, NULL);
outbuf = (UINT8*) malloc(buffersize);
memcpy(outbuf, data, buffersize);
size = buffersize;
g_object_unref(image);
break;
}
case CB_FORMAT_JPEG:
{
gchar* data;
gsize buffersize;
gdk_pixbuf_save_to_buffer(image, &data, &buffersize, "jpeg", NULL, NULL);
outbuf = (UINT8*) malloc(buffersize);
memcpy(outbuf, data, buffersize);
size = buffersize;
g_object_unref(image);
break;
}
case CB_FORMAT_DIB:
{
gchar* data;
gsize buffersize;
gdk_pixbuf_save_to_buffer(image, &data, &buffersize, "bmp", NULL, NULL);
size = buffersize - 14;
outbuf = (UINT8*) malloc(size);
memcpy(outbuf, data + 14, size);
g_object_unref(image);
break;
}
}
}
event = (RDP_CB_DATA_RESPONSE_EVENT*)
freerdp_event_new(CliprdrChannel_Class, CliprdrChannel_DataResponse, NULL, NULL);
event->data = outbuf;
event->size = size;
freerdp_channels_send_event(rfi->instance->context->channels, (wMessage*) event);
}
char* generate_directory_icon(const char* p1, const char* p2,
const char* p3, const char* p4)
{
#define write_to_canvas(dest, src, x, y) \
change_corner_alpha (src, 0.1); \
gdk_pixbuf_composite(src, dest, x+1, y+1, 17-2, 17-2, x, y, 1, 1, GDK_INTERP_HYPER, 255);
GdkPixbuf *bg = gdk_pixbuf_new_from_inline(-1, dir_bg_4, TRUE, NULL);
GError* error = NULL;
g_assert(bg !=NULL);
if (p1 != NULL) {
error = NULL;
GdkPixbuf* icon = gdk_pixbuf_new_from_file_at_scale(p1, 17, -1,
TRUE, &error);
if (error == NULL) {
write_to_canvas(bg, icon, 6+1, 6);
g_object_unref(icon);
} else {
g_warning("[%s] generate_directory_icon: %s\n",
__func__, error->message);
g_warning("[%s] generate_directory_icon icon 1: %s fail\n",
__func__, p1);
g_error_free (error);
}
}
if (p2 != NULL) {
error = NULL;
GdkPixbuf* icon = gdk_pixbuf_new_from_file_at_scale(p2, 17, -1,
TRUE, &error);
if (error == NULL) {
write_to_canvas(bg, icon, 6+17 + 1, 6);
g_object_unref(icon);
} else {
g_warning("[%s] generate_directory_icon icon 2: %s fail\n",
__func__, p2);
g_warning("[%s] generate_directory_icon: %s\n",
__func__, error->message);
g_error_free (error);
}
}
if (p3 != NULL) {
error = NULL;
GdkPixbuf* icon = gdk_pixbuf_new_from_file_at_scale(p3, 17, -1,
TRUE, &error);
if (error == NULL) {
write_to_canvas(bg, icon, 6+1, 6+17);
g_object_unref(icon);
} else {
g_warning("[%s] generate_directory_icon icon 3: %s fail\n",
__func__, p3);
g_warning("[%s] generate_directory_icon 3: %s\n",
__func__, error->message);
g_error_free (error);
}
}
if (p4 != NULL) {
error = NULL;
GdkPixbuf* icon = gdk_pixbuf_new_from_file_at_scale(p4, 17, -1,
TRUE, &error);
if (error == NULL) {
write_to_canvas(bg, icon, 6+17 + 1, 6+17);
g_object_unref(icon);
} else {
g_warning("[%s] generate_directory_icon icon 4: %s fail\n",
__func__, p4);
g_warning("[%s] generate_directory_icon: %s\n",
__func__, error->message);
g_error_free (error);
}
}
gchar* buf = NULL;
gsize size = 0;
error = NULL;
gdk_pixbuf_save_to_buffer(bg, &buf, &size, "png", &error, NULL);
g_assert(buf != NULL);
if (error != NULL) {
g_warning("%s\n", error->message);
g_error_free(error);
g_free(buf);
return NULL;
}
char* base64 = g_base64_encode((const guchar*)buf, size);
g_free(buf);
char* data = g_strdup_printf("data:image/png;base64,%s", base64);
g_free(base64);
return data;
}
static void format_contact(DBusContact* contact, ContactData* c) {
gchar* firstname;
gchar* lastname;
GValueArray* email = NULL;
GValue email_member = {0};
gchar* str;
gchar* image = NULL;
gsize size;
contact->data = hash_table_new();
contact->emails = g_value_email_new();
firstname = lastname = NULL;
if (c->name) {
gchar* pos = strchr(c->name, ' ');
if (pos) {
firstname = g_strndup(c->name, pos - c->name);
lastname = g_strdup(++pos);
g_hash_table_replace(contact->data,
g_strdup("first-name"), convert_2_utf8(firstname));
g_hash_table_replace(contact->data,
g_strdup("last-name"), convert_2_utf8(lastname));
}
else {
lastname = g_strdup(c->name);
g_hash_table_replace(contact->data,
g_strdup("last-name"), convert_2_utf8(lastname));
}
g_free(firstname);
g_free(lastname);
}
if (c->cn) {
g_hash_table_replace(contact->data,
g_strdup("cn"), convert_2_utf8(c->cn));
}
if (c->picture) {
gdk_pixbuf_save_to_buffer(
c->picture, &image, &size, "png", NULL, NULL);
g_hash_table_replace(contact->data,
g_strdup("image"), g_base64_encode((const guchar *) image, size));
}
email = g_value_array_new(0);
/* Alias is not available but needed so make an empty string */
g_value_init(&email_member, G_TYPE_STRING);
g_value_set_string(&email_member, "");
g_value_array_append(email, &email_member);
g_value_unset(&email_member);
if (c->email)
str = convert_2_utf8(c->email);
else
str = g_strdup("");
g_value_init(&email_member, G_TYPE_STRING);
g_value_set_string(&email_member, str);
g_value_array_append(email, &email_member);
g_value_unset(&email_member);
g_free(str);
if (c->remarks)
str = convert_2_utf8(c->remarks);
else
str = g_strdup("");
g_value_init(&email_member, G_TYPE_STRING);
g_value_set_string(&email_member, str);
g_value_array_append(email, &email_member);
g_value_unset(&email_member);
g_free(str);
g_ptr_array_add(contact->emails, email);
}
/**
* as_icon_convert_to_kind:
* @icon: a #AsIcon instance.
* @kind: a %AsIconKind, e.g. #AS_ICON_KIND_EMBEDDED
* @error: A #GError or %NULL.
*
* Converts the icon from one kind to another.
*
* Returns: %TRUE for success
*
* Since: 0.3.1
**/
gboolean
as_icon_convert_to_kind (AsIcon *icon, AsIconKind kind, GError **error)
{
AsIconPrivate *priv = GET_PRIVATE (icon);
/* these can't be converted */
if (priv->kind == AS_ICON_KIND_STOCK ||
priv->kind == AS_ICON_KIND_REMOTE)
return TRUE;
/* no change */
if (priv->kind == kind)
return TRUE;
/* cached -> embedded */
if (priv->kind == AS_ICON_KIND_CACHED && kind == AS_ICON_KIND_EMBEDDED) {
gsize data_size;
g_autoptr(GBytes) tmp = NULL;
g_autofree gchar *data = NULL;
/* load the pixbuf and save it to a PNG buffer */
if (priv->pixbuf == NULL) {
if (!as_icon_load (icon, AS_ICON_LOAD_FLAG_SEARCH_SIZE, error))
return FALSE;
}
if (!gdk_pixbuf_save_to_buffer (priv->pixbuf, &data, &data_size,
"png", error, NULL))
return FALSE;
/* set the PNG buffer to a blob of data */
tmp = g_bytes_new (data, data_size);
as_icon_set_data (icon, tmp);
as_icon_set_kind (icon, kind);
return TRUE;
}
/* cached -> embedded */
if (priv->kind == AS_ICON_KIND_EMBEDDED && kind == AS_ICON_KIND_CACHED) {
g_autofree gchar *size_str = NULL;
g_autofree gchar *path = NULL;
g_autofree gchar *fn = NULL;
/* ensure the parent path exists */
size_str = g_strdup_printf ("%ux%u", priv->width, priv->height);
path = g_build_filename (priv->prefix, size_str, NULL);
if (g_mkdir_with_parents (path, 0700) != 0) {
g_set_error (error,
AS_ICON_ERROR,
AS_ICON_ERROR_FAILED,
"Failed to create: %s", path);
return FALSE;
}
/* save the pixbuf */
fn = g_build_filename (path, priv->name, NULL);
if (!gdk_pixbuf_save (priv->pixbuf, fn, "png", error, NULL))
return FALSE;
as_icon_set_kind (icon, kind);
return TRUE;
}
/* not supported */
g_set_error (error,
AS_ICON_ERROR,
AS_ICON_ERROR_FAILED,
"converting %s to %s is not supported",
as_icon_kind_to_string (priv->kind),
as_icon_kind_to_string (kind));
return FALSE;
}
static gboolean
prepare_image (const gchar *image_filename,
gchar **file_contents,
gsize *length,
GdkPixbuf **use_pixbuf,
gboolean can_claim)
{
gboolean res = FALSE;
g_return_val_if_fail (image_filename != NULL, FALSE);
g_return_val_if_fail (file_contents != NULL, FALSE);
g_return_val_if_fail (length != NULL, FALSE);
if (g_file_get_contents (image_filename, file_contents, length, NULL)) {
GError *error = NULL;
GdkPixbuf *pixbuf;
GdkPixbufLoader *loader = gdk_pixbuf_loader_new ();
if (!gdk_pixbuf_loader_write (loader, (const guchar *)(*file_contents), *length, &error)
|| !gdk_pixbuf_loader_close (loader, &error)
|| (pixbuf = gdk_pixbuf_loader_get_pixbuf (loader)) == NULL) {
const gchar *err = _("Unknown error");
if (error && error->message)
err = error->message;
if (can_claim)
e_alert_run_dialog_for_args (NULL, "org.gnome.evolution.plugins.face:not-an-image", err, NULL);
if (error)
g_error_free (error);
} else {
gint width, height;
height = gdk_pixbuf_get_height (pixbuf);
width = gdk_pixbuf_get_width (pixbuf);
if (height <= 0 || width <= 0) {
if (can_claim)
e_alert_run_dialog_for_args (NULL, "org.gnome.evolution.plugins.face:invalid-image-size", NULL, NULL);
} else if (height != 48 || width != 48) {
GdkPixbuf *copy, *scale;
guchar *pixels;
guint32 fill;
if (width >= height) {
if (width > 48) {
gdouble ratio = (gdouble) width / 48.0;
width = 48;
height = height / ratio;
if (height == 0)
height = 1;
}
} else {
if (height > 48) {
gdouble ratio = (gdouble) height / 48.0;
height = 48;
width = width / ratio;
if (width == 0)
width = 1;
}
}
scale = e_icon_factory_pixbuf_scale (pixbuf, width, height);
copy = e_icon_factory_pixbuf_scale (pixbuf, 48, 48);
width = gdk_pixbuf_get_width (scale);
height = gdk_pixbuf_get_height (scale);
pixels = gdk_pixbuf_get_pixels (scale);
/* fill with a pixel color at [0,0] */
fill = (pixels[0] << 24) | (pixels[1] << 16) | (pixels[2] << 8) | (pixels[0]);
gdk_pixbuf_fill (copy, fill);
gdk_pixbuf_copy_area (scale, 0, 0, width, height, copy, width < 48 ? (48 - width) / 2 : 0, height < 48 ? (48 - height) / 2 : 0);
g_free (*file_contents);
*file_contents = NULL;
*length = 0;
res = gdk_pixbuf_save_to_buffer (copy, file_contents, length, "png", NULL, "compression", "9", NULL);
if (res && use_pixbuf)
*use_pixbuf = g_object_ref (copy);
g_object_unref (copy);
g_object_unref (scale);
} else {
res = TRUE;
if (use_pixbuf)
*use_pixbuf = g_object_ref (pixbuf);
}
}
g_object_unref (loader);
} else {
if (can_claim)
e_alert_run_dialog_for_args (NULL, "org.gnome.evolution.plugins.face:file-not-found", NULL, NULL);
}
return res;
}
void remmina_rdp_cliprdr_get_clipboard_data(RemminaProtocolWidget* gp, RemminaPluginRdpUiObject* ui)
{
TRACE_CALL(__func__);
GtkClipboard* gtkClipboard;
UINT8* inbuf = NULL;
UINT8* outbuf = NULL;
GdkPixbuf *image = NULL;
int size = 0;
rfContext* rfi = GET_PLUGIN_DATA(gp);
RemminaPluginRdpEvent rdp_event = { 0 };
CLIPRDR_FORMAT_DATA_RESPONSE* pFormatDataResponse;
gtkClipboard = gtk_widget_get_clipboard(rfi->drawing_area, GDK_SELECTION_CLIPBOARD);
if (gtkClipboard) {
switch (ui->clipboard.format) {
case CF_TEXT:
case CF_UNICODETEXT:
case CB_FORMAT_HTML:
{
inbuf = (UINT8*)gtk_clipboard_wait_for_text(gtkClipboard);
break;
}
case CB_FORMAT_PNG:
case CB_FORMAT_JPEG:
case CF_DIB:
case CF_DIBV5:
{
image = gtk_clipboard_wait_for_image(gtkClipboard);
break;
}
}
}
/* No data received, send nothing */
if (inbuf != NULL || image != NULL) {
switch (ui->clipboard.format) {
case CF_TEXT:
case CB_FORMAT_HTML:
{
size = strlen((char*)inbuf);
outbuf = lf2crlf(inbuf, &size);
break;
}
case CF_UNICODETEXT:
{
size = strlen((char*)inbuf);
inbuf = lf2crlf(inbuf, &size);
size = (ConvertToUnicode(CP_UTF8, 0, (CHAR*)inbuf, -1, (WCHAR**)&outbuf, 0) ) * sizeof(WCHAR);
g_free(inbuf);
break;
}
case CB_FORMAT_PNG:
{
gchar* data;
gsize buffersize;
gdk_pixbuf_save_to_buffer(image, &data, &buffersize, "png", NULL, NULL);
outbuf = (UINT8*)malloc(buffersize);
memcpy(outbuf, data, buffersize);
size = buffersize;
g_object_unref(image);
break;
}
case CB_FORMAT_JPEG:
{
gchar* data;
gsize buffersize;
gdk_pixbuf_save_to_buffer(image, &data, &buffersize, "jpeg", NULL, NULL);
outbuf = (UINT8*)malloc(buffersize);
memcpy(outbuf, data, buffersize);
size = buffersize;
g_object_unref(image);
break;
}
case CF_DIB:
case CF_DIBV5:
{
gchar* data;
gsize buffersize;
gdk_pixbuf_save_to_buffer(image, &data, &buffersize, "bmp", NULL, NULL);
size = buffersize - 14;
outbuf = (UINT8*)malloc(size);
memcpy(outbuf, data + 14, size);
g_object_unref(image);
break;
}
}
}
pFormatDataResponse = (CLIPRDR_FORMAT_DATA_RESPONSE*)malloc(sizeof(CLIPRDR_FORMAT_DATA_RESPONSE));
if (!pFormatDataResponse) {
if (outbuf) free(outbuf);
return;
}
ZeroMemory(pFormatDataResponse, sizeof(CLIPRDR_FORMAT_DATA_RESPONSE));
rdp_event.type = REMMINA_RDP_EVENT_TYPE_CLIPBOARD_SEND_CLIENT_FORMAT_DATA_RESPONSE;
rdp_event.clipboard_formatdataresponse.pFormatDataResponse = pFormatDataResponse;
pFormatDataResponse->msgFlags = CB_RESPONSE_OK;
pFormatDataResponse->dataLen = size;
pFormatDataResponse->requestedFormatData = outbuf;
remmina_rdp_event_event_push(gp, &rdp_event);
}