static void
nautilus_navigation_window_save_geometry (NautilusNavigationWindow *window)
{
char *geometry_string;
gboolean is_maximized;
g_assert (NAUTILUS_IS_WINDOW (window));
if (gtk_widget_get_window (GTK_WIDGET (window))) {
geometry_string = eel_gtk_window_get_geometry_string (GTK_WINDOW (window));
is_maximized = gdk_window_get_state (gtk_widget_get_window (GTK_WIDGET (window)))
& GDK_WINDOW_STATE_MAXIMIZED;
if (eel_preferences_key_is_writable (NAUTILUS_PREFERENCES_NAVIGATION_WINDOW_SAVED_GEOMETRY) &&
!is_maximized) {
eel_preferences_set
(NAUTILUS_PREFERENCES_NAVIGATION_WINDOW_SAVED_GEOMETRY,
geometry_string);
}
g_free (geometry_string);
if (eel_preferences_key_is_writable (NAUTILUS_PREFERENCES_NAVIGATION_WINDOW_MAXIMIZED)) {
eel_preferences_set_boolean
(NAUTILUS_PREFERENCES_NAVIGATION_WINDOW_MAXIMIZED,
is_maximized);
}
}
}
static void
window_save_state (GiggleWindow *window)
{
GiggleWindowPriv *priv;
char geometry[25];
gboolean maximized;
priv = GET_PRIV (window);
g_snprintf (geometry, sizeof (geometry), "%dx%d+%d+%d",
priv->width, priv->height, priv->x, priv->y);
maximized = gdk_window_get_state (GTK_WIDGET (window)->window) & GDK_WINDOW_STATE_MAXIMIZED;
giggle_git_config_set_field (priv->configuration,
GIGGLE_GIT_CONFIG_FIELD_MAIN_WINDOW_GEOMETRY,
geometry);
giggle_git_config_set_boolean_field (priv->configuration,
GIGGLE_GIT_CONFIG_FIELD_MAIN_WINDOW_MAXIMIZED,
maximized);
giggle_git_config_commit (priv->configuration,
window_configuration_committed_cb,
window);
}
static gboolean
gdk_monitor_has_fullscreen_window (GdkMonitor *monitor)
{
GdkScreen *screen = gdk_display_get_default_screen (monitor->display);
GList *toplevels, *l;
GdkWindow *window;
gboolean has_fullscreen;
toplevels = gdk_screen_get_toplevel_windows (screen);
has_fullscreen = FALSE;
for (l = toplevels; l; l = l->next)
{
window = l->data;
if ((gdk_window_get_state (window) & GDK_WINDOW_STATE_FULLSCREEN) == 0)
continue;
if (gdk_window_get_fullscreen_mode (window) == GDK_FULLSCREEN_ON_ALL_MONITORS ||
gdk_display_get_monitor_at_window (monitor->display, window) == monitor)
{
has_fullscreen = TRUE;
break;
}
}
g_list_free (toplevels);
return has_fullscreen;
}
bool wxTopLevelWindowGTK::IsMaximized() const
{
GdkWindow* window = NULL;
if (m_widget)
window = gtk_widget_get_window(m_widget);
return window && (gdk_window_get_state(window) & GDK_WINDOW_STATE_MAXIMIZED);
}
static void blist_create_cb(PurpleBuddyList *purple_blist, void *data) {
purple_debug_info(WINPREFS_PLUGIN_ID, "buddy list created\n");
blist = PIDGIN_BLIST(purple_blist)->window;
if(purple_prefs_get_bool(PREF_DBLIST_DOCKABLE)) {
blist_set_dockable(TRUE);
if(purple_prefs_get_bool(PREF_DBLIST_DOCKED)) {
blist_ab->undocked_height = purple_prefs_get_int(PREF_DBLIST_HEIGHT);
if(!(gdk_window_get_state(gtk_widget_get_window(blist))
& GDK_WINDOW_STATE_WITHDRAWN)) {
gtk_appbar_dock(blist_ab,
purple_prefs_get_int(PREF_DBLIST_SIDE));
if(purple_prefs_get_int(PREF_BLIST_ON_TOP)
== BLIST_TOP_DOCKED)
blist_set_ontop(TRUE);
} else {
g_idle_add(listen_for_blist_visible_cb, NULL);
}
}
}
if(purple_prefs_get_int(PREF_BLIST_ON_TOP) == BLIST_TOP_ALWAYS)
blist_set_ontop(TRUE);
}
/* On configure event. */
G_MODULE_EXPORT gboolean
on_configure (GtkWidget *widget,
GdkEventExpose *event,
gpointer user_data)
{
AnnotateData *data = (AnnotateData *) user_data;
if (data->debug)
{
g_printerr("DEBUG: Annotation window get configure event (%d,%d)\n",
gtk_widget_get_allocated_width (widget),
gtk_widget_get_allocated_height (widget));
}
GdkWindowState state = gdk_window_get_state (gtk_widget_get_window (widget));
gint is_fullscreen = state & GDK_WINDOW_STATE_FULLSCREEN;
if (!is_fullscreen)
{
return FALSE;
}
initialize_annotation_cairo_context (data);
if (!data->is_grabbed)
{
return FALSE;
}
/* Postcondition; data->annotation_cairo_context is not NULL. */
return TRUE;
}
G_MODULE_EXPORT gboolean
preview_state_cb(
GtkWidget *widget,
GdkEvent *event,
signal_user_data_t *ud)
{
GdkEventType type = ghb_event_get_event_type(event);
if (type == GDK_WINDOW_STATE)
{
// Look for transition to iconified state.
// Toggle "Show Preview" button when iconified.
// I only do this because there seems to be no
// way to reliably disable the iconfy button without
// also disabling the maximize button.
#if GTK_CHECK_VERSION(3, 90, 0)
GdkWindow * window = gdk_event_get_window(event);
GdkWindowState state = gdk_window_get_state(window);
if (state & GDK_WINDOW_STATE_ICONIFIED)
#else
GdkEventWindowState * wse = (GdkEventWindowState*)event;
if (wse->changed_mask & wse->new_window_state &
GDK_WINDOW_STATE_ICONIFIED)
#endif
{
live_preview_stop(ud);
GtkWidget *widget = GHB_WIDGET(ud->builder, "show_preview");
gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(widget), FALSE);
}
}
return FALSE;
}
JNIEXPORT jint JNICALL
Java_org_gnome_gdk_GdkWindow_gdk_1window_1get_1state
(
JNIEnv* env,
jclass cls,
jlong _self
)
{
GdkWindowState result;
jint _result;
GdkWindow* self;
// convert parameter self
self = (GdkWindow*) _self;
// call function
result = gdk_window_get_state(self);
// cleanup parameter self
// translate return value to JNI type
_result = (jint) result;
// and finally
return _result;
}
static AtkStateSet*
gail_window_ref_state_set (AtkObject *accessible)
{
AtkStateSet *state_set;
GtkWidget *widget;
GtkWindow *window;
GdkWindowState state;
state_set = ATK_OBJECT_CLASS (gail_window_parent_class)->ref_state_set (accessible);
widget = GTK_ACCESSIBLE (accessible)->widget;
if (widget == NULL)
return state_set;
window = GTK_WINDOW (widget);
if (window->has_focus)
atk_state_set_add_state (state_set, ATK_STATE_ACTIVE);
if (widget->window)
{
state = gdk_window_get_state (widget->window);
if (state & GDK_WINDOW_STATE_ICONIFIED)
atk_state_set_add_state (state_set, ATK_STATE_ICONIFIED);
}
if (gtk_window_get_modal (window))
atk_state_set_add_state (state_set, ATK_STATE_MODAL);
if (gtk_window_get_resizable (window))
atk_state_set_add_state (state_set, ATK_STATE_RESIZABLE);
return state_set;
}
static gboolean
geometry_store_cb (gpointer user_data)
{
GdkWindowState window_state;
GdkWindow *gdk_window;
GSettings *ui_settings;
gboolean maximized;
gint x, y, w, h;
if (!gtk_widget_get_visible (GTK_WIDGET (user_data))){
return FALSE;
}
/* Get window metrics and status */
gtk_window_get_position (GTK_WINDOW (user_data), &x, &y);
gtk_window_get_size (GTK_WINDOW (user_data), &w, &h);
gdk_window = gtk_widget_get_window (GTK_WIDGET (user_data));
window_state = gdk_window_get_state (gdk_window);
maximized = (window_state & GDK_WINDOW_STATE_MAXIMIZED) != 0;
/* Save values */
ui_settings = g_object_get_data (G_OBJECT (user_data), GEOMETRY_DATA_NAME);
g_settings_set_int (ui_settings, TWITUX_UI_WINDOW_X_POS, x);
g_settings_set_int (ui_settings, TWITUX_UI_WINDOW_Y_POS, y);
g_settings_set_int (ui_settings, TWITUX_UI_WINDOW_WIDTH, w);
g_settings_set_int (ui_settings, TWITUX_UI_WINDOW_HEIGHT, h);
g_settings_set_boolean (ui_settings, TWITUX_UI_WINDOW_MAXIMISED, maximized);
save_queue_id = 0;
return FALSE;
}
bool wxTopLevelWindowGTK::IsMaximized() const
{
if(!m_widget->window)
return false;
return gdk_window_get_state(m_widget->window) & GDK_WINDOW_STATE_MAXIMIZED;
}
static gboolean
photos_main_window_window_state_event (GtkWidget *widget, GdkEventWindowState *event)
{
PhotosMainWindow *self = PHOTOS_MAIN_WINDOW (widget);
GdkWindow *window;
GdkWindowState state;
gboolean maximized;
gboolean ret_val;
ret_val = GTK_WIDGET_CLASS (photos_main_window_parent_class)->window_state_event (widget, event);
window = gtk_widget_get_window (widget);
state = gdk_window_get_state (window);
if (state & GDK_WINDOW_STATE_FULLSCREEN)
{
photos_mode_controller_set_fullscreen (self->mode_cntrlr, TRUE);
return ret_val;
}
photos_mode_controller_set_fullscreen (self->mode_cntrlr, FALSE);
maximized = (state & GDK_WINDOW_STATE_MAXIMIZED);
g_settings_set_boolean (self->settings, "window-maximized", maximized);
return ret_val;
}
void
liferea_shell_toggle_visibility (void)
{
GtkWidget *mainwindow = GTK_WIDGET (shell->priv->window);
if (gdk_window_get_state (gtk_widget_get_window (mainwindow)) & GDK_WINDOW_STATE_ICONIFIED) {
/* The window is either iconified, or on another workspace */
/* Raise it in one click */
if (gtk_widget_get_visible (mainwindow)) {
liferea_shell_save_position ();
gtk_widget_hide (mainwindow);
}
liferea_shell_restore_position ();
/* Note: Without deiconify() desktop moving doesn't work in
GNOME+metacity. The window would be moved correctly by
present() but not become visible. */
gtk_window_deiconify (GTK_WINDOW (mainwindow));
gtk_window_present (GTK_WINDOW (mainwindow));
}
else if (!gtk_widget_get_visible (mainwindow)) {
/* The window is neither iconified nor on another workspace, but is not visible */
liferea_shell_restore_position ();
gtk_window_present (shell->priv->window);
} else {
liferea_shell_save_position ();
gtk_widget_hide (mainwindow);
}
}
static void
caja_navigation_window_save_geometry (CajaNavigationWindow *window)
{
char *geometry_string;
gboolean is_maximized;
g_assert (CAJA_IS_WINDOW (window));
if (gtk_widget_get_window (GTK_WIDGET (window)))
{
geometry_string = eel_gtk_window_get_geometry_string (GTK_WINDOW (window));
is_maximized = gdk_window_get_state (gtk_widget_get_window (GTK_WIDGET (window)))
& GDK_WINDOW_STATE_MAXIMIZED;
if (!is_maximized)
{
g_settings_set_string (caja_window_state,
CAJA_WINDOW_STATE_GEOMETRY,
geometry_string);
}
g_free (geometry_string);
g_settings_set_boolean (caja_window_state,
CAJA_WINDOW_STATE_MAXIMIZED,
is_maximized);
}
}
char video_canvas_can_resize(video_canvas_t *canvas)
{
GtkWidget *t = get_active_toplevel();
if (t) {
return !(gdk_window_get_state(gtk_widget_get_window(t)) & GDK_WINDOW_STATE_MAXIMIZED);
}
return 0;
}
void cw_window_set_child_window(GtkWidget* widget, CWWindowPrivate* priv)
{
GdkWindowState state = gdk_window_get_state(
gtk_widget_get_window(GTK_WIDGET(widget)));
gint window_mode = cw_thumbnails_window_get_mode(priv->thumbnails_window);
gboolean isfullscreen = state & GDK_WINDOW_STATE_FULLSCREEN;
cw_window_set_child_window_size(widget, priv, window_mode, isfullscreen);
}
gboolean window_maximized(GtkWidget *window)
{
GdkWindowState state;
if (!window || !gtk_widget_get_window(window)) return FALSE;
state = gdk_window_get_state(gtk_widget_get_window(window));
return !!(state & GDK_WINDOW_STATE_MAXIMIZED);
}
int dt_control_write_config(dt_control_t *c)
{
// TODO: move to gtk.c
GtkWidget *widget = dt_ui_main_window(darktable.gui->ui);
GtkAllocation allocation;
gtk_widget_get_allocation(widget, &allocation);
gint x, y;
gtk_window_get_position(GTK_WINDOW(widget), &x, &y);
dt_conf_set_int("ui_last/window_x", x);
dt_conf_set_int("ui_last/window_y", y);
dt_conf_set_int("ui_last/window_w", allocation.width);
dt_conf_set_int("ui_last/window_h", allocation.height);
dt_conf_set_bool("ui_last/maximized",
(gdk_window_get_state(gtk_widget_get_window(widget)) & GDK_WINDOW_STATE_MAXIMIZED));
dt_conf_set_bool("ui_last/fullscreen",
(gdk_window_get_state(gtk_widget_get_window(widget)) & GDK_WINDOW_STATE_FULLSCREEN));
return 0;
}
/****************************************************************************************************
* the events of the main window
* used to keep the "fullscreen"-checkbox up-to-date
****************************************************************************************************/
static gboolean window_event_cb(GtkWidget *window, GdkEventWindowState *event, gpointer menubar_p)
{
Menu * menubar = GOSM_MENU(menubar_p);
if ((event -> changed_mask & GDK_WINDOW_STATE_FULLSCREEN) != 0){
gboolean fullscreened =
(gdk_window_get_state(GTK_WIDGET(menubar -> main_window) -> window)
& GDK_WINDOW_STATE_FULLSCREEN) != 0;
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menubar -> menu_view_fullscreen), fullscreened);
}
}
static void
toggle_fullscreen(GtkWidget *widget){
GdkWindowState state = gdk_window_get_state(GDK_WINDOW(widget->window));
if (state == GDK_WINDOW_STATE_FULLSCREEN){
gtk_window_unfullscreen(GTK_WINDOW(widget));
}
else{
gtk_window_fullscreen(GTK_WINDOW(widget));
}
}
void
liferea_shell_present (void)
{
GtkWidget *mainwindow = GTK_WIDGET (shell->priv->window);
if ((gdk_window_get_state (gtk_widget_get_window (mainwindow)) & GDK_WINDOW_STATE_ICONIFIED) || !gtk_widget_get_visible (mainwindow))
liferea_shell_restore_position ();
gtk_window_present (shell->priv->window);
}
bool gui_is_maximised(void)
{
GdkWindow *window = gtk_widget_get_window(GTK_WIDGET(gui.window));
if (!window)
return false;
GdkWindowState state = gdk_window_get_state(window);
return (state & GDK_WINDOW_STATE_MAXIMIZED);
}
void
dates_window_state_cb (GtkWidget *widget, GdkEventVisibility *event,
DatesData *d)
{
GtkWidget *header = d->header_eventbox;
if (gdk_window_get_state (widget->window) &
GDK_WINDOW_STATE_FULLSCREEN) {
gtk_widget_show (header);
} else {
gtk_widget_hide (header);
}
}
static DdbListview *
playlist_visible () {
if (searchwin) {
GdkWindow *window = gtk_widget_get_window(searchwin);
if (window) {
if (!(gdk_window_get_state(window) & GDK_WINDOW_STATE_ICONIFIED) && gtk_widget_get_visible(searchwin)) {
return DDB_LISTVIEW(lookup_widget(searchwin, "searchlist"));
}
}
}
return NULL;
}
void MainFrame::SaveWindowInfo (void)
{
// Delete all the current window states from the registry
GlobalRegistry().deleteXPath(RKEY_WINDOW_STATE);
// Tell the position tracker to save the information
_windowPosition.saveToPath(RKEY_WINDOW_STATE);
GdkWindow* window = GTK_WIDGET(m_window)->window;
if (window != NULL)
GlobalRegistry().setAttribute(RKEY_WINDOW_STATE, "state", string::toString(gdk_window_get_state(window)));
}
static void remmina_main_save_size(RemminaMain *remminamain)
{
if ((gdk_window_get_state(gtk_widget_get_window(GTK_WIDGET(remminamain))) & GDK_WINDOW_STATE_MAXIMIZED) == 0)
{
gtk_window_get_size(GTK_WINDOW(remminamain), &remmina_pref.main_width, &remmina_pref.main_height);
remmina_pref.main_maximize = FALSE;
}
else
{
remmina_pref.main_maximize = TRUE;
}
}
/* Performs a scheduled dimensions-to-prefs sync for a window binding */
static gboolean
window_binding_perform_scheduled_sync (WindowBinding *binding)
{
if (binding->bind_size) {
gint width, height;
gchar *key;
GdkWindowState state;
GdkWindow *window;
window = gtk_widget_get_window (GTK_WIDGET (binding->window));
state = gdk_window_get_state (window);
if (state & GDK_WINDOW_STATE_MAXIMIZED) {
key = g_strconcat (binding->key_prefix, "_maximized", NULL);
gconf_client_set_bool (bridge->client, key, TRUE, NULL);
g_free (key);
} else {
gtk_window_get_size (binding->window, &width, &height);
key = g_strconcat (binding->key_prefix, "_width", NULL);
gconf_client_set_int (bridge->client, key, width, NULL);
g_free (key);
key = g_strconcat (binding->key_prefix, "_height", NULL);
gconf_client_set_int (bridge->client, key, height, NULL);
g_free (key);
key = g_strconcat (binding->key_prefix, "_maximized", NULL);
gconf_client_set_bool (bridge->client, key, FALSE, NULL);
g_free (key);
}
}
if (binding->bind_pos) {
gint x, y;
gchar *key;
gtk_window_get_position (binding->window, &x, &y);
key = g_strconcat (binding->key_prefix, "_x", NULL);
gconf_client_set_int (bridge->client, key, x, NULL);
g_free (key);
key = g_strconcat (binding->key_prefix, "_y", NULL);
gconf_client_set_int (bridge->client, key, y, NULL);
g_free (key);
}
binding->sync_timeout_id = 0;
return FALSE;
}
static gboolean
window_get_is_on_current_workspace (GtkWindow *window)
{
GdkWindow *gdk_window;
gdk_window = GTK_WIDGET (window)->window;
if (gdk_window) {
return !(gdk_window_get_state (gdk_window) &
GDK_WINDOW_STATE_ICONIFIED);
} else {
return FALSE;
}
}
static gboolean
window_configure_event (GtkWidget *widget,
GdkEventConfigure *event)
{
GiggleWindowPriv *priv = GET_PRIV (widget);
if (!(gdk_window_get_state (widget->window) & GDK_WINDOW_STATE_MAXIMIZED)) {
gtk_window_get_size (GTK_WINDOW (widget), &priv->width, &priv->height);
gtk_window_get_position (GTK_WINDOW (widget), &priv->x, &priv->y);
}
return GTK_WIDGET_CLASS (giggle_window_parent_class)->configure_event (widget, event);
}
/**
* win: The window that changed state
* event: The event that triggered it
* data: ignored
*
* Depending on the state it will grab the keyboard or ungrab it.
*
* Returns FALSE
**/
static gboolean
window_state_changed (GtkWidget *win, GdkEventWindowState *event, gpointer data)
{
GdkWindowState state = gdk_window_get_state (gtk_widget_get_window (win));
if (state & GDK_WINDOW_STATE_WITHDRAWN ||
state & GDK_WINDOW_STATE_ICONIFIED ||
state & GDK_WINDOW_STATE_FULLSCREEN ||
state & GDK_WINDOW_STATE_MAXIMIZED)
ungrab_keyboard (win, (GdkEvent*)event, data);
else
grab_keyboard (win, (GdkEvent*)event, data);
return FALSE;
}
