static void
map (GtkWidget *widget)
{
/* Chain up to realize our children */
GTK_WIDGET_CLASS (athena_desktop_window_parent_class)->map (widget);
gdk_window_lower (gtk_widget_get_window (widget));
}
void fm_turn_on_desktop_icons()
{
GdkDisplay * gdpy;
gint i;
int big = 0;
if( ! group )
group = gtk_window_group_new();
theme_change_notify = g_signal_connect( gtk_icon_theme_get_default(), "changed",
G_CALLBACK(on_icon_theme_changed), NULL );
vfs_mime_type_get_icon_size( &big, NULL );
gdpy = gdk_display_get_default();
n_screens = gdk_display_get_n_screens( gdpy );
desktops = g_new( GtkWidget *, n_screens );
for ( i = 0; i < n_screens; i++ )
{
desktops[ i ] = desktop_window_new();
desktop_window_set_icon_size( (DesktopWindow*)desktops[ i ], big );
desktop_window_set_single_click( (DesktopWindow*)desktops[ i ], app_settings.single_click );
gtk_widget_realize( desktops[ i ] ); /* without this, setting wallpaper won't work */
gtk_widget_show_all( desktops[ i ] );
gdk_window_lower( desktops[ i ] ->window );
gtk_window_group_add_window( GTK_WINDOW_GROUP(group), GTK_WINDOW( desktops[i] ) );
}
fm_desktop_update_colors();
fm_desktop_update_wallpaper();
}
static void term_app_request(VteTerminal *term, gpointer user_data) {
int event = GPOINTER_TO_INT(user_data);
if (event == TERM_ICONIFY_WINDOW) {
gdk_window_iconify(GTK_WIDGET(mainwindow)->window);
}
if (event == TERM_DEICONIFY_WINDOW) {
gdk_window_deiconify(GTK_WIDGET(mainwindow)->window);
}
if (event == TERM_RAISE_WINDOW) {
gdk_window_raise(GTK_WIDGET(mainwindow)->window);
}
if (event == TERM_LOWER_WINDOW) {
gdk_window_lower(GTK_WIDGET(mainwindow)->window);
}
if (event == TERM_MAXIMIZE_WINDOW) {
gdk_window_maximize(GTK_WIDGET(mainwindow)->window);
}
if (event == TERM_RESTORE_WINDOW) {
gdk_window_unmaximize(GTK_WIDGET(mainwindow)->window);
}
if (event == TERM_REFRESH_WINDOW) {
GdkRectangle rect;
rect.x = rect.y = 0;
rect.width = mainwindow->allocation.width;
rect.height = mainwindow->allocation.height;
gdk_window_invalidate_rect(GTK_WIDGET(mainwindow)->window, &rect, TRUE);
}
}
static PyObject *
PyGdkWindow_Lower(PyGdkWindow_Object *self, PyObject *args)
{
if (!PyArg_ParseTuple(args, ":GdkWindow.lower"))
return NULL;
gdk_window_lower(self->obj);
Py_INCREF(Py_None);
return Py_None;
}
static void
lower_window(GtkWidget *widget, gpointer data)
{
if (GTK_IS_WIDGET(data)) {
if ((GTK_WIDGET(data))->window) {
gdk_window_lower((GTK_WIDGET(data))->window);
}
}
}
static void lower_window_cb (G_GNUC_UNUSED GtkWidget *widget, gpointer data)
{
DEBUG_FUNCTION ("lower_window_cb");
DEBUG_ASSERT (data != NULL);
if (GTK_IS_WIDGET(data))
if (gtk_widget_get_window (GTK_WIDGET (data)))
gdk_window_lower (gtk_widget_get_window (GTK_WIDGET (data)));
}
static void
lower_window(GtkWidget *widget, gpointer data)
{
GdkWindow *window;
if (GTK_IS_WIDGET(data)) {
window = gtk_widget_get_window(GTK_WIDGET(data));
if (window) {
gdk_window_lower(window);
}
}
}
int iupdrvBaseSetZorderAttrib(Ihandle* ih, const char* value)
{
if (iupdrvIsVisible(ih))
{
GdkWindow* window = ih->handle->window;
if (iupStrEqualNoCase(value, "TOP"))
gdk_window_raise(window);
else
gdk_window_lower(window);
}
return 0;
}
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GtkWindowPeer_toBack (JNIEnv *env,
jobject obj)
{
void *ptr;
ptr = NSA_GET_PTR (env, obj);
gdk_threads_enter ();
gdk_window_lower (GTK_WIDGET (ptr)->window);
XFlush (GDK_DISPLAY ());
gdk_threads_leave ();
}
static void
map (GtkWidget *widget)
{
/* Chain up to realize our children */
GTK_WIDGET_CLASS (nemo_blank_desktop_window_parent_class)->map (widget);
gdk_window_lower (gtk_widget_get_window (widget));
GdkWindow *window;
GdkRGBA transparent = { 0, 0, 0, 0 };
window = gtk_widget_get_window (widget);
gdk_window_set_background_rgba (window, &transparent);
}
void
frame_window_realized (GtkWidget *widget,
gpointer data)
{
decor_t *d = (decor_t *) data;
if (d)
{
GdkWindow *gdk_frame_window = gtk_widget_get_window (d->decor_window);
gdk_window_reparent (gdk_frame_window, d->frame_window, 0, 0);
gdk_window_lower (gdk_frame_window);
}
}
/*Lowers window to the bottom of the Z-order (stacking order), so
that other windows with the same parent window appear above window.*/
int
clip_GDK_WINDOWLOWER(ClipMachine * cm)
{
C_widget *cwin = _fetch_cw_arg(cm);
GdkWindow *win = NULL;
CHECKCWID(cwin,GTK_IS_WIDGET);
if (cwin && cwin->widget) win = cwin->widget->window;
gdk_window_lower(win);
return 0;
err:
return 1;
}
JNIEXPORT void JNICALL
Java_org_gnome_gdk_GdkWindow_gdk_1window_1lower
(
JNIEnv* env,
jclass cls,
jlong _self
)
{
GdkWindow* self;
// convert parameter self
self = (GdkWindow*) _self;
// call function
gdk_window_lower(self);
// cleanup parameter self
}
static void
deemphasize_window (GtkWidget *window)
{
GdkDisplay *display;
display = gtk_widget_get_display (window);
if (gdk_display_is_composited (display))
{
cairo_rectangle_int_t rect;
cairo_region_t *region;
gtk_widget_set_opacity (window, 0.3);
rect.x = rect.y = rect.width = rect.height = 0;
region = cairo_region_create_rectangle (&rect);
gtk_widget_input_shape_combine_region (window, region);
cairo_region_destroy (region);
}
else
gdk_window_lower (gtk_widget_get_window (window));
}
static void
lower_window_clicked (GtkWidget *button,
gpointer data)
{
GList *selected, *l;
GdkWindow *window;
selected = get_selected_windows ();
for (l = selected; l != NULL; l = l->next)
{
window = l->data;
gdk_window_lower (window);
}
g_list_free (selected);
update_store ();
}
void onPlay(GtkButton *button, gpointer user_data)
{
intf_thread_t *p_intf = GtkGetIntf( GTK_WIDGET( button ) );
playlist_t *p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST, FIND_ANYWHERE );
if (p_playlist)
{
vlc_mutex_lock( &p_playlist->object_lock );
if (p_playlist->i_size)
{
vlc_mutex_unlock( &p_playlist->object_lock );
playlist_Play( p_playlist );
gdk_window_lower( p_intf->p_sys->p_window->window );
}
else
{
vlc_mutex_unlock( &p_playlist->object_lock );
}
vlc_object_release( p_playlist );
}
}
static void deepin_workspace_overview_realize (GtkWidget *widget)
{
DeepinWorkspaceOverview *self = DEEPIN_WORKSPACE_OVERVIEW (widget);
DeepinWorkspaceOverviewPrivate *priv = self->priv;
GtkAllocation allocation;
GdkWindow *window;
GdkWindowAttr attributes;
gint attributes_mask;
gtk_widget_get_allocation (widget, &allocation);
gtk_widget_set_realized (widget, TRUE);
attributes.window_type = GDK_WINDOW_CHILD;
attributes.x = allocation.x;
attributes.y = allocation.y;
attributes.width = allocation.width;
attributes.height = allocation.height;
attributes.wclass = GDK_INPUT_ONLY;
attributes.event_mask = gtk_widget_get_events (widget);
attributes.event_mask |= (GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_ENTER_NOTIFY_MASK |
GDK_EXPOSURE_MASK |
GDK_LEAVE_NOTIFY_MASK);
attributes_mask = GDK_WA_X | GDK_WA_Y;
window = gtk_widget_get_parent_window (widget);
gtk_widget_set_window (widget, window);
g_object_ref (window);
priv->event_window = gdk_window_new (window,
&attributes, attributes_mask);
gtk_widget_register_window (widget, priv->event_window);
gdk_window_lower(priv->event_window);
}
void
gtk_inspector_on_inspect (GtkWidget *button,
GtkInspectorWindow *iw)
{
GdkDisplay *display;
GdkDevice *device;
GdkCursor *cursor;
g_signal_connect (button, "event",
G_CALLBACK (property_query_event), iw);
display = gtk_widget_get_display (button);
cursor = gdk_cursor_new_for_display (display, GDK_CROSSHAIR);
device = gdk_device_manager_get_client_pointer (gdk_display_get_device_manager (display));
gdk_device_grab (device,
gtk_widget_get_window (GTK_WIDGET (button)),
GDK_OWNERSHIP_NONE, TRUE,
GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK,
cursor, GDK_CURRENT_TIME);
g_object_unref (cursor);
gtk_grab_add (GTK_WIDGET (button));
gdk_window_lower (gtk_widget_get_window (GTK_WIDGET (iw)));
}
void
meta_draw_window_decoration (decor_t *d)
{
Display *xdisplay =
GDK_DISPLAY_XDISPLAY (gdk_display_get_default ());
cairo_surface_t *surface;
Picture src;
MetaButtonState button_states [META_BUTTON_TYPE_LAST];
MetaButtonLayout button_layout;
MetaFrameGeometry fgeom;
MetaFrameFlags flags;
MetaFrameType frame_type;
MetaTheme *theme;
GtkStyleContext *context;
cairo_t *cr;
gint i;
GdkRectangle clip;
Region top_region = NULL;
Region bottom_region = NULL;
Region left_region = NULL;
Region right_region = NULL;
gdouble meta_active_opacity, meta_inactive_opacity;
gboolean meta_active_shade_opacity, meta_inactive_shade_opacity;
g_object_get (settings, "metacity-active-opacity", &meta_active_opacity, NULL);
g_object_get (settings, "metacity-inactive-opacity", &meta_inactive_opacity, NULL);
g_object_get (settings, "metacity-active-shade-opacity", &meta_active_shade_opacity, NULL);
g_object_get (settings, "metacity-inactive-shade-opacity", &meta_inactive_shade_opacity, NULL);
double alpha = (d->active) ? meta_active_opacity : meta_inactive_opacity;
gboolean shade_alpha = (d->active) ? meta_active_shade_opacity :
meta_inactive_shade_opacity;
MetaFrameStyle *frame_style;
GtkWidget *style_window;
GdkRGBA bg_rgba;
if (!d->surface || !d->picture)
return;
if (decoration_alpha == 1.0)
alpha = 1.0;
if (cairo_xlib_surface_get_depth (d->surface) == 32)
{
context = gtk_widget_get_style_context (d->frame->style_window_rgba);
style_window = d->frame->style_window_rgba;
}
else
{
context = gtk_widget_get_style_context (d->frame->style_window_rgb);
style_window = d->frame->style_window_rgb;
}
cr = cairo_create (d->buffer_surface ? d->buffer_surface : d->surface);
cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
theme = meta_theme_get_current ();
frame_type = meta_frame_type_from_string (d->frame->type);
if (frame_type == META_FRAME_TYPE_LAST)
frame_type = META_FRAME_TYPE_NORMAL;
meta_get_decoration_geometry (d, theme, &flags, &fgeom, &button_layout,
frame_type, &clip);
if ((d->prop_xid || !d->buffer_surface) && !d->frame_window)
draw_shadow_background (d, cr, d->shadow, d->context);
for (i = 0; i < META_BUTTON_TYPE_LAST; ++i)
button_states[i] = meta_button_state_for_button_type (d, i);
frame_style = meta_theme_get_frame_style (theme,
frame_type,
flags);
gtk_style_context_get_background_color (context, GTK_STATE_FLAG_NORMAL, &bg_rgba);
bg_rgba.alpha = 1.0;
if (frame_style->window_background_color)
{
meta_color_spec_render (frame_style->window_background_color,
gtk_widget_get_style_context (style_window),
&bg_rgba);
bg_rgba.alpha = frame_style->window_background_alpha / 255.0;
}
/* Draw something that will be almost invisible to user. This is hacky way
* to fix invisible decorations. */
cairo_set_source_rgba (cr, 0, 0, 0, 0.01);
cairo_rectangle (cr, 0, 0, 1, 1);
cairo_fill (cr);
/* ------------ */
cairo_destroy (cr);
if (d->frame_window)
surface = create_surface (clip.width, clip.height, d->frame->style_window_rgb);
else
surface = create_surface (clip.width, clip.height, d->frame->style_window_rgba);
cr = cairo_create (surface);
gdk_cairo_set_source_rgba (cr, &bg_rgba);
cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
src = XRenderCreatePicture (xdisplay, cairo_xlib_surface_get_drawable (surface),
get_format_for_surface (d, surface), 0, NULL);
cairo_paint (cr);
meta_theme_draw_frame (theme,
style_window,
cr,
frame_type,
flags,
clip.width - fgeom.left_width - fgeom.right_width,
clip.height - fgeom.top_height - fgeom.bottom_height,
d->layout,
d->frame->text_height,
&button_layout,
button_states,
d->icon_pixbuf,
NULL);
if (fgeom.top_height)
{
top_region = meta_get_top_border_region (&fgeom, clip.width);
decor_blend_border_picture (xdisplay,
d->context,
src,
0, 0,
d->picture,
&d->border_layout,
BORDER_TOP,
top_region,
alpha * 0xffff,
shade_alpha,
0);
}
if (fgeom.bottom_height)
{
bottom_region = meta_get_bottom_border_region (&fgeom, clip.width);
decor_blend_border_picture (xdisplay,
d->context,
src,
0, clip.height - fgeom.bottom_height,
d->picture,
&d->border_layout,
BORDER_BOTTOM,
bottom_region,
alpha * 0xffff,
shade_alpha,
0);
}
if (fgeom.left_width)
{
left_region = meta_get_left_border_region (&fgeom, clip.height);
decor_blend_border_picture (xdisplay,
d->context,
src,
0, fgeom.top_height,
d->picture,
&d->border_layout,
BORDER_LEFT,
left_region,
alpha * 0xffff,
shade_alpha,
0);
}
if (fgeom.right_width)
{
right_region = meta_get_right_border_region (&fgeom, clip.height);
decor_blend_border_picture (xdisplay,
d->context,
src,
clip.width - fgeom.right_width, fgeom.top_height,
d->picture,
&d->border_layout,
BORDER_RIGHT,
right_region,
alpha * 0xffff,
shade_alpha,
0);
}
cairo_destroy (cr);
cairo_surface_destroy (surface);
XRenderFreePicture (xdisplay, src);
copy_to_front_buffer (d);
if (d->frame_window)
{
GdkWindow *gdk_frame_window = gtk_widget_get_window (d->decor_window);
GdkPixbuf *pixbuf = gdk_pixbuf_get_from_surface (d->surface, 0, 0, d->width, d->height);
gtk_image_set_from_pixbuf (GTK_IMAGE (d->decor_image), pixbuf);
g_object_unref (pixbuf);
gtk_window_resize (GTK_WINDOW (d->decor_window), d->width, d->height);
gdk_window_move (gdk_frame_window,
d->context->left_corner_space - 1,
d->context->top_corner_space - 1);
gdk_window_lower (gdk_frame_window);
}
if (d->prop_xid)
{
/* translate from frame to client window space */
if (top_region)
XOffsetRegion (top_region, -fgeom.left_width, -fgeom.top_height);
if (bottom_region)
XOffsetRegion (bottom_region, -fgeom.left_width, 0);
if (left_region)
XOffsetRegion (left_region, -fgeom.left_width, 0);
decor_update_meta_window_property (d, theme, flags,
top_region,
bottom_region,
left_region,
right_region);
d->prop_xid = 0;
}
if (top_region)
XDestroyRegion (top_region);
if (bottom_region)
XDestroyRegion (bottom_region);
if (left_region)
XDestroyRegion (left_region);
if (right_region)
XDestroyRegion (right_region);
}
static void
nautilus_desktop_window_focus_in (GtkWidget* widget, GdkEventFocus *event,
gpointer user_data)
{
gdk_window_lower (gtk_widget_get_window (widget));
}
static VALUE
gdkwin_lower(VALUE self)
{
gdk_window_lower(_SELF(self));
return self;
}