static gboolean fullscreen_key_accel_callback(GtkAccelGroup *accel_group,
GObject *acceleratable, guint keyval,
GdkModifierType modifier,
gpointer data)
{
GtkWidget *widget;
int fullscreen;
if(data)
{
widget = dt_ui_main_window(darktable.gui->ui);
fullscreen = dt_conf_get_bool("ui_last/fullscreen");
if(fullscreen) gtk_window_unfullscreen(GTK_WINDOW(widget));
else gtk_window_fullscreen (GTK_WINDOW(widget));
fullscreen ^= 1;
dt_conf_set_bool("ui_last/fullscreen", fullscreen);
dt_dev_invalidate(darktable.develop);
}
else
{
widget = dt_ui_main_window(darktable.gui->ui);
gtk_window_unfullscreen(GTK_WINDOW(widget));
fullscreen = 0;
dt_conf_set_bool("ui_last/fullscreen", fullscreen);
dt_dev_invalidate(darktable.develop);
}
/* redraw center view */
gtk_widget_queue_draw(dt_ui_center(darktable.gui->ui));
return TRUE;
}
/**
* Gets calles if any key is pressed on the main window.
* Sets fullscreen if pressed key is F10 or F11
*/
void on_key_pressed(GtkWidget *window, GdkEventKey *event, gpointer *user_data)
{
if (event->keyval == 0xffc7) // F10
gtk_window_unfullscreen(GTK_WINDOW(window));
if (event->keyval == 0xffc8) // F11
gtk_window_fullscreen(GTK_WINDOW(window));
}
int dt_control_load_config(dt_control_t *c)
{
GtkWidget *widget = dt_ui_main_window(darktable.gui->ui);
dt_conf_set_int("ui_last/view", DT_MODE_NONE);
int width = dt_conf_get_int("ui_last/window_w");
int height = dt_conf_get_int("ui_last/window_h");
#ifndef __WIN32__
gint x = dt_conf_get_int("ui_last/window_x");
gint y = dt_conf_get_int("ui_last/window_y");
gtk_window_move(GTK_WINDOW(widget), x, y);
#endif
gtk_window_resize(GTK_WINDOW(widget), width, height);
int fullscreen = dt_conf_get_bool("ui_last/fullscreen");
if(fullscreen)
gtk_window_fullscreen(GTK_WINDOW(widget));
else
{
gtk_window_unfullscreen(GTK_WINDOW(widget));
int maximized = dt_conf_get_bool("ui_last/maximized");
if(maximized)
gtk_window_maximize(GTK_WINDOW(widget));
else
gtk_window_unmaximize(GTK_WINDOW(widget));
}
return 0;
}
void disable_Fullscreen() {
gtk_widget_hide(fullscreen_disable_button);
gtk_widget_show(fullscreen_enable_button);
g_print("drawing \"fullscreen_enable_button\"\n");
gtk_window_unfullscreen(GTK_WINDOW(main_window));
isFullscreen = FALSE;
}
G_MODULE_EXPORT void
fullscreen_clicked_cb(GtkWidget *toggle, signal_user_data_t *ud)
{
gboolean active;
GtkWindow *window;
g_debug("fullscreen_clicked_cb()");
ghb_widget_to_setting (ud->prefs, toggle);
ghb_check_dependency(ud, toggle, NULL);
const gchar *name = ghb_get_setting_key(toggle);
ghb_pref_save(ud->prefs, name);
window = GTK_WINDOW(GHB_WIDGET (ud->builder, "preview_window"));
active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggle));
if (active)
{
gtk_window_set_resizable(window, TRUE);
gtk_button_set_label(GTK_BUTTON(toggle), _("Windowed"));
// Changing resizable property doesn't take effect immediately
// need to delay fullscreen till after this callback returns
// to mainloop
g_idle_add((GSourceFunc)go_full, ud);
}
else
{
gtk_window_unfullscreen(window);
gtk_window_set_resizable(window, FALSE);
gtk_button_set_label(GTK_BUTTON(toggle), _("Fullscreen"));
ghb_set_preview_image(ud);
}
}
G_MODULE_EXPORT
void on_menu_fullscreen_toggled (GtkWidget *widget, void *user) {
if (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget)))
gtk_window_fullscreen (gui->mainwindow);
else
gtk_window_unfullscreen (gui->mainwindow);
}
static gint
luaH_window_unfullscreen(lua_State *L)
{
widget_t *w = luaH_checkwidget(L, 1);
gtk_window_unfullscreen(GTK_WINDOW(w->widget));
return 0;
}
static void
on_menu_fullscreen_activate (GtkMenuItem *menuitem, gpointer user_data)
{
shell->priv->fullscreen == TRUE ?
gtk_window_fullscreen(shell->priv->window) :
gtk_window_unfullscreen (shell->priv->window);
}
bool
sc_toggle_fullscreen(girara_session_t* session, girara_argument_t*
UNUSED(argument), girara_event_t* UNUSED(event), unsigned int UNUSED(t))
{
g_return_val_if_fail(session != NULL, false);
g_return_val_if_fail(session->global.data != NULL, false);
zathura_t* zathura = session->global.data;
if (zathura->document == NULL) {
girara_notify(session, GIRARA_WARNING, _("No document opened."));
return false;
}
const girara_mode_t old_mode = girara_mode_get(session);
if (old_mode == zathura->modes.fullscreen) {
gtk_window_unfullscreen(GTK_WINDOW(session->gtk.window));
refresh_view(zathura);
girara_mode_set(session, zathura->modes.normal);
} else if (old_mode == zathura->modes.normal) {
gtk_window_fullscreen(GTK_WINDOW(session->gtk.window));
refresh_view(zathura);
girara_mode_set(session, zathura->modes.fullscreen);
}
return false;
}
static gboolean
widget_on_click(GtkWidget *widget, GdkEventButton *event, gpointer user_data)
{
GtkVlcPlayer *player = GTK_VLC_PLAYER(user_data);
GtkWidget *fullscreen_window = player->priv->fullscreen_window;
if (fullscreen_window == NULL)
return TRUE;
if (event->type != GDK_2BUTTON_PRESS || event->button != 1)
return TRUE;
if (player->priv->isFullscreen) {
gtk_widget_reparent(widget, GTK_WIDGET(player));
gtk_widget_show(widget);
gtk_window_unfullscreen(GTK_WINDOW(fullscreen_window));
gtk_widget_hide(fullscreen_window);
player->priv->isFullscreen = FALSE;
} else {
set_transient_toplevel_window(GTK_WINDOW(fullscreen_window),
GTK_WIDGET(player));
gtk_window_fullscreen(GTK_WINDOW(fullscreen_window));
gtk_widget_show(fullscreen_window);
gtk_widget_reparent(widget, fullscreen_window);
gtk_widget_show(widget);
player->priv->isFullscreen = TRUE;
}
return TRUE;
}
static void
photos_main_window_fullscreen_changed (PhotosMainWindow *self, gboolean fullscreen)
{
if (fullscreen)
gtk_window_fullscreen (GTK_WINDOW (self));
else
gtk_window_unfullscreen (GTK_WINDOW (self));
}
// TODO use window-state-event to track
// TODO does this send an extra size changed?
// TODO what behavior do we want?
void uiWindowSetFullscreen(uiWindow *w, int fullscreen)
{
w->fullscreen = fullscreen;
if (w->fullscreen)
gtk_window_fullscreen(w->window);
else
gtk_window_unfullscreen(w->window);
}
void main_window_set_fullscreen( main_window_t win, gboolean fullscreen )
{
if( fullscreen ) {
gtk_window_fullscreen( GTK_WINDOW(win->window) );
} else {
gtk_window_unfullscreen( GTK_WINDOW(win->window) );
}
}
void fullscreen_show_hide(MainWindow *main_window, gboolean state)
{
if (state) {
gtk_window_fullscreen (GTK_WINDOW(main_window->window));
} else {
gtk_window_unfullscreen (GTK_WINDOW(main_window->window));
}
}
static int gtkDialogSetFullScreenAttrib(Ihandle* ih, const char* value)
{
if (iupStrBoolean(value))
{
if (!iupAttribGet(ih, "_IUPGTK_FS_STYLE"))
{
/* save the previous decoration attributes */
/* during fullscreen these attributes can be consulted by the application */
iupAttribStoreStr(ih, "_IUPGTK_FS_MAXBOX", iupAttribGet(ih, "MAXBOX"));
iupAttribStoreStr(ih, "_IUPGTK_FS_MINBOX", iupAttribGet(ih, "MINBOX"));
iupAttribStoreStr(ih, "_IUPGTK_FS_MENUBOX",iupAttribGet(ih, "MENUBOX"));
iupAttribStoreStr(ih, "_IUPGTK_FS_RESIZE", iupAttribGet(ih, "RESIZE"));
iupAttribStoreStr(ih, "_IUPGTK_FS_BORDER", iupAttribGet(ih, "BORDER"));
iupAttribStoreStr(ih, "_IUPGTK_FS_TITLE", IupGetAttribute(ih, "TITLE")); /* must use IupGetAttribute to check from the native implementation */
/* remove the decorations attributes */
iupAttribSetStr(ih, "MAXBOX", "NO");
iupAttribSetStr(ih, "MINBOX", "NO");
iupAttribSetStr(ih, "MENUBOX", "NO");
IupSetAttribute(ih, "TITLE", NULL); iupAttribSetStr(ih, "TITLE", NULL); /* remove from the hash table if we are during IupMap */
iupAttribSetStr(ih, "RESIZE", "NO");
iupAttribSetStr(ih, "BORDER", "NO");
if (iupdrvIsVisible(ih))
gtk_window_fullscreen((GtkWindow*)ih->handle);
iupAttribSetStr(ih, "_IUPGTK_FS_STYLE", "YES");
}
}
else
{
char* fs_style = iupAttribGet(ih, "_IUPGTK_FS_STYLE");
if (fs_style)
{
iupAttribSetStr(ih, "_IUPGTK_FS_STYLE", NULL);
/* restore the decorations attributes */
iupAttribStoreStr(ih, "MAXBOX", iupAttribGet(ih, "_IUPGTK_FS_MAXBOX"));
iupAttribStoreStr(ih, "MINBOX", iupAttribGet(ih, "_IUPGTK_FS_MINBOX"));
iupAttribStoreStr(ih, "MENUBOX",iupAttribGet(ih, "_IUPGTK_FS_MENUBOX"));
IupSetAttribute(ih, "TITLE", iupAttribGet(ih, "_IUPGTK_FS_TITLE")); /* must use IupSetAttribute to update the native implementation */
iupAttribStoreStr(ih, "RESIZE", iupAttribGet(ih, "_IUPGTK_FS_RESIZE"));
iupAttribStoreStr(ih, "BORDER", iupAttribGet(ih, "_IUPGTK_FS_BORDER"));
if (iupdrvIsVisible(ih))
gtk_window_unfullscreen((GtkWindow*)ih->handle);
/* remove auxiliar attributes */
iupAttribSetStr(ih, "_IUPGTK_FS_MAXBOX", NULL);
iupAttribSetStr(ih, "_IUPGTK_FS_MINBOX", NULL);
iupAttribSetStr(ih, "_IUPGTK_FS_MENUBOX",NULL);
iupAttribSetStr(ih, "_IUPGTK_FS_RESIZE", NULL);
iupAttribSetStr(ih, "_IUPGTK_FS_BORDER", NULL);
iupAttribSetStr(ih, "_IUPGTK_FS_TITLE", NULL);
}
}
return 1;
}
static void image_fullscreen ( GtkWidget *widget, AnypaperPreview *preview)
{
if (preview->priv->state == WINDOW_NORMAL_STATE) gtk_window_fullscreen (GTK_WINDOW(preview->priv->window));
if (preview->priv->state == WINDOW_FULLSCREEN_STATE)
{
timeout_destroy(preview->priv->source);
gtk_window_unfullscreen (GTK_WINDOW(preview->priv->window));
}
}
static void video_window_set_fullscreen(GtkWidget *w, gboolean val){
if (val){
g_object_set_data(G_OBJECT(w),"fullscreen",GINT_TO_POINTER(1));
gtk_window_fullscreen(GTK_WINDOW(w));
}else{
g_object_set_data(G_OBJECT(w),"fullscreen",GINT_TO_POINTER(0));
gtk_window_unfullscreen(GTK_WINDOW(w));
}
}
static void
glide_window_unfullscreen_stage (GlideWindow *w)
{
gtk_window_unfullscreen (GTK_WINDOW (w));
gtk_widget_show_all (GTK_WIDGET (w));
glide_document_resize (w->priv->document, w->priv->old_document_width,
w->priv->old_document_height);
}
/* surfer_set_fullscreen */
void surfer_set_fullscreen(Surfer * surfer, gboolean fullscreen)
{
HTMLApp * htmlapp = surfer;
if(fullscreen)
gtk_window_fullscreen(GTK_WINDOW(htmlapp->window));
else
gtk_window_unfullscreen(GTK_WINDOW(htmlapp->window));
}
static void
fullscreen_cb (GtkAction * action)
{
if (action == fullscreen_action) {
gtk_window_fullscreen (GTK_WINDOW (window));
} else {
gtk_window_unfullscreen (GTK_WINDOW (window));
}
}
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));
}
}
static void unfullscreen_window (GtkWidget *current, gpointer other)
{
GtkWidget *window = g_object_get_data(G_OBJECT(current), "window");
if (window)
{
gtk_widget_set_sensitive(GTK_WIDGET(current), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(other), TRUE);
gtk_window_unfullscreen(GTK_WINDOW(window));
}
}
/* on_engineering_fullscreen_toggled */
static void _on_engineering_fullscreen_toggled(gpointer data)
{
Engineering * engineering = data;
if(gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(
engineering->tb_fullscreen)))
gtk_window_fullscreen(GTK_WINDOW(engineering->window));
else
gtk_window_unfullscreen(GTK_WINDOW(engineering->window));
}
static int fullscreen(Client *c, const char *name, DataType type, void *value, void *data)
{
if (*(gboolean*)value) {
gtk_window_fullscreen(GTK_WINDOW(c->window));
} else {
gtk_window_unfullscreen(GTK_WINDOW(c->window));
}
return CMD_SUCCESS;
}
static void
m_toggle_fullscreen(GtkCheckMenuItem *w, gpointer data)
{
gu_window_t *gw = data;
if(gtk_check_menu_item_get_active(w)) {
gtk_window_fullscreen(GTK_WINDOW(gw->gw_window));
} else {
gtk_window_unfullscreen(GTK_WINDOW(gw->gw_window));
}
}
static void
fullscreen_cb (GSettings *settings,
char *key,
EphyWindow *window)
{
if (g_settings_get_boolean (settings, key))
gtk_window_fullscreen (GTK_WINDOW (window));
else
gtk_window_unfullscreen (GTK_WINDOW (window));
}
static void mainwindow_toggle_fullscreen(GtkWidget *widget, gpointer user_data) {
if (fullscreen) {
gtk_window_unfullscreen(GTK_WINDOW(mainwindow));
mainwindow_reset_position();
}
else
gtk_window_fullscreen(GTK_WINDOW(mainwindow));
fullscreen = !fullscreen;
mainwindow_focus_terminal();
}
static void
update_fullscreen(GtWin* self)
{
GtWinPrivate* priv = gt_win_get_instance_private(self);
if (priv->fullscreen)
gtk_window_fullscreen(GTK_WINDOW(self));
else
gtk_window_unfullscreen(GTK_WINDOW(self));
}
void
games_fullscreen_action_set_is_fullscreen (GamesFullscreenAction *action, gboolean is_fullscreen)
{
g_return_if_fail (GAMES_IS_FULLSCREEN_ACTION (action));
if (is_fullscreen)
gtk_window_fullscreen (action->priv->window);
else
gtk_window_unfullscreen (action->priv->window);
}
void af_window_set_fullscreen(gboolean fullscreen)
{
GtkWidget *window = global_get("window");
global_set("fullscreen", (gpointer)fullscreen);
if (fullscreen)
gtk_window_fullscreen(GTK_WINDOW(window));
else
gtk_window_unfullscreen(GTK_WINDOW(window));
}
