/**
* gucharma_settings_add_window:
* @window: a #GtkWindow
*
* Restore the window configuration, and persist changes to the window configuration:
* window width and height, and maximised and fullscreen state.
* @window must not be realised yet.
*/
void
gucharmap_settings_add_window (GtkWindow *window)
{
WindowState *state;
int width, height;
gboolean maximised, fullscreen;
g_return_if_fail (GTK_IS_WINDOW (window));
g_return_if_fail (!gtk_widget_get_realized (GTK_WIDGET (window)));
state = g_slice_new0 (WindowState);
state->settings = g_settings_new ("org.gnome.Charmap.WindowState");
g_object_set_data_full (G_OBJECT (window), "GamesConf::WindowState",
state, (GDestroyNotify) free_window_state);
g_signal_connect_after (window, "size-allocate",
G_CALLBACK (window_size_allocate_cb), state);
g_signal_connect (window, "window-state-event",
G_CALLBACK (window_state_event_cb), state);
maximised = g_settings_get_boolean (state->settings, "maximized");
fullscreen = g_settings_get_boolean (state->settings, "fullscreen");
g_settings_get (state->settings, "size", "(ii)", &width, &height);
if (width > 0 && height > 0) {
gtk_window_set_default_size (GTK_WINDOW (window), width, height);
}
if (maximised) {
gtk_window_maximize (GTK_WINDOW (window));
}
if (fullscreen) {
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;
}
static void
set_initial_size (GtkWindow *window,
PositionInfo *pinfo)
{
int width, height;
width = moo_prefs_get_int (pinfo->key_width);
height = moo_prefs_get_int (pinfo->key_height);
if (width > 0 && height > 0)
gtk_window_set_default_size (window, width, height);
if (moo_prefs_get_bool (pinfo->key_maximized))
gtk_window_maximize (window);
if (pinfo->remember_position)
{
int x, y;
x = moo_prefs_get_int (pinfo->key_x);
y = moo_prefs_get_int (pinfo->key_y);
if (x < G_MAXINT && y < G_MAXINT)
gtk_window_move (window, x, y);
}
}
static void
update_small_screen_settings (GnomeControlCenter *self)
{
CcSmallScreen small;
update_monitor_number (self);
small = is_small (self);
if (small == SMALL_SCREEN_TRUE)
{
gtk_window_set_resizable (GTK_WINDOW (self->priv->window), TRUE);
if (self->priv->small_screen != small)
gtk_window_maximize (GTK_WINDOW (self->priv->window));
}
else
{
if (self->priv->small_screen != small)
gtk_window_unmaximize (GTK_WINDOW (self->priv->window));
gtk_window_set_resizable (GTK_WINDOW (self->priv->window), FALSE);
}
self->priv->small_screen = small;
/* And update the minimum sizes */
notebook_page_notify_cb (GTK_NOTEBOOK (self->priv->notebook), NULL, self->priv);
}
static gint
luaH_window_maximize(lua_State *L)
{
widget_t *w = luaH_checkwidget(L, 1);
gtk_window_maximize(GTK_WINDOW(w->widget));
return 0;
}
int main(int argc, char** argv) {
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(window), HEIGHT, WIDTH);
// hardwired position GTK_WIN_POS_CENTER_ALWAYS
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER_ALWAYS);
g_signal_connect(window, "key-press-event", G_CALLBACK(on_key_press), NULL);
g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
web_view = WEBKIT_WEB_VIEW(webkit_web_view_new());
signal(SIGHUP, reload_browser);
gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(web_view));
webkit_web_view_load_uri(web_view, DEFAULT_URL);
// maximize()
gtk_window_maximize(GTK_WINDOW(window));
gtk_window_fullscreen(GTK_WINDOW(window));
gtk_window_set_decorated(GTK_WINDOW(window), FALSE);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
static void
gcal_application_activate (GApplication *application)
{
GcalApplicationPrivate *priv;
priv = GCAL_APPLICATION (application)->priv;
if (priv->window != NULL)
{
gtk_window_present (GTK_WINDOW (priv->window));
}
else
{
priv->window =
gcal_window_new_with_view (GCAL_APPLICATION (application),
g_settings_get_enum (priv->settings,
"active-view"));
g_settings_bind (priv->settings,
"active-view",
priv->window,
"active-view",
G_SETTINGS_BIND_SET | G_SETTINGS_BIND_GET);
gtk_window_set_title (GTK_WINDOW (priv->window), _("Calendar"));
gtk_window_set_hide_titlebar_when_maximized (GTK_WINDOW (priv->window),
TRUE);
gtk_window_maximize (GTK_WINDOW (priv->window));
gtk_widget_show_all (priv->window);
}
}
void
on_show_listing1_activate (GtkMenuItem * menuitem, gpointer user_data)
{
GString *list;
GtkWidget *cont;
/* assemble */
on_assemble1_activate (NULL, NULL);
if (asm_error == FALSE)
return;
list = asm_listing_generate (b_get_src ());
//gui_editor_set_text (app->editor, list->str);
/* show */
wind = create_window_listing ();
cont = lookup_widget (wind, "listing_vbox");
g_assert (cont);
edit = gui_editor_new ();
g_assert (edit);
gui_editor_show (edit);
gui_editor_set_text (edit, list->str);
gui_editor_set_readonly (edit, TRUE);
gtk_box_pack_end (GTK_BOX (cont), edit->scroll, TRUE, TRUE, 0);
gtk_window_maximize (GTK_WINDOW (wind));
gtk_widget_show_all (wind);
/* TODO clean up of listing window editor on delete event */
/* clean up */
g_string_free (list, TRUE);
}
void
show_tutorial ()
{
GString* tutorial_text = read_tutorial ();
GtkWidget *cont;
/* show */
tutorial = create_window_tutorial ();
cont = lookup_widget (tutorial, "tutorial_vbox");
g_assert (cont);
edit = gui_editor_new ();
g_assert (edit);
gui_editor_show (edit);
if (tutorial_text == NULL)
{
tutorial_text = g_string_new (_("The tutorial file, asm-guide.txt, was not found. It should be present in directory - "));
g_string_append (tutorial_text, PACKAGE_DOC_DIR);
}
gui_editor_set_text (edit, tutorial_text->str);
gui_editor_set_readonly (edit, TRUE);
gui_editor_set_show_line_numbers (edit, FALSE);
gtk_box_pack_end (GTK_BOX (cont), edit->scroll, TRUE, TRUE, 0);
gtk_window_maximize (GTK_WINDOW (tutorial));
gtk_widget_show_all (tutorial);
/* clean up */
g_string_free (tutorial_text, TRUE);
}
static void
geometry_load (GtkWindow *window)
{
GSettings *ui_settings;
gboolean maximized;
gint x, y, w, h;
ui_settings = g_object_get_data (G_OBJECT (window), GEOMETRY_DATA_NAME);
maximized = g_settings_get_boolean (ui_settings, TWITUX_UI_WINDOW_MAXIMISED);
x = g_settings_get_int (ui_settings, TWITUX_UI_WINDOW_X_POS);
y = g_settings_get_int (ui_settings, TWITUX_UI_WINDOW_Y_POS);
w = g_settings_get_int (ui_settings, TWITUX_UI_WINDOW_WIDTH);
h = g_settings_get_int (ui_settings, TWITUX_UI_WINDOW_HEIGHT);
if ((x > 0) || (y > 0)){
gtk_window_move (window, x, y);
}
if ((w > 0) && (h > 0)){
gtk_window_resize (window, w, h);
}
if (maximized) {
gtk_window_maximize (window);
} else {
gtk_window_unmaximize (window);
}
}
static void
create_window (int width,
int height,
gboolean alpha,
gboolean maximized)
{
WindowInfo *info;
info = g_new0 (WindowInfo, 1);
info->width = width;
info->height = height;
info->alpha = alpha;
info->maximized = maximized;
info->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
if (alpha)
gtk_widget_set_visual (info->window, gdk_screen_get_rgba_visual (gdk_screen_get_default ()));
if (maximized)
gtk_window_maximize (GTK_WINDOW (info->window));
info->pending = TRUE;
gtk_widget_set_size_request (info->window, width, height);
gtk_widget_set_app_paintable (info->window, TRUE);
g_signal_connect (info->window, "map-event", G_CALLBACK (on_window_map_event), info);
g_signal_connect (info->window, "draw", G_CALLBACK (on_window_draw), info);
gtk_widget_show (info->window);
our_windows = g_list_prepend (our_windows, info);
}
static void load_window_size(GKeyFile *keyfile)
{
GError *error = NULL;
bool max = g_key_file_get_boolean(keyfile, "window", "max", &error);
if (error)
g_error_free(error);
else if (max) {
gtk_window_maximize(gui.window);
return;
}
int width = g_key_file_get_integer(keyfile, "window", "width", &error);
if (error) {
g_error_free(error);
error = NULL;
width = -1;
}
int height = g_key_file_get_integer(keyfile, "window", "height", &error);
if (error) {
g_error_free(error);
error = NULL;
height = -1;
}
if ((width > 0) && (height > 0))
gtk_window_resize(gui.window, width, height);
}
void wxTopLevelWindowGTK::Maximize(bool maximize)
{
if (maximize)
gtk_window_maximize( GTK_WINDOW( m_widget ) );
else
gtk_window_unmaximize( GTK_WINDOW( m_widget ) );
}
static void
gy_window_settings__window_realize (GtkWindow *window)
{
GdkRectangle geom = { 0 };
gboolean maximized = FALSE;
g_assert (GTK_IS_WINDOW (window));
g_assert (G_IS_SETTINGS (settings));
g_settings_get (settings, "window-position", "(ii)", &geom.x, &geom.y);
g_settings_get (settings, "window-size", "(ii)", &geom.width, &geom.height);
g_settings_get (settings, "window-maximized", "b", &maximized);
gtk_window_set_default_size (window, geom.width, geom.height);
gtk_window_move (window, geom.x, geom.y);
if (maximized)
gtk_window_maximize (window);
DzlDockBin* dockbin = gy_window_get_dockbin (GY_WINDOW (window));
GtkWidget * edge = dzl_dock_bin_get_left_edge (dockbin);
g_settings_bind (settings, "left-panel-visible", edge, "reveal-child", G_SETTINGS_BIND_DEFAULT);
g_settings_bind (settings, "left-panel-position", edge, "position", G_SETTINGS_BIND_DEFAULT);
edge = dzl_dock_bin_get_right_edge (dockbin);
g_settings_bind (settings, "right-panel-visible", edge, "reveal-child", G_SETTINGS_BIND_DEFAULT);
g_settings_bind (settings, "right-panel-position", edge, "position", G_SETTINGS_BIND_DEFAULT);
}
void
gui_app_new (void)
{
GtkPaned *p_msg, *p_data;
/*GdkScreen *screen;*/
g_assert (app == NULL);
app = g_malloc0 (sizeof (GUIApp));
app->window_main = create_window_main ();
gtk_window_maximize (GTK_WINDOW (app->window_main));
app->editor = gui_editor_new ();
gui_editor_set_margin_toggle_mark (app->editor);
gui_editor_show (app->editor);
/* add editor */
container = lookup_widget (app->window_main, "main_vbox_center");
g_assert (container);
gtk_box_pack_start_defaults (GTK_BOX (container),
app->editor->scroll);
/* dim */
//gtk_window_get_size(app->window_main, &w, &h);
p_msg = GTK_PANED (lookup_widget
(app->window_main, "main_hpaned_msg"));
g_assert (p_msg);
p_data = GTK_PANED (lookup_widget
(app->window_main, "main_vpaned_data"));
g_assert (p_data);
/* get screen
screen = gdk_screen_get_default ();
w = gdk_screen_get_width (screen);
h = gdk_screen_get_height (screen);
g_message ("screen w = %d", w);
g_message ("screen h = %d", h);*/
/* maximize window FIXME - not working in other wms say IceWM */
gtk_window_maximize (GTK_WINDOW (app->window_main));
//FIXME properly allocate spaces to widgets?
//gtk_paned_set_position (p_data, w);
//gtk_paned_set_position (p_msg, h/2);
}
int make_window(struct layout *l, int justwindow)
{
GdkColor color = {0, 0, 0};
GdkCursor *cursor;
GdkWindow *window;
l->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(l->window), MAX_WIDTH, 482);
l->fixed = gtk_fixed_new();
gtk_container_add(GTK_CONTAINER(l->window), l->fixed);
gtk_widget_show(l->fixed);
gdk_color_parse(BG_COLOR, &color);
gtk_widget_modify_bg(l->window, GTK_STATE_NORMAL, &color);
if (!justwindow)
gtk_window_maximize(GTK_WINDOW(l->window));
gtk_widget_show(l->window);
cursor = gdk_cursor_new(GDK_BLANK_CURSOR);
window = gtk_widget_get_window(GTK_WIDGET(l->window));
gdk_window_set_cursor(window, cursor);
make_indicators(l);
make_aprs_info(l);
make_aprs_list(l);
make_gps_info(l);
make_telemetry(l);
make_weather(l);
l->sep1 = gtk_hseparator_new();
gtk_widget_set_size_request(l->sep1, 720, 10);
gtk_widget_show(l->sep1);
gtk_fixed_put(GTK_FIXED(l->fixed), l->sep1, 0, 110);
l->sep2 = gtk_hseparator_new();
gtk_widget_set_size_request(l->sep2, 720, 10);
gtk_widget_show(l->sep2);
gtk_fixed_put(GTK_FIXED(l->fixed), l->sep2, 0, 240);
l->sep3 = gtk_hseparator_new();
gtk_widget_set_size_request(l->sep3, 720, 10);
gtk_widget_show(l->sep3);
gtk_fixed_put(GTK_FIXED(l->fixed), l->sep3, 0, 340);
l->sep4 = gtk_hseparator_new();
gtk_widget_set_size_request(l->sep4, 720, 10);
gtk_widget_show(l->sep4);
gtk_fixed_put(GTK_FIXED(l->fixed), l->sep4, 0, 440);
gtk_widget_add_events(GTK_WIDGET(l->window), GDK_KEY_PRESS_MASK);
gtk_signal_connect(GTK_OBJECT(l->window), "key-press-event",
G_CALLBACK(main_button), l);
l->key_map = main_screen;
return 0;
}
gboolean af_window_maximize()
{
if (!af_window_get_visible()) return FALSE;
GtkWidget *window = global_get("window");
gtk_window_maximize(GTK_WINDOW(window));
return TRUE;
}
void do_tmpwin_hack (void)
{
GtkWidget * tmpwin = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (GTK_OBJECT (tmpwin), "configure-event",
GTK_SIGNAL_FUNC (tmpwin_configured),
gpointer (tmpwin));
gtk_window_maximize (GTK_WINDOW(tmpwin));
gtk_widget_show (tmpwin);
}
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GtkFramePeer_maximize
(JNIEnv *env, jobject obj)
{
void *ptr;
gdk_threads_enter ();
ptr = gtkpeer_get_widget (env, obj);
gtk_window_maximize (GTK_WINDOW (ptr));
gdk_threads_leave ();
}
/**
* gedit_app_create_window:
* @app: the #GeditApp
* @screen: (allow-none):
*
* Create a new #GeditWindow part of @app.
*
* Return value: (transfer none): the new #GeditWindow
*/
GeditWindow *
gedit_app_create_window (GeditApp *app,
GdkScreen *screen)
{
GeditAppPrivate *priv;
GeditWindow *window;
gchar *role;
GdkWindowState state;
gint w, h;
gedit_debug (DEBUG_APP);
priv = gedit_app_get_instance_private (app);
window = GEDIT_APP_GET_CLASS (app)->create_window (app);
if (screen != NULL)
{
gtk_window_set_screen (GTK_WINDOW (window), screen);
}
role = gen_role ();
gtk_window_set_role (GTK_WINDOW (window), role);
g_free (role);
state = g_settings_get_int (priv->window_settings,
GEDIT_SETTINGS_WINDOW_STATE);
g_settings_get (priv->window_settings,
GEDIT_SETTINGS_WINDOW_SIZE,
"(ii)", &w, &h);
gtk_window_set_default_size (GTK_WINDOW (window), w, h);
if ((state & GDK_WINDOW_STATE_MAXIMIZED) != 0)
{
gtk_window_maximize (GTK_WINDOW (window));
}
else
{
gtk_window_unmaximize (GTK_WINDOW (window));
}
if ((state & GDK_WINDOW_STATE_STICKY ) != 0)
{
gtk_window_stick (GTK_WINDOW (window));
}
else
{
gtk_window_unstick (GTK_WINDOW (window));
}
return window;
}
void gMainWindow::setMaximized(bool vl)
{
if (!isTopLevel())
return;
_maximized = vl;
if (vl)
gtk_window_maximize(GTK_WINDOW(border));
else
gtk_window_unmaximize(GTK_WINDOW(border));
}
/**
* gva_main_init:
*
* Initializes the main window.
*
* This function should be called once when the application starts.
**/
void
gva_main_init (void)
{
GSettings *settings;
gchar *text;
settings = gva_get_settings ();
gva_tree_view_init ();
gtk_box_pack_start (
GTK_BOX (GVA_WIDGET_MAIN_VBOX),
gva_ui_get_managed_widget ("/main-menu"),
FALSE, FALSE, 0);
gtk_box_reorder_child (
GTK_BOX (GVA_WIDGET_MAIN_VBOX),
gva_ui_get_managed_widget ("/main-menu"), 0);
gtk_widget_set_sensitive (
GVA_WIDGET_MAIN_MUTE_BUTTON,
gva_mame_supports_sound ());
g_settings_bind (
settings, GVA_SETTING_SOUND_MUTED,
GVA_WIDGET_MAIN_MUTE_BUTTON, "muted",
G_SETTINGS_BIND_DEFAULT);
gtk_window_move (
GTK_WINDOW (GVA_WIDGET_MAIN_WINDOW),
g_settings_get_int (settings, "window-x"),
g_settings_get_int (settings, "window-y"));
gtk_window_resize (
GTK_WINDOW (GVA_WIDGET_MAIN_WINDOW),
g_settings_get_int (settings, "window-width"),
g_settings_get_int (settings, "window-height"));
if (g_settings_get_boolean (settings, "window-maximized"))
gtk_window_maximize (GTK_WINDOW (GVA_WIDGET_MAIN_WINDOW));
/* Initialize the search entry. */
text = gva_main_get_last_search_text ();
gtk_entry_set_text (GTK_ENTRY (GVA_WIDGET_MAIN_SEARCH_ENTRY), text);
g_free (text);
gva_ui_lock ();
gtk_action_set_visible (GVA_ACTION_INSERT_FAVORITE, FALSE);
gtk_action_set_visible (GVA_ACTION_REMOVE_FAVORITE, FALSE);
gtk_window_present (GTK_WINDOW (GVA_WIDGET_MAIN_WINDOW));
}
static void load_window_size(void)
{
if (g_settings_get_boolean(prefs_priv.settings, PREFS_KEY_WINDOW_MAX)) {
gtk_window_maximize(gui.window);
return;
}
int width = g_settings_get_int(prefs_priv.settings, PREFS_KEY_WINDOW_WIDTH);
int height = g_settings_get_int(prefs_priv.settings, PREFS_KEY_WINDOW_HEIGHT);
if ((width > 0) && (height > 0))
gtk_window_resize(gui.window, width, height);
}
static GtkWidget *desktop_create()
{
GtkWidget *desktop = gtk_window_new(GTK_WINDOW_TOPLEVEL);
GtkWidget *fixed_pos_viewport = gtk_viewport_new(NULL,NULL);
GtkWidget *fixed_pos = gtk_fixed_new();
gtk_container_add(GTK_CONTAINER(fixed_pos_viewport),fixed_pos);
gtk_container_add(GTK_CONTAINER(desktop),fixed_pos_viewport);
g_signal_connect(G_OBJECT(desktop),"delete-event",G_CALLBACK(desktop_destroy),NULL);
g_signal_connect(G_OBJECT(desktop),"key-press-event",G_CALLBACK(desktop_keypress),NULL);
gtk_window_maximize(GTK_WINDOW(desktop));
gtk_window_fullscreen(GTK_WINDOW(desktop));
return desktop;
}
gboolean
tray_toggle_visibility (gboolean force_hide)
{
static int x, y;
static GdkScreen *screen;
static int maximized;
GtkWindow *win;
if (!sticon)
return FALSE;
/* ph may have an invalid context now */
hexchat_set_context (ph, hexchat_find_context (ph, NULL, NULL));
win = GTK_WINDOW (hexchat_get_info (ph, "gtkwin_ptr"));
tray_stop_flash ();
tray_reset_counts ();
if (!win)
return FALSE;
#if GTK_CHECK_VERSION(2,20,0)
if (force_hide || gtk_widget_get_visible (GTK_WIDGET (win)))
#else
if (force_hide || GTK_WIDGET_VISIBLE (win))
#endif
{
if (prefs.hex_gui_tray_away)
hexchat_command (ph, "ALLSERV AWAY");
gtk_window_get_position (win, &x, &y);
screen = gtk_window_get_screen (win);
maximized = prefs.hex_gui_win_state;
gtk_widget_hide (GTK_WIDGET (win));
}
else
{
if (prefs.hex_gui_tray_away)
hexchat_command (ph, "ALLSERV BACK");
gtk_window_set_screen (win, screen);
gtk_window_move (win, x, y);
if (maximized)
gtk_window_maximize (win);
gtk_widget_show (GTK_WIDGET (win));
gtk_window_present (win);
}
return TRUE;
}
void
_gtk_window_resize_to_fit_screen_height (GtkWidget *window,
int default_width)
{
GdkScreen *screen;
screen = gtk_widget_get_screen (window);
if ((screen != NULL) && (gdk_screen_get_height (screen) < 768))
/* maximize on netbooks */
gtk_window_maximize (GTK_WINDOW (window));
else
/* This should fit on a XGA/WXGA (height 768) screen
* with top and bottom panels */
gtk_window_set_default_size (GTK_WINDOW (window), default_width, 670);
}
static void setup_window_position(void)
{
/* interprets the saved window geometry */
if (!prefs.save_winpos)
return;
if (ui_prefs.geometry[0] != -1 && ui_prefs.geometry[1] != -1)
gtk_window_move(GTK_WINDOW(main_widgets.window),
ui_prefs.geometry[0], ui_prefs.geometry[1]);
if (ui_prefs.geometry[2] != -1 && ui_prefs.geometry[3] != -1)
gtk_window_set_default_size(GTK_WINDOW(main_widgets.window),
ui_prefs.geometry[2], ui_prefs.geometry[3]);
if (ui_prefs.geometry[4] == 1)
gtk_window_maximize(GTK_WINDOW(main_widgets.window));
}
static void
photos_main_window_init (PhotosMainWindow *self)
{
PhotosMainWindowPrivate *priv;
GApplication *app;
GVariant *variant;
PhotosSearchContextState *state;
gboolean maximized;
const gint32 *position;
const gint32 *size;
gsize n_elements;
self->priv = photos_main_window_get_instance_private (self);
priv = self->priv;
app = g_application_get_default ();
state = photos_search_context_get_state (PHOTOS_SEARCH_CONTEXT (app));
priv->settings = photos_settings_new ();
variant = g_settings_get_value (priv->settings, "window-size");
size = g_variant_get_fixed_array (variant, &n_elements, sizeof (gint32));
if (n_elements == 2)
gtk_window_set_default_size (GTK_WINDOW (self), size[0], size[1]);
g_variant_unref (variant);
variant = g_settings_get_value (priv->settings, "window-position");
position = g_variant_get_fixed_array (variant, &n_elements, sizeof (gint32));
if (n_elements == 2)
gtk_window_move (GTK_WINDOW (self), position[0], position[1]);
g_variant_unref (variant);
maximized = g_settings_get_boolean (priv->settings, "window-maximized");
if (maximized)
gtk_window_maximize (GTK_WINDOW (self));
priv->item_mngr = g_object_ref (state->item_mngr);
priv->mode_cntrlr = photos_mode_controller_dup_singleton ();
g_signal_connect_swapped (priv->mode_cntrlr,
"fullscreen-changed",
G_CALLBACK (photos_main_window_fullscreen_changed),
self);
priv->sel_cntrlr = photos_selection_controller_dup_singleton ();
}
JNIEXPORT void JNICALL
Java_org_gnome_gtk_GtkWindow_gtk_1window_1maximize
(
JNIEnv* env,
jclass cls,
jlong _self
)
{
GtkWindow* self;
// convert parameter self
self = (GtkWindow*) _self;
// call function
gtk_window_maximize(self);
// cleanup parameter self
}
static void create_app_main_window(MainWindow *main_window, const gchar *title)
{
main_window->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(main_window->window), title);
gint w, h, x, y;
if (get_preferences_manager_window_maximized(main_window->prefmg)) {
gtk_window_maximize(GTK_WINDOW(main_window->window));
} else {
get_preferences_manager_window_size (main_window->prefmg, &w, &h);
gtk_window_set_default_size(GTK_WINDOW(main_window->window), w, h);
get_preferences_manager_window_position (main_window->prefmg, &y, &x);
gtk_window_move(GTK_WINDOW(main_window->window), x, y);
}
g_set_application_name (title);
gtk_window_set_default_icon_name ("gphpedit");
/* set RGBA colormap */
set_colormap(main_window->window);
}
