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));
}
}
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) );
}
}
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);
}
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);
}
void CFullScreenWindow::init(GladeXML* ui)
{
window = (GtkWindow*) glade_xml_get_widget(ui, "fullScreenWindow");
restTimeLabel = (GtkLabel*) glade_xml_get_widget(ui, "restTimeLabel");
whipLabel = (GtkLabel*) glade_xml_get_widget(ui, "whipLabel");
gtk_window_fullscreen(window);
gtk_window_set_keep_above(GTK_WINDOW(window), TRUE);
}
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 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
fullscreen_cb (GtkAction * action)
{
if (action == fullscreen_action) {
gtk_window_fullscreen (GTK_WINDOW (window));
} else {
gtk_window_unfullscreen (GTK_WINDOW (window));
}
}
static gboolean
go_full(signal_user_data_t *ud)
{
GtkWindow *window;
window = GTK_WINDOW(GHB_WIDGET (ud->builder, "preview_window"));
gtk_window_fullscreen(window);
ghb_set_preview_image(ud);
return FALSE;
}
/* 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 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
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
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
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));
}
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));
}
/* 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 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();
}
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);
}
/* Two callbacks for the popup menu items Fullscreen and Unfullscreen.
* These are just making sure that the user can't select the same menu
* item among these, twice in a row by making the current item selected
* insensitive. GTK+-2.2.3 on my WinXP box seems to ignore any calls to
* unfullscreen if the user has selected fullscreen on a window that's
* already fullscreen.
*/
static void fullscreen_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_fullscreen(GTK_WINDOW(window));
}
}
G_MODULE_EXPORT void FbsetOk_released() // Change fbset resolution
{
int x, y;
int FbX = gtk_adjustment_get_value(FBSETX);
int FbY = gtk_adjustment_get_value(FBSETY);
char RunString[28];
sprintf(RunString, "scripts/Tweaks/fbset-set %d %d", FbX, FbY);
RunScript(RunString);
gtk_window_fullscreen(GTK_WINDOW(Window_QuickSetup));
gtk_window_unfullscreen(GTK_WINDOW(Window_QuickSetup));
}
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));
}
/* main entry-point */
int main(int argc, char *argv[])
{
gboolean version = FALSE;
gboolean fullscreen = FALSE;
char *geometry = NULL;
char **uris = NULL;
GError *error = NULL;
GOptionEntry entries[] = {
{ "version", 'v', 0, G_OPTION_ARG_NONE, &version, "Print version number", NULL },
{ "fullscreen", 0, 0, G_OPTION_ARG_NONE, &fullscreen, "Fullscreen mode", NULL },
{ "geometry", 'g', 0, G_OPTION_ARG_STRING, &geometry, "X geometry specification", "GEOMETRY" },
{ G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_STRING_ARRAY, &uris, "Addresses", NULL },
{ NULL }
};
/* initialize GTK and parse commandline options */
if (!gtk_init_with_args(&argc, &argv, "[addresses]", entries, NULL, &error)) {
die("%s\n", error->message);
}
if (version) {
printf("hydra %s, 2014 David Luco\n", VERSION);
exit(EXIT_SUCCESS);
}
/* create top level Hydra struct */
hydra = g_new0(Hydra, 1);
/* create first browser and add to browsers list */
Browser *b = browser_new();
hydra->browsers = g_list_append(hydra->browsers, b);
if (fullscreen) {
gtk_window_fullscreen(GTK_WINDOW(b->window));
}
if (uris) {
/* load first uri in first tab (already created) */
tab_load_uri(browser_get_current_tab(b), *uris++);
/* load other uris (if any) in new tabs */
while (uris && *uris) {
tab_load_uri(tab_new(b, "Loading..."), *uris++);
}
} else {
/* load homepage on startup */
tab_load_uri(browser_get_current_tab(b), DEFAULT_HOME);
}
gtk_main();
return 0;
}
void ZLGtkApplicationWindow::setFullscreen(bool fullscreen) {
if (fullscreen == myFullScreen) {
return;
}
myFullScreen = fullscreen;
if (myFullScreen) {
gtk_window_fullscreen(GTK_WINDOW(myWindow));
} else if (!myFullScreen) {
gtk_window_unfullscreen(GTK_WINDOW(myWindow));
}
}
static void togglefullscreen(GtkWidget* window, WebKitWebView* webView) {
gchar* fs = g_object_get_data(G_OBJECT(window), "fullscreen");
if (strcmp(fs, "u") == 0) {
g_object_set_data(G_OBJECT(window), "fullscreen",
g_strjoin(NULL, "f", NULL));
gtk_window_fullscreen(GTK_WINDOW(window));
} else {
g_object_set_data(G_OBJECT(window), "fullscreen",
g_strjoin(NULL, "u", NULL));
gtk_window_unfullscreen(GTK_WINDOW(window));
}
}
static void
change_fullscreen_state (GSimpleAction *action,
GVariant *state,
gpointer user_data)
{
if (g_variant_get_boolean (state))
gtk_window_fullscreen (user_data);
else
gtk_window_unfullscreen (user_data);
g_simple_action_set_state (action, state);
}
static void
enter_full_screen(RingMainWindow *self)
{
g_return_if_fail(IS_RING_MAIN_WINDOW(self));
auto priv = RING_MAIN_WINDOW_GET_PRIVATE(RING_MAIN_WINDOW(self));
if (!priv->is_fullscreen) {
gtk_widget_hide(priv->vbox_left_pane);
gtk_window_fullscreen(GTK_WINDOW(self));
priv->is_fullscreen = TRUE;
}
}
void chmsee_set_fullscreen(ChmSee* self, gboolean fullscreen) {
g_debug("enter chmsee_set_fullscreen with fullscreen = %d", fullscreen);
selfp->expect_fullscreen = fullscreen;
if(fullscreen) {
g_debug("call gtk_window_fullscreen");
gtk_window_fullscreen(GTK_WINDOW(self));
} else {
g_debug("call gtk_window_unfullscreen");
gtk_window_unfullscreen(GTK_WINDOW(self));
}
}
void roadmap_main_toggle_full_screen (void) {
static int RoadMapIsFullScreen = 0;
if (RoadMapIsFullScreen) {
gtk_window_unfullscreen (GTK_WINDOW(RoadMapMainWindow));
RoadMapIsFullScreen = 0;
} else {
gtk_window_fullscreen (GTK_WINDOW(RoadMapMainWindow));
RoadMapIsFullScreen = 1;
}
}