JNIEXPORT void JNICALL
Java_org_gnome_gtk_GtkWindow_gtk_1window_1set_1keep_1below
(
JNIEnv* env,
jclass cls,
jlong _self,
jboolean _setting
)
{
GtkWindow* self;
gboolean setting;
// convert parameter self
self = (GtkWindow*) _self;
// convert parameter setting
setting = (gboolean) _setting;
// call function
gtk_window_set_keep_below(self, setting);
// cleanup parameter self
// cleanup parameter setting
}
void cairo_dock_pop_down (CairoDock *pDock)
{
//g_print ("%s (%d, %d)\n", __func__, pDock->bIsBelow, pDock->container.bInside);
if (! pDock->bIsBelow && pDock->iVisibility == CAIRO_DOCK_VISI_KEEP_BELOW && ! pDock->container.bInside)
{
if (gldi_dock_search_overlapping_window (pDock) != NULL)
{
pDock->iFadeCounter = 0;
pDock->bFadeInOut = TRUE;
gldi_object_register_notification (pDock,
NOTIFICATION_UPDATE,
(GldiNotificationFunc) _update_fade_out_dock,
GLDI_RUN_FIRST, NULL);
if (g_pKeepingBelowBackend != NULL && g_pKeepingBelowBackend->init)
g_pKeepingBelowBackend->init (pDock);
cairo_dock_launch_animation (CAIRO_CONTAINER (pDock));
}
else
{
//g_print ("set below\n");
gtk_window_set_keep_below (GTK_WINDOW (pDock->container.pWidget), TRUE);
}
pDock->bIsBelow = TRUE;
}
}
static gboolean _update_fade_out_dock (G_GNUC_UNUSED gpointer pUserData, CairoDock *pDock, gboolean *bContinueAnimation)
{
pDock->iFadeCounter += (pDock->bFadeInOut ? 1 : -1); // fade out, puis fade in.
if (pDock->iFadeCounter >= myBackendsParam.iHideNbSteps)
{
pDock->bFadeInOut = FALSE;
//g_print ("set below\n");
gtk_window_set_keep_below (GTK_WINDOW (pDock->container.pWidget), TRUE);
// si fenetre maximisee, on met direct iFadeCounter a 0.
// malheureusement X met du temps a faire passer le dock derriere, et ca donne un "sursaut" :-/
}
//g_print ("pDock->iFadeCounter : %d\n", pDock->iFadeCounter);
if (pDock->iFadeCounter > 0)
{
*bContinueAnimation = TRUE;
}
else
{
gldi_object_remove_notification (pDock,
NOTIFICATION_UPDATE,
(GldiNotificationFunc) _update_fade_out_dock,
NULL);
}
cairo_dock_redraw_container (CAIRO_CONTAINER (pDock));
return GLDI_NOTIFICATION_LET_PASS;
}
void gMainWindow::setStacking(int vl)
{
stack=vl;
if (!isTopLevel()) return;
switch (vl)
{
case 0:
gtk_window_set_keep_below(GTK_WINDOW(border),FALSE);
gtk_window_set_keep_above(GTK_WINDOW(border),FALSE);
break;
case 1:
gtk_window_set_keep_below(GTK_WINDOW(border),FALSE);
gtk_window_set_keep_above(GTK_WINDOW(border),TRUE);
break;
case 2:
gtk_window_set_keep_above(GTK_WINDOW(border),FALSE);
gtk_window_set_keep_below(GTK_WINDOW(border),TRUE);
break;
}
}
static void _set_one_desklet_visible (CairoDesklet *pDesklet, gpointer data)
{
gboolean bOnWidgetLayerToo = GPOINTER_TO_INT (data);
gboolean bIsOnWidgetLayer = (pDesklet->iVisibility == CAIRO_DESKLET_ON_WIDGET_LAYER);
if (bOnWidgetLayerToo || ! bIsOnWidgetLayer)
{
if (bIsOnWidgetLayer) // on le passe sur la couche visible.
gldi_desktop_set_on_widget_layer (CAIRO_CONTAINER (pDesklet), FALSE);
gtk_window_set_keep_below (GTK_WINDOW (pDesklet->container.pWidget), FALSE);
gldi_desklet_show (pDesklet);
}
}
/*
Creates main window
*/
void
launcher_create_window (launcher_core_s *launcher_core)
{
launcher_core->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW(launcher_core->window), launcher_core->width, launcher_core->height);
gtk_window_set_resizable (GTK_WINDOW(launcher_core->window), TRUE);
gtk_widget_set_app_paintable (launcher_core->window, TRUE);
gtk_window_set_decorated (GTK_WINDOW(launcher_core->window), FALSE);
on_alpha_screen_changed (launcher_core->window, NULL, NULL);
gtk_window_stick (GTK_WINDOW(launcher_core->window));
gtk_window_set_keep_below (GTK_WINDOW(launcher_core->window), TRUE);
gtk_window_set_modal (GTK_WINDOW(launcher_core->window), FALSE);
gtk_window_set_type_hint (GTK_WINDOW(launcher_core->window), GDK_WINDOW_TYPE_HINT_DOCK);
}
static gboolean _cairo_dock_set_one_desklet_visibility_to_default (CairoDesklet *pDesklet, CairoDockModule *pModule, CairoDockMinimalAppletConfig *pMinimalConfig)
{
GKeyFile *pKeyFile = cairo_dock_pre_read_module_config (pModule, pMinimalConfig);
g_key_file_free (pKeyFile);
gtk_window_set_keep_below (GTK_WINDOW (pDesklet->pWidget), pMinimalConfig->bKeepBelow);
gtk_window_set_keep_above (GTK_WINDOW (pDesklet->pWidget), pMinimalConfig->bKeepAbove);
Window Xid = GDK_WINDOW_XID (pDesklet->pWidget->window);
if (pMinimalConfig->bOnWidgetLayer)
cairo_dock_set_xwindow_type_hint (Xid, "_NET_WM_WINDOW_TYPE_UTILITY");
else
cairo_dock_set_xwindow_type_hint (Xid, "_NET_WM_WINDOW_TYPE_NORMAL");
return FALSE;
}
void cairo_dock_pop_up (CairoDock *pDock)
{
//g_print ("%s (%d)\n", __func__, pDock->bIsBelow);
if (pDock->bIsBelow)
{
gldi_object_remove_notification (pDock,
NOTIFICATION_UPDATE,
(GldiNotificationFunc) _update_fade_out_dock,
NULL);
pDock->iFadeCounter = 0;
cairo_dock_redraw_container (CAIRO_CONTAINER (pDock));
//g_print ("set above\n");
gtk_window_set_keep_below (GTK_WINDOW (pDock->container.pWidget), FALSE); // keep above
pDock->bIsBelow = FALSE;
}
}
static gboolean _cairo_dock_set_one_desklet_visible (CairoDesklet *pDesklet, CairoDockModule *pModule, gpointer data)
{
gboolean bOnWidgetLayerToo = GPOINTER_TO_INT (data);
Window Xid = GDK_WINDOW_XID (pDesklet->pWidget->window);
gboolean bIsOnWidgetLayer = cairo_dock_window_is_utility (Xid);
if (bOnWidgetLayerToo || ! bIsOnWidgetLayer)
{
cd_debug ("%s (%d)", __func__, Xid);
if (bIsOnWidgetLayer) // on le passe sur la couche visible.
cairo_dock_set_xwindow_type_hint (Xid, "_NET_WM_WINDOW_TYPE_NORMAL");
gtk_window_set_keep_below (GTK_WINDOW (pDesklet->pWidget), FALSE);
///gtk_window_set_keep_above (GTK_WINDOW (pDesklet->pWidget), TRUE);
cairo_dock_show_desklet (pDesklet);
}
return FALSE;
}
void gldi_desklet_set_accessibility (CairoDesklet *pDesklet, CairoDeskletVisibility iVisibility, gboolean bSaveState)
{
cd_debug ("%s (%d)", __func__, iVisibility);
//\_________________ On applique la nouvelle accessibilite.
gtk_window_set_keep_below (GTK_WINDOW (pDesklet->container.pWidget), iVisibility == CAIRO_DESKLET_KEEP_BELOW);
gtk_window_set_keep_above (GTK_WINDOW (pDesklet->container.pWidget), iVisibility == CAIRO_DESKLET_KEEP_ABOVE);
if (iVisibility == CAIRO_DESKLET_ON_WIDGET_LAYER)
{
if (pDesklet->iVisibility != CAIRO_DESKLET_ON_WIDGET_LAYER)
gldi_desktop_set_on_widget_layer (CAIRO_CONTAINER (pDesklet), TRUE);
}
else if (pDesklet->iVisibility == CAIRO_DESKLET_ON_WIDGET_LAYER)
{
gldi_desktop_set_on_widget_layer (CAIRO_CONTAINER (pDesklet), FALSE);
}
if (iVisibility == CAIRO_DESKLET_RESERVE_SPACE)
{
if (! pDesklet->bSpaceReserved)
_reserve_space_for_desklet (pDesklet, TRUE); // sinon inutile de le refaire, s'il y'a un changement de taille ce sera fait lors du configure-event.
}
else if (pDesklet->bSpaceReserved)
{
_reserve_space_for_desklet (pDesklet, FALSE);
}
//\_________________ On enregistre le nouvel etat.
pDesklet->iVisibility = iVisibility;
Icon *icon = pDesklet->pIcon;
if (bSaveState && CAIRO_DOCK_IS_APPLET (icon))
cairo_dock_update_conf_file (icon->pModuleInstance->cConfFilePath,
G_TYPE_INT, "Desklet", "accessibility", iVisibility,
G_TYPE_INVALID);
}
/*
Creates the main window, setting size and position
*/
static void
libgadget_sidebar_create_sidebar (sidebar_core_s *core)
{
/* Create a new window and set all its proprieties */
core->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW(core->window), core->width, core->height);
gtk_widget_set_uposition (GTK_WIDGET(core->window), (core->width_desktop - core->width), 0);
/* Set widget's name */
gtk_widget_set_name (core->window, "main_window");
gtk_window_set_resizable (GTK_WINDOW(core->window), FALSE);
gtk_widget_set_app_paintable (core->window, TRUE);
gtk_window_set_decorated (GTK_WINDOW(core->window), FALSE);
on_alpha_screen_changed (core->window, NULL, NULL);
gtk_window_stick (GTK_WINDOW(core->window));
gtk_window_set_keep_below (GTK_WINDOW(core->window), TRUE);
gtk_window_set_modal (GTK_WINDOW(core->window), FALSE);
gtk_window_set_type_hint (GTK_WINDOW(core->window), GDK_WINDOW_TYPE_HINT_DOCK);
}
void cairo_dock_place_desklet (CairoDesklet *pDesklet, CairoDockMinimalAppletConfig *pMinimalConfig)
{
cd_message ("%s (%dx%d ; (%d,%d) ; %d,%d,%d)", __func__, pMinimalConfig->iDeskletWidth, pMinimalConfig->iDeskletHeight, pMinimalConfig->iDeskletPositionX, pMinimalConfig->iDeskletPositionY, pMinimalConfig->bKeepBelow, pMinimalConfig->bKeepAbove, pMinimalConfig->bOnWidgetLayer);
if (pMinimalConfig->bDeskletUseSize)
gdk_window_resize (pDesklet->pWidget->window,
pMinimalConfig->iDeskletWidth,
pMinimalConfig->iDeskletHeight);
gdk_window_move(pDesklet->pWidget->window,
pMinimalConfig->iDeskletPositionX,
pMinimalConfig->iDeskletPositionY);
gtk_window_set_keep_below (GTK_WINDOW (pDesklet->pWidget), pMinimalConfig->bKeepBelow);
gtk_window_set_keep_above (GTK_WINDOW (pDesklet->pWidget), pMinimalConfig->bKeepAbove);
Window Xid = GDK_WINDOW_XID (pDesklet->pWidget->window);
if (pMinimalConfig->bOnWidgetLayer)
cairo_dock_set_xwindow_type_hint (Xid, "_NET_WM_WINDOW_TYPE_UTILITY"); // le hide-show le fait deconner completement, il perd son skip_task_bar ! au moins sous KDE.
else
cairo_dock_set_xwindow_type_hint (Xid, "_NET_WM_WINDOW_TYPE_NORMAL");
pDesklet->bPositionLocked = pMinimalConfig->bPositionLocked;
}
/* desktopicon_new_do */
static DesktopIcon * _desktopicon_new_do(Desktop * desktop, GdkPixbuf * image,
char const * name)
{
DesktopIcon * desktopicon;
GtkWindow * window;
GtkWidget * vbox;
GdkGeometry geometry;
if((desktopicon = malloc(sizeof(*desktopicon))) == NULL)
return NULL;
memset(desktopicon, 0, sizeof(*desktopicon));
desktopicon->desktop = desktop;
desktopicon->confirm = TRUE;
desktopicon->updated = TRUE;
/* window */
desktopicon->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
window = GTK_WINDOW(desktopicon->window);
gtk_window_set_decorated(window, FALSE);
#if GTK_CHECK_VERSION(2, 6, 0)
gtk_window_set_focus_on_map(window, FALSE);
#endif
gtk_window_set_keep_below(window, TRUE);
gtk_window_set_resizable(window, FALSE);
gtk_window_set_skip_pager_hint(window, TRUE);
#ifdef EMBEDDED
gtk_window_set_type_hint(window, GDK_WINDOW_TYPE_HINT_UTILITY);
#else
gtk_window_set_type_hint(window, GDK_WINDOW_TYPE_HINT_DOCK);
#endif
g_signal_connect(G_OBJECT(desktopicon->window), "delete-event",
G_CALLBACK(_on_desktopicon_closex), NULL);
/* event */
desktopicon->event = gtk_event_box_new();
g_signal_connect(G_OBJECT(desktopicon->event), "button-press-event",
G_CALLBACK(_on_icon_button_press), desktopicon);
g_signal_connect(G_OBJECT(desktopicon->event), "key-press-event",
G_CALLBACK(_on_icon_key_press), desktopicon);
vbox = gtk_vbox_new(FALSE, 4);
geometry.min_width = DESKTOPICON_MIN_WIDTH;
geometry.min_height = DESKTOPICON_MIN_HEIGHT;
geometry.max_width = DESKTOPICON_MAX_WIDTH;
geometry.max_height = DESKTOPICON_MAX_HEIGHT;
geometry.base_width = DESKTOPICON_MIN_WIDTH;
geometry.base_height = DESKTOPICON_MIN_HEIGHT;
gtk_window_set_geometry_hints(window, vbox, &geometry, /* XXX check */
GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE
| GDK_HINT_BASE_SIZE);
/* image */
desktopicon->image = gtk_image_new();
gtk_widget_set_size_request(desktopicon->image, DESKTOPICON_ICON_SIZE,
DESKTOPICON_ICON_SIZE);
gtk_box_pack_start(GTK_BOX(vbox), desktopicon->image, FALSE, TRUE, 0);
/* label */
desktopicon->label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(desktopicon->label), 0.5, 0.0);
#if GTK_CHECK_VERSION(2, 10, 0)
gtk_label_set_line_wrap_mode(GTK_LABEL(desktopicon->label),
PANGO_WRAP_WORD_CHAR);
#endif
gtk_label_set_line_wrap(GTK_LABEL(desktopicon->label), TRUE);
gtk_box_pack_start(GTK_BOX(vbox), desktopicon->label, TRUE, TRUE, 4);
gtk_container_add(GTK_CONTAINER(desktopicon->event), vbox);
gtk_container_add(GTK_CONTAINER(desktopicon->window),
desktopicon->event);
if(image == NULL)
image = desktop_get_file(desktop);
_desktopicon_set_icon(desktopicon, image);
_desktopicon_set_name(desktopicon, name);
_desktopicon_update_transparency(desktopicon);
return desktopicon;
}
void af_window_set_below(gboolean below)
{
GtkWidget *window = global_get("window");
gtk_window_set_keep_below(GTK_WINDOW(window), below);
}
static void
panel_start_gui(panel *p)
{
ENTER;
// main toplevel window
p->topgwin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width(GTK_CONTAINER(p->topgwin), 0);
g_signal_connect(G_OBJECT(p->topgwin), "destroy-event",
(GCallback) panel_destroy_event, p);
g_signal_connect(G_OBJECT(p->topgwin), "size-request",
(GCallback) panel_size_req, p);
g_signal_connect(G_OBJECT(p->topgwin), "map-event",
(GCallback) panel_mapped, p);
g_signal_connect(G_OBJECT(p->topgwin), "configure-event",
(GCallback) panel_configure_event, p);
g_signal_connect(G_OBJECT(p->topgwin), "button-press-event",
(GCallback) panel_button_press_event, p);
g_signal_connect(G_OBJECT(p->topgwin), "scroll-event",
(GCallback) panel_scroll_event, p);
gtk_window_set_resizable(GTK_WINDOW(p->topgwin), FALSE);
gtk_window_set_wmclass(GTK_WINDOW(p->topgwin), "panel", "fbpanel");
gtk_window_set_title(GTK_WINDOW(p->topgwin), "panel");
gtk_window_set_position(GTK_WINDOW(p->topgwin), GTK_WIN_POS_NONE);
gtk_window_set_decorated(GTK_WINDOW(p->topgwin), FALSE);
gtk_window_set_accept_focus(GTK_WINDOW(p->topgwin), FALSE);
if (p->setdocktype)
gtk_window_set_type_hint(GTK_WINDOW(p->topgwin),
GDK_WINDOW_TYPE_HINT_DOCK);
if (p->layer == LAYER_ABOVE)
gtk_window_set_keep_above(GTK_WINDOW(p->topgwin), TRUE);
else if (p->layer == LAYER_BELOW)
gtk_window_set_keep_below(GTK_WINDOW(p->topgwin), TRUE);
gtk_window_stick(GTK_WINDOW(p->topgwin));
gtk_widget_realize(p->topgwin);
p->topxwin = GDK_WINDOW_XWINDOW(p->topgwin->window);
DBG("topxwin = %lx\n", p->topxwin);
/* ensure configure event */
XMoveWindow(GDK_DISPLAY(), p->topxwin, 20, 20);
XSync(GDK_DISPLAY(), False);
gtk_widget_set_app_paintable(p->topgwin, TRUE);
calculate_position(p);
gtk_window_move(GTK_WINDOW(p->topgwin), p->ax, p->ay);
gtk_window_resize(GTK_WINDOW(p->topgwin), p->aw, p->ah);
DBG("move-resize x %d y %d w %d h %d\n", p->ax, p->ay, p->aw, p->ah);
//XSync(GDK_DISPLAY(), False);
//gdk_flush();
// background box all over toplevel
p->bbox = gtk_bgbox_new();
gtk_container_add(GTK_CONTAINER(p->topgwin), p->bbox);
gtk_container_set_border_width(GTK_CONTAINER(p->bbox), 0);
if (p->transparent) {
p->bg = fb_bg_get_for_display();
gtk_bgbox_set_background(p->bbox, BG_ROOT, p->tintcolor, p->alpha);
}
// main layout manager as a single child of background widget box
p->lbox = p->my_box_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(p->lbox), 0);
gtk_container_add(GTK_CONTAINER(p->bbox), p->lbox);
p->box = p->my_box_new(FALSE, p->spacing);
gtk_container_set_border_width(GTK_CONTAINER(p->box), 0);
gtk_box_pack_start(GTK_BOX(p->lbox), p->box, TRUE, TRUE,
(p->round_corners) ? p->round_corners_radius : 0);
if (p->round_corners) {
make_round_corners(p);
DBG("make_round_corners\n");
}
/* start window creation process */
gtk_widget_show_all(p->topgwin);
/* .. and hide it from user until everything is done */
gtk_widget_hide(p->topgwin);
p->menu = panel_make_menu(p);
if (p->setstrut)
panel_set_wm_strut(p);
XSelectInput(GDK_DISPLAY(), GDK_ROOT_WINDOW(), PropertyChangeMask);
gdk_window_add_filter(gdk_get_default_root_window(),
(GdkFilterFunc)panel_event_filter, p);
//XSync(GDK_DISPLAY(), False);
gdk_flush();
RET();
}
void XttGeGtk::set_below(int val)
{
gtk_window_set_keep_below(GTK_WINDOW(toplevel), val);
}
