/*
- * Geeqie
- * (C) 2004 John Ellis
- * Copyright (C) 2008 The Geeqie Team
+ * Copyright (C) 2004 John Ellis
+ * Copyright (C) 2008 - 2016 The Geeqie Team
*
* Author: John Ellis
*
- * This software is released under the GNU General Public License (GNU GPL).
- * Please read the included file COPYING for more information.
- * This software comes with no warranty of any kind, use at your own risk!
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-
#include "main.h"
#include "fullscreen.h"
#include "image.h"
+#include "misc.h"
#include "ui_fileops.h"
#include "ui_menu.h"
#include "ui_misc.h"
#include "window.h"
+#include "image-load.h"
enum {
FULLSCREEN_CURSOR_HIDDEN = 1 << 0,
static void clear_mouse_cursor(GtkWidget *widget, gint state)
{
- if (!widget->window) return;
+ GdkWindow *window = gtk_widget_get_window(widget);
+ if (!window) return;
if (state & FULLSCREEN_CURSOR_BUSY)
{
GdkCursor *cursor;
cursor = gdk_cursor_new(GDK_WATCH);
- gdk_window_set_cursor(widget->window, cursor);
+ gdk_window_set_cursor(window, cursor);
gdk_cursor_unref(cursor);
}
else if (state & FULLSCREEN_CURSOR_NORMAL)
{
- gdk_window_set_cursor(widget->window, NULL);
+ gdk_window_set_cursor(window, NULL);
}
else
{
GdkCursor *cursor;
- GdkPixmap *p;
-
- p = gdk_bitmap_create_from_data(widget->window, "\0\0\0", 1, 1);
-
- cursor = gdk_cursor_new_from_pixmap(p, p,
- &widget->style->fg[GTK_STATE_ACTIVE],
- &widget->style->bg[GTK_STATE_ACTIVE],
- 0, 0);
-
- gdk_window_set_cursor(widget->window, cursor);
+ cursor = gdk_cursor_new(GDK_BLANK_CURSOR);
+ gdk_window_set_cursor(window, cursor);
gdk_cursor_unref(cursor);
- g_object_unref(p);
}
}
-static gint fullscreen_hide_mouse_cb(gpointer data)
+static gboolean fullscreen_hide_mouse_cb(gpointer data)
{
FullScreenData *fs = data;
- if (fs->hide_mouse_id == -1) return FALSE;
+ if (!fs->hide_mouse_id) return FALSE;
fs->cursor_state &= ~FULLSCREEN_CURSOR_NORMAL;
if (!(fs->cursor_state & FULLSCREEN_CURSOR_BUSY)) clear_mouse_cursor(fs->window, fs->cursor_state);
- fs->hide_mouse_id = -1;
+ g_source_remove(fs->hide_mouse_id);
+ fs->hide_mouse_id = 0;
return FALSE;
}
static void fullscreen_hide_mouse_disable(FullScreenData *fs)
{
- if (fs->hide_mouse_id != -1)
+ if (fs->hide_mouse_id)
{
g_source_remove(fs->hide_mouse_id);
- fs->hide_mouse_id = -1;
+ fs->hide_mouse_id = 0;
}
}
fs->hide_mouse_id = g_timeout_add(FULL_SCREEN_HIDE_MOUSE_DELAY, fullscreen_hide_mouse_cb, fs);
}
-static gint fullscreen_mouse_moved(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
+static gboolean fullscreen_mouse_moved(GtkWidget *widget, GdkEventMotion *event, gpointer data)
{
FullScreenData *fs = data;
static void fullscreen_busy_mouse_disable(FullScreenData *fs)
{
- if (fs->busy_mouse_id != -1)
+ if (fs->busy_mouse_id)
{
g_source_remove(fs->busy_mouse_id);
- fs->busy_mouse_id = -1;
+ fs->busy_mouse_id = 0;
}
}
-static void fullscreen_mouse_set_busy(FullScreenData *fs, gint busy)
+static void fullscreen_mouse_set_busy(FullScreenData *fs, gboolean busy)
{
fullscreen_busy_mouse_disable(fs);
- if ((fs->cursor_state & FULLSCREEN_CURSOR_BUSY) == (busy)) return;
+ if (!!(fs->cursor_state & FULLSCREEN_CURSOR_BUSY) == (busy)) return;
if (busy)
{
{
FullScreenData *fs = data;
- fs->busy_mouse_id = -1;
+ fs->busy_mouse_id = 0;
fullscreen_mouse_set_busy(fs, TRUE);
return FALSE;
}
static void fullscreen_mouse_set_busy_idle(FullScreenData *fs)
{
- if (fs->busy_mouse_id == -1)
+ if (!fs->busy_mouse_id)
{
fs->busy_mouse_id = g_timeout_add(FULL_SCREEN_BUSY_MOUSE_DELAY,
fullscreen_mouse_set_busy_cb, fs);
FullScreenData *fs = data;
if (fs->imd->il &&
- fs->imd->il->pixbuf != image_get_pixbuf(fs->imd))
+ image_loader_get_pixbuf(fs->imd->il) != image_get_pixbuf(fs->imd))
{
fullscreen_mouse_set_busy_idle(fs);
}
}
-static void fullscreen_image_complete_cb(ImageWindow *imd, gint preload, gpointer data)
+static void fullscreen_image_complete_cb(ImageWindow *imd, gboolean preload, gpointer data)
{
FullScreenData *fs = data;
static void fullscreen_saver_deactivate(void)
{
- static gint checked = FALSE;
- static gint found = FALSE;
+ static gboolean checked = FALSE;
+ static gboolean found = FALSE;
if (!checked)
{
if (found)
{
- system(XSCREENSAVER_COMMAND);
+ runcmd(XSCREENSAVER_COMMAND);
}
}
return TRUE;
}
-static gint fullscreen_delete_cb(GtkWidget *widget, GdkEventAny *event, gpointer data)
+static gboolean fullscreen_delete_cb(GtkWidget *widget, GdkEventAny *event, gpointer data)
{
FullScreenData *fs = data;
{
FullScreenData *fs;
GdkScreen *screen;
- gint same;
gint x, y;
gint w, h;
GdkGeometry geometry;
fs = g_new0(FullScreenData, 1);
- fs->hide_mouse_id = -1;
- fs->busy_mouse_id = -1;
fs->cursor_state = FULLSCREEN_CURSOR_HIDDEN;
fs->normal_window = window;
DEBUG_1("full screen requests screen %d", options->fullscreen.screen);
fullscreen_prefs_get_geometry(options->fullscreen.screen, window, &x, &y, &w, &h,
- &screen, &same);
+ &screen, &fs->same_region);
fs->window = window_new(GTK_WINDOW_TOPLEVEL, "fullscreen", NULL, NULL, _("Full screen"));
+ DEBUG_NAME(fs->window);
+
+ g_signal_connect(G_OBJECT(fs->window), "delete_event",
+ G_CALLBACK(fullscreen_delete_cb), fs);
- /* this requests no decorations, if you still have them complain to the window manager author(s) */
+ /* few cosmetic details */
gtk_window_set_decorated(GTK_WINDOW(fs->window), FALSE);
+ gtk_container_set_border_width(GTK_CONTAINER(fs->window), 0);
- if (options->fullscreen.screen < 0)
- {
- /* If we want control of the window size and position this is not what we want.
- * Geeqie needs control of which monitor(s) to use for full screen.
- */
- gtk_window_fullscreen(GTK_WINDOW(fs->window));
- }
- else if (options->fullscreen.above)
- {
- /* request to be above other windows */
+ /* keep window above others, if requested */
+ if (options->fullscreen.above) {
gtk_window_set_keep_above(GTK_WINDOW(fs->window), TRUE);
- }
+ }
- gtk_window_set_resizable(GTK_WINDOW(fs->window), FALSE);
-
- gtk_window_set_screen(GTK_WINDOW(fs->window), screen);
- gtk_container_set_border_width(GTK_CONTAINER(fs->window), 0);
- g_signal_connect(G_OBJECT(fs->window), "delete_event",
- G_CALLBACK(fullscreen_delete_cb), fs);
+ /* set default size and position, so the window appears where it was before */
+ gtk_window_set_default_size(GTK_WINDOW(fs->window), w, h);
+ gtk_window_move(GTK_WINDOW(fs->window), x, y);
- geometry.min_width = w;
- geometry.min_height = h;
- geometry.max_width = w;
- geometry.max_height = h;
- geometry.base_width = w;
- geometry.base_height = h;
- geometry.win_gravity = GDK_GRAVITY_STATIC;
/* By setting USER_POS and USER_SIZE, most window managers will
* not request positioning of the full screen window (for example twm).
*
* decorations of twm to not effect the requested window position,
* the decorations will simply be off screen, except in multi monitor setups :-/
*/
+ geometry.min_width = 1;
+ geometry.min_height = 1;
+ geometry.base_width = w;
+ geometry.base_height = h;
+ geometry.win_gravity = GDK_GRAVITY_STATIC;
gtk_window_set_geometry_hints(GTK_WINDOW(fs->window), fs->window, &geometry,
- GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE | GDK_HINT_BASE_SIZE |
- GDK_HINT_WIN_GRAVITY |
- GDK_HINT_USER_POS);
+ GDK_HINT_WIN_GRAVITY | GDK_HINT_USER_POS | GDK_HINT_USER_SIZE);
- gtk_window_set_default_size(GTK_WINDOW(fs->window), w, h);
- gtk_window_move(GTK_WINDOW(fs->window), x, y);
+ gtk_widget_realize(fs->window);
+#if GTK_CHECK_VERSION(3,8,0)
+ if ((options->fullscreen.screen % 100) == 0)
+ {
+ GdkWindow *gdkwin;
+ gdkwin = gtk_widget_get_window(fs->window);
+ if (gdkwin != NULL)
+ gdk_window_set_fullscreen_mode(gdkwin, GDK_FULLSCREEN_ON_ALL_MONITORS);
+ }
+#endif
+ /* make window fullscreen -- let Gtk do it's job, don't screw it in any way */
+ gtk_window_fullscreen(GTK_WINDOW(fs->window));
+
+ /* move it to requested screen */
+ if (options->fullscreen.screen >= 0)
+ {
+ gtk_window_set_screen(GTK_WINDOW(fs->window), screen);
+ }
fs->imd = image_new(FALSE);
gtk_container_add(GTK_CONTAINER(fs->window), fs->imd->widget);
- if (options->image.use_custom_border_color)
- {
- image_background_set_color(fs->imd, &options->image.border_color);
- }
-
+ image_background_set_color_from_options(fs->imd, TRUE);
image_set_delay_flip(fs->imd, options->fullscreen.clean_flip);
- image_auto_refresh(fs->imd, fs->normal_imd->auto_refresh_interval);
+ image_auto_refresh_enable(fs->imd, fs->normal_imd->auto_refresh);
if (options->fullscreen.clean_flip)
{
gtk_widget_show(fs->imd->widget);
- image_change_from_image(fs->imd, fs->normal_imd);
+ if (fs->same_region)
+ {
+ DEBUG_2("Original window is not visible, enabling std. fullscreen mode");
+ image_move_from_image(fs->imd, fs->normal_imd);
+ }
+ else
+ {
+ DEBUG_2("Original window is still visible, enabling presentation fullscreen mode");
+ image_copy_from_image(fs->imd, fs->normal_imd);
+ }
+
+ if (options->stereo.enable_fsmode) {
+ image_stereo_set(fs->imd, options->stereo.fsmode);
+ }
gtk_widget_show(fs->window);
/* set timer to block screen saver */
fs->saver_block_id = g_timeout_add(60 * 1000, fullscreen_saver_block_cb, fs);
- /* hide normal window
- * FIXME: properly restore this window on show
+ /* hide normal window */
+ /** @FIXME properly restore this window on show
*/
-#ifdef HIDE_WINDOW_IN_FULLSCREEN
- gtk_widget_hide(fs->normal_window);
-#endif
- image_change_fd(fs->normal_imd, NULL, image_zoom_get(fs->normal_imd));
+ if (fs->same_region)
+ {
+ if (options->hide_window_in_fullscreen)
+ {
+ gtk_widget_hide(fs->normal_window);
+ }
+ image_change_fd(fs->normal_imd, NULL, image_zoom_get(fs->normal_imd));
+ }
return fs;
}
{
if (!fs) return;
- g_source_remove(fs->saver_block_id);
+ if (fs->saver_block_id) g_source_remove(fs->saver_block_id);
fullscreen_hide_mouse_disable(fs);
fullscreen_busy_mouse_disable(fs);
gdk_keyboard_ungrab(GDK_CURRENT_TIME);
- image_change_from_image(fs->normal_imd, fs->imd);
-#ifdef HIDE_WINDOW_IN_FULLSCREEN
- gtk_widget_show(fs->normal_window);
-#endif
+ if (fs->same_region)
+ {
+ image_move_from_image(fs->normal_imd, fs->imd);
+ if (options->hide_window_in_fullscreen)
+ {
+ gtk_widget_show(fs->normal_window);
+ }
+ if (options->stereo.enable_fsmode)
+ {
+ image_stereo_set(fs->normal_imd, options->stereo.mode);
+ }
+ }
+
+
if (fs->stop_func) fs->stop_func(fs, fs->stop_data);
gtk_widget_destroy(fs->window);
+ gtk_window_present(GTK_WINDOW(fs->normal_window));
+
g_free(fs);
}
display = gdk_display_get_default();
number = gdk_display_get_n_screens(display);
- for (i = 0; i < number ; i++)
+ for (i = 0; i < number; i++)
{
GdkScreen *screen;
gint monitors;
else
{
gdk_screen_get_monitor_geometry(screen, j, &rect);
- subname = g_strdup_printf("%s %d", _("Monitor"), j + 1);
+ subname = gdk_screen_get_monitor_plug_name(screen, j);
+ if (subname == NULL)
+ {
+ subname = g_strdup_printf("%s %d", _("Monitor"), j + 1);
+ }
}
sd = g_new0(ScreenData, 1);
* same_region: the returned region will overlap the current location of widget.
*/
void fullscreen_prefs_get_geometry(gint screen, GtkWidget *widget, gint *x, gint *y, gint *width, gint *height,
- GdkScreen **dest_screen, gint *same_region)
+ GdkScreen **dest_screen, gboolean *same_region)
{
GList *list;
ScreenData *sd;
if (height) *height = sd->height;
if (dest_screen) *dest_screen = screen;
- if (same_region) *same_region = (!widget || !widget->window ||
+ if (same_region) *same_region = (!widget || !gtk_widget_get_window(widget) ||
(screen == gtk_widget_get_screen(widget) &&
(sd->number%100 == 0 ||
- sd->number%100 == gdk_screen_get_monitor_at_window(screen, widget->window)+1)));
+ sd->number%100 == gdk_screen_get_monitor_at_window(screen, gtk_widget_get_window(widget))+1)));
}
- else if (screen != 1 || !widget || !widget->window)
+ else if (screen != 1 || !widget || !gtk_widget_get_window(widget))
{
GdkScreen *screen;
GdkRectangle rect;
screen = gtk_widget_get_screen(widget);
- monitor = gdk_screen_get_monitor_at_window(screen, widget->window);
+ monitor = gdk_screen_get_monitor_at_window(screen, gtk_widget_get_window(widget));
gdk_screen_get_monitor_geometry(screen, monitor, &rect);
gint monitor;
gint n;
- if (!widget || !widget->window) return 0;
+ if (!widget || !gtk_widget_get_window(widget)) return 0;
screen = gtk_widget_get_screen(widget);
- monitor = gdk_screen_get_monitor_at_window(screen, widget->window);
+ monitor = gdk_screen_get_monitor_at_window(screen, gtk_widget_get_window(widget));
n = (gdk_screen_get_number(screen)+1) * 100 + monitor + 1;
FS_MENU_COLUMN_VALUE, value, -1);
}
-GtkWidget *fullscreen_prefs_selection_new(const gchar *text, gint *screen_value, gint *above_value)
+GtkWidget *fullscreen_prefs_selection_new(const gchar *text, gint *screen_value, gboolean *above_value)
{
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *combo;
GtkListStore *store;
GtkCellRenderer *renderer;
- GtkWidget *button = NULL;
GList *list;
GList *work;
gint current = 0;
if (!screen_value) return NULL;
vbox = gtk_vbox_new(FALSE, PREF_PAD_GAP);
+ DEBUG_NAME(vbox);
hbox = pref_box_new(vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
if (text) pref_label_new(hbox, text);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo), renderer,
"text", FS_MENU_COLUMN_NAME, NULL);
- if (above_value)
- {
- button = pref_checkbox_new_int(vbox, _("Stay above other windows"),
- *above_value, above_value);
- gtk_widget_set_sensitive(button, *screen_value != -1);
-
- g_object_set_data(G_OBJECT(combo), BUTTON_ABOVE_KEY, button);
- }
-
fullscreen_prefs_selection_add(store, _("Determined by Window Manager"), -1);
fullscreen_prefs_selection_add(store, _("Active screen"), 0);
if (*screen_value == 0) current = 1;
return vbox;
}
+/* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */
projects / geeqie.git / blobdiff