C++ gtk_window_maximize函数代码示例

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
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;
}