static void
gimp_pick_button_pick (GdkScreen *screen,
gint x_root,
gint y_root,
GimpPickButton *button)
{
GdkWindow *root_window = gdk_screen_get_root_window (screen);
cairo_surface_t *image;
cairo_t *cr;
guchar *data;
guchar color[3];
GimpRGB rgb;
image = cairo_image_surface_create (CAIRO_FORMAT_RGB24, 1, 1);
cr = cairo_create (image);
gdk_cairo_set_source_window (cr, root_window, -x_root, -y_root);
cairo_paint (cr);
cairo_destroy (cr);
data = cairo_image_surface_get_data (image);
GIMP_CAIRO_RGB24_GET_PIXEL (data, color[0], color[1], color[2]);
cairo_surface_destroy (image);
gimp_rgba_set_uchar (&rgb, color[0], color[1], color[2], 1.0);
g_signal_emit (button, pick_button_signals[COLOR_PICKED], 0, &rgb);
}
JS_EXPORT_API
void dock_draw_window_preview(JSValueRef canvas, double xid, double dest_width, double dest_height)
{
GdkWindow* win = gdk_x11_window_foreign_new_for_display(gdk_display_get_default(), (long)xid);
if (win == NULL) {
return;
}
if (JSValueIsNull(get_global_context(), canvas)) {
g_debug("draw_window_preview with null canvas!");
return;
}
cairo_t* cr = fetch_cairo_from_html_canvas(get_global_context(), canvas);
if (cr == NULL) {
return;
}
cairo_save(cr);
//clear preview content to prevent translucency window problem
cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR);
cairo_paint(cr);
cairo_restore(cr);
int width = gdk_window_get_width(win);
int height = gdk_window_get_height(win);
cairo_save(cr);
double scale = 0;
if (width > height) {
scale = dest_width/width;
cairo_scale(cr, scale, scale);
gdk_cairo_set_source_window(cr, win, 0, 0.5*(dest_height/scale-height));
} else {
scale = dest_height/height;
cairo_scale(cr, scale, scale);
gdk_cairo_set_source_window(cr, win, 0.5*(dest_width/scale-width), 0);
}
cairo_paint(cr);
cairo_restore(cr);
canvas_custom_draw_did(cr, NULL);
}
PRIVATE void
draw_tray_icon(GdkWindow* wrapper, gpointer no_use, cairo_t* cr)
{
static cairo_surface_t* left = NULL;
static cairo_surface_t* right = NULL;
if (left == NULL)
left = cairo_image_surface_create_from_png(TRAY_LEFT_LINE_PATH);
if (right == NULL)
right = cairo_image_surface_create_from_png(TRAY_RIGHT_LINE_PATH);
GdkWindow* icon = get_icon_window(wrapper);
g_assert(GDK_IS_WINDOW(wrapper));
if (!gdk_window_is_destroyed(icon)) {
gboolean is_in = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(wrapper), "is_mouse_in"));
int x = 0;
int y = 0;
gdk_window_get_geometry(wrapper, &x, &y, NULL, NULL); //gdk_window_get_position will get error value when dock is hidden!
cairo_save(cr);
if (wrapper == _deepin_tray || !is_in) {
gdk_cairo_set_source_window(cr, icon, x, y);
cairo_paint(cr);
} else {
if (cairo_surface_status(left) == CAIRO_STATUS_SUCCESS) {
cairo_set_source_surface(cr, left, x - 4, y - 3);
cairo_paint(cr);
}
gdk_cairo_set_source_window(cr, icon, x, y);
cairo_paint(cr);
if (cairo_surface_status(right) == CAIRO_STATUS_SUCCESS) {
cairo_set_source_surface(cr, right, x + gdk_window_get_width(wrapper) + 2, y - 3);
cairo_paint(cr);
}
}
cairo_restore(cr);
}
}
gboolean background_info_draw_callback(GtkWidget* w, cairo_t* cr,
BackgroundInfo* info)
{
if (info->bg != NULL) {
g_mutex_lock(&info->m);
cairo_set_source_surface(cr, info->bg, 0, 0);
cairo_paint_with_alpha(cr, info->alpha);
g_mutex_unlock(&info->m);
}
GList* children = gtk_container_get_children(GTK_CONTAINER(w));
for (GList* l = children; l != NULL; l = l->next) {
GtkWidget* child = GTK_WIDGET(l->data);
if (gtk_widget_get_visible(child)) {
gdk_cairo_set_source_window(cr,
gtk_widget_get_window(child), 0, 0);
cairo_paint(cr);
}
}
g_list_free(children);
return TRUE;
}
static cairo_surface_t *
snapshot_widget (GtkWidget *widget, SnapshotMode mode)
{
cairo_surface_t *surface;
cairo_pattern_t *bg;
GMainLoop *loop;
cairo_t *cr;
g_assert (gtk_widget_get_realized (widget));
surface = gdk_window_create_similar_surface (gtk_widget_get_window (widget),
CAIRO_CONTENT_COLOR,
gtk_widget_get_allocated_width (widget),
gtk_widget_get_allocated_height (widget));
loop = g_main_loop_new (NULL, FALSE);
/* We wait until the widget is drawn for the first time.
* We can not wait for a GtkWidget::draw event, because that might not
* happen if the window is fully obscured by windowed child widgets.
* Alternatively, we could wait for an expose event on widget's window.
* Both of these are rather hairy, not sure what's best. */
gdk_event_handler_set (check_for_draw, loop, NULL);
g_main_loop_run (loop);
cr = cairo_create (surface);
switch (mode)
{
case SNAPSHOT_WINDOW:
{
GdkWindow *window = gtk_widget_get_window (widget);
if (gdk_window_get_window_type (window) == GDK_WINDOW_TOPLEVEL ||
gdk_window_get_window_type (window) == GDK_WINDOW_FOREIGN)
{
/* give the WM/server some time to sync. They need it.
* Also, do use popups instead of toplevls in your tests
* whenever you can. */
gdk_display_sync (gdk_window_get_display (window));
g_timeout_add (500, quit_when_idle, loop);
g_main_loop_run (loop);
}
gdk_cairo_set_source_window (cr, window, 0, 0);
cairo_paint (cr);
}
break;
case SNAPSHOT_DRAW:
bg = gdk_window_get_background_pattern (gtk_widget_get_window (widget));
if (bg)
{
cairo_set_source (cr, bg);
cairo_paint (cr);
}
gtk_widget_draw (widget, cr);
break;
default:
g_assert_not_reached();
break;
}
cairo_destroy (cr);
g_main_loop_unref (loop);
gtk_widget_destroy (widget);
return surface;
}
static void
gimp_pick_button_pick (GimpPickButton *button,
GdkEvent *event)
{
GdkScreen *screen = gdk_event_get_screen (event);
GimpColorProfile *monitor_profile;
GdkMonitor *monitor;
GimpRGB rgb;
gint x_root;
gint y_root;
gdouble x_win;
gdouble y_win;
gdk_window_get_origin (gdk_event_get_window (event), &x_root, &y_root);
gdk_event_get_coords (event, &x_win, &y_win);
x_root += x_win;
y_root += y_win;
#ifdef G_OS_WIN32
{
HDC hdc;
RECT rect;
COLORREF win32_color;
/* For MS Windows, use native GDI functions to get the pixel, as
* cairo does not handle the case where you have multiple monitors
* with a monitor on the left or above the primary monitor. That
* scenario create a cairo primary surface with negative extent,
* which is not handled properly (bug 740634).
*/
hdc = GetDC (HWND_DESKTOP);
GetClipBox (hdc, &rect);
win32_color = GetPixel (hdc, x_root + rect.left, y_root + rect.top);
ReleaseDC (HWND_DESKTOP, hdc);
gimp_rgba_set_uchar (&rgb,
GetRValue (win32_color),
GetGValue (win32_color),
GetBValue (win32_color),
255);
}
#else
{
GdkWindow *window;
gint x_window;
gint y_window;
cairo_surface_t *image;
cairo_t *cr;
guchar *data;
guchar color[3];
/* we try to pick from the local window under the cursor, and fall
* back to picking from the root window if this fails (i.e., if
* the cursor is not under a local window). on wayland, picking
* from the root window is not supported, so this at least allows
* us to pick from local windows. see bug #780375.
*/
window = gdk_device_get_window_at_position (gdk_event_get_device (event),
&x_window, &y_window);
if (! window)
{
window = gdk_screen_get_root_window (screen);
x_window = x_root;
y_window = y_root;
}
image = cairo_image_surface_create (CAIRO_FORMAT_RGB24, 1, 1);
cr = cairo_create (image);
gdk_cairo_set_source_window (cr, window, -x_window, -y_window);
cairo_paint (cr);
cairo_destroy (cr);
data = cairo_image_surface_get_data (image);
GIMP_CAIRO_RGB24_GET_PIXEL (data, color[0], color[1], color[2]);
cairo_surface_destroy (image);
gimp_rgba_set_uchar (&rgb, color[0], color[1], color[2], 255);
}
#endif
monitor = gdk_display_get_monitor_at_point (gdk_screen_get_display (screen),
x_root, y_root);
monitor_profile = gimp_monitor_get_color_profile (monitor);
if (monitor_profile)
{
GimpColorProfile *srgb_profile;
GimpColorTransform *transform;
const Babl *format;
GimpColorTransformFlags flags = 0;
format = babl_format ("R'G'B'A double");
flags |= GIMP_COLOR_TRANSFORM_FLAGS_NOOPTIMIZE;
flags |= GIMP_COLOR_TRANSFORM_FLAGS_BLACK_POINT_COMPENSATION;
srgb_profile = gimp_color_profile_new_rgb_srgb ();
transform = gimp_color_transform_new (monitor_profile, format,
srgb_profile, format,
GIMP_COLOR_RENDERING_INTENT_PERCEPTUAL,
flags);
g_object_unref (srgb_profile);
if (transform)
{
gimp_color_transform_process_pixels (transform,
format, &rgb,
format, &rgb,
1);
gimp_rgb_clamp (&rgb);
g_object_unref (transform);
}
}
g_signal_emit_by_name (button, "color-picked", &rgb);
}
