static void
gs_manager_create_windows_for_display (GSManager *manager,
GdkDisplay *display)
{
int n_monitors;
int i;
g_return_if_fail (manager != NULL);
g_return_if_fail (GS_IS_MANAGER (manager));
g_return_if_fail (GDK_IS_DISPLAY (display));
g_object_ref (manager);
g_object_ref (display);
n_monitors = gdk_display_get_n_monitors (display);
gs_debug ("Creating %d windows for display %s",
n_monitors, gdk_display_get_name (display));
for (i = 0; i < n_monitors; i++)
{
GdkMonitor *mon = gdk_display_get_monitor (display, i);
gs_manager_create_window_for_monitor (manager, mon);
}
g_object_unref (display);
g_object_unref (manager);
}
static GdkMonitor *
get_monitor (GdkScreen *screen,
gint n)
{
GdkDisplay *display;
display = gdk_screen_get_display (screen);
return gdk_display_get_monitor (display, n);
}
static gint
monitor_number (GdkMonitor *monitor)
{
GdkDisplay *display = gdk_monitor_get_display (monitor);
gint n_monitors = gdk_display_get_n_monitors (display);
gint i;
for (i = 0; i < n_monitors; i++)
if (gdk_display_get_monitor (display, i) == monitor)
return i;
return 0;
}
static int
get_monitor_num (GdkMonitor *monitor)
{
GdkDisplay *display;
int n_monitors, i;
display = gdk_monitor_get_display (monitor);
n_monitors = gdk_display_get_n_monitors (display);
for (i = 0; i < n_monitors; i++)
{
if (gdk_display_get_monitor (display, i) == monitor)
return i;
}
return -1;
}
GimpColorProfile *
gimp_widget_get_color_profile (GtkWidget *widget)
{
GdkMonitor *monitor;
g_return_val_if_fail (widget == NULL || GTK_IS_WIDGET (widget), NULL);
if (widget)
{
monitor = gimp_widget_get_monitor (widget);
}
else
{
monitor = gdk_display_get_monitor (gdk_display_get_default (), 0);
}
return gimp_monitor_get_color_profile (monitor);
}
static GdkMonitor *
gdk_display_real_get_primary_monitor (GdkDisplay *display)
{
return gdk_display_get_monitor (display, 0);
}
void
create_main_window (GsmApplication *app)
{
GtkApplicationWindow *main_window;
GtkStack *stack;
GtkMenuButton *process_menu_button;
GMenuModel *process_menu_model;
GdkDisplay *display;
GdkMonitor *monitor;
GdkRectangle monitor_geometry;
const char* session;
int width, height, xpos, ypos;
GtkBuilder *builder = gtk_builder_new();
gtk_builder_add_from_resource (builder, "/org/gnome/gnome-system-monitor/data/interface.ui", NULL);
gtk_builder_add_from_resource (builder, "/org/gnome/gnome-system-monitor/data/menus.ui", NULL);
main_window = GTK_APPLICATION_WINDOW (gtk_builder_get_object (builder, "main_window"));
gtk_window_set_application (GTK_WINDOW (main_window), app->gobj());
gtk_widget_set_name (GTK_WIDGET (main_window), "gnome-system-monitor");
app->main_window = main_window;
session = g_getenv ("XDG_CURRENT_DESKTOP");
if (session && !strstr (session, "GNOME")){
GtkBox *mainbox;
GtkHeaderBar *headerbar;
mainbox = GTK_BOX (gtk_builder_get_object (builder, "main_box"));
headerbar = GTK_HEADER_BAR (gtk_builder_get_object (builder, "header_bar"));
gtk_style_context_remove_class (gtk_widget_get_style_context (GTK_WIDGET (headerbar)), "titlebar");
gtk_window_set_titlebar (GTK_WINDOW (main_window), NULL);
gtk_header_bar_set_show_close_button (headerbar, FALSE);
gtk_box_pack_start (mainbox, GTK_WIDGET (headerbar), FALSE, FALSE, 0);
}
g_settings_get (app->settings->gobj(), GSM_SETTING_WINDOW_STATE, "(iiii)",
&width, &height, &xpos, &ypos);
display = gdk_display_get_default ();
monitor = gdk_display_get_monitor_at_point (display, xpos, ypos);
if (monitor == NULL) {
monitor = gdk_display_get_monitor (display, 0);
}
gdk_monitor_get_geometry (monitor, &monitor_geometry);
width = CLAMP (width, 50, monitor_geometry.width);
height = CLAMP (height, 50, monitor_geometry.height);
xpos = CLAMP (xpos, 0, monitor_geometry.width - width);
ypos = CLAMP (ypos, 0, monitor_geometry.height - height);
gtk_window_set_default_size (GTK_WINDOW (main_window), width, height);
gtk_window_move (GTK_WINDOW (main_window), xpos, ypos);
if (app->settings->get_boolean (GSM_SETTING_MAXIMIZED))
gtk_window_maximize (GTK_WINDOW (main_window));
app->process_menu_button = process_menu_button = GTK_MENU_BUTTON (gtk_builder_get_object (builder, "process_menu_button"));
process_menu_model = G_MENU_MODEL (gtk_builder_get_object (builder, "process-window-menu"));
gtk_menu_button_set_menu_model (process_menu_button, process_menu_model);
app->end_process_button = GTK_BUTTON (gtk_builder_get_object (builder, "end_process_button"));
app->search_button = GTK_BUTTON (gtk_builder_get_object (builder, "search_button"));
GActionEntry win_action_entries[] = {
{ "about", on_activate_about, NULL, NULL, NULL },
{ "search", on_activate_search, "b", "false", NULL },
{ "send-signal-stop", on_activate_send_signal, "i", NULL, NULL },
{ "send-signal-cont", on_activate_send_signal, "i", NULL, NULL },
{ "send-signal-end", on_activate_send_signal, "i", NULL, NULL },
{ "send-signal-kill", on_activate_send_signal, "i", NULL, NULL },
{ "priority", on_activate_priority, "i", "@i 0", change_priority_state },
{ "memory-maps", on_activate_memory_maps, NULL, NULL, NULL },
{ "open-files", on_activate_open_files, NULL, NULL, NULL },
{ "process-properties", on_activate_process_properties, NULL, NULL, NULL },
{ "refresh", on_activate_refresh, NULL, NULL, NULL },
{ "show-page", on_activate_radio, "s", "'resources'", change_show_page_state },
{ "show-whose-processes", on_activate_radio, "s", "'all'", change_show_processes_state },
{ "show-dependencies", on_activate_toggle, NULL, "false", change_show_dependencies_state }
};
g_action_map_add_action_entries (G_ACTION_MAP (main_window),
win_action_entries,
G_N_ELEMENTS (win_action_entries),
app);
GdkScreen* screen = gtk_widget_get_screen(GTK_WIDGET (main_window));
GdkVisual* visual = gdk_screen_get_rgba_visual(screen);
/* use visual, if available */
if (visual)
gtk_widget_set_visual(GTK_WIDGET (main_window), visual);
/* create the main stack */
app->stack = stack = GTK_STACK (gtk_builder_get_object (builder, "stack"));
create_proc_view(app, builder);
create_sys_view (app, builder);
create_disk_view (app, builder);
g_settings_bind (app->settings->gobj (), GSM_SETTING_CURRENT_TAB, stack, "visible-child-name", G_SETTINGS_BIND_DEFAULT);
g_signal_connect (G_OBJECT (stack), "notify::visible-child",
G_CALLBACK (cb_change_current_page), app);
g_signal_connect (G_OBJECT (main_window), "delete_event",
G_CALLBACK (cb_main_window_delete),
app);
g_signal_connect (G_OBJECT (main_window), "window-state-event",
G_CALLBACK (cb_main_window_state_changed),
app);
GAction *action;
action = g_action_map_lookup_action (G_ACTION_MAP (main_window),
"show-dependencies");
g_action_change_state (action,
g_settings_get_value (app->settings->gobj (), GSM_SETTING_SHOW_DEPENDENCIES));
action = g_action_map_lookup_action (G_ACTION_MAP (main_window),
"show-whose-processes");
g_action_change_state (action,
g_settings_get_value (app->settings->gobj (), GSM_SETTING_SHOW_WHOSE_PROCESSES));
gtk_widget_show (GTK_WIDGET (main_window));
update_page_activities (app);
g_object_unref (G_OBJECT (builder));
}
char *iupdrvGetGlobal(const char *name)
{
if (iupStrEqual(name, "VIRTUALSCREEN"))
{
GdkScreen *screen = gdk_screen_get_default();
GdkWindow *root = gdk_screen_get_root_window(gdk_screen_get_default());
int x = 0;
int y = 0;
int w = gdk_screen_get_width(screen);
int h = gdk_screen_get_height(screen);
gdk_window_get_root_origin(root, &x, &y);
return iupStrReturnStrf("%d %d %d %d", x, y, w, h);
}
if (iupStrEqual(name, "MONITORSINFO"))
{
int i;
#if GTK_CHECK_VERSION(3, 22, 0)
GdkDisplay *display = gdk_display_get_default();
int monitors_count = gdk_display_get_n_monitors(display);
#else
GdkScreen *screen = gdk_screen_get_default();
int monitors_count = gdk_screen_get_n_monitors(screen);
#endif
char *str = iupStrGetMemory(monitors_count * 50);
char* pstr = str;
GdkRectangle rect;
for (i = 0; i < monitors_count; i++)
{
#if GTK_CHECK_VERSION(3, 22, 0)
GdkMonitor* monitor = gdk_display_get_monitor(display, i);
gdk_monitor_get_geometry(monitor, &rect);
#else
gdk_screen_get_monitor_geometry(screen, i, &rect);
#endif
pstr += sprintf(pstr, "%d %d %d %d\n", rect.x, rect.y, rect.width, rect.height);
}
return str;
}
if (iupStrEqual(name, "MONITORSCOUNT"))
{
#if GTK_CHECK_VERSION(3, 22, 0)
GdkDisplay *display = gdk_display_get_default();
int monitors_count = gdk_display_get_n_monitors(display);
#else
GdkScreen *screen = gdk_screen_get_default();
int monitors_count = gdk_screen_get_n_monitors(screen);
#endif
return iupStrReturnInt(monitors_count);
}
if (iupStrEqual(name, "TRUECOLORCANVAS"))
{
return iupStrReturnBoolean(gdk_visual_get_best_depth() > 8);
}
if (iupStrEqual(name, "UTF8MODE"))
{
return iupStrReturnBoolean(iupgtkStrGetUTF8Mode());
}
if (iupStrEqual(name, "UTF8AUTOCONVERT"))
{
return iupStrReturnBoolean(!iupgtkStrGetUTF8Mode());
}
#ifndef WIN32
if (iupStrEqual(name, "EXEFILENAME"))
{
char* argv0 = IupGetGlobal("ARGV0");
if (argv0)
{
char* exefilename = realpath(argv0, NULL);
if (exefilename)
{
char* str = iupStrReturnStr(exefilename);
free(exefilename);
return str;
}
}
}
#endif
if (iupStrEqual(name, "SHOWMENUIMAGES"))
{
gboolean menu_images;
g_object_get (gtk_settings_get_default (), "gtk-menu-images", &menu_images, NULL);
return iupStrReturnBoolean(menu_images);
}
return NULL;
}
static gboolean
gimp_session_info_deserialize (GimpConfig *config,
GScanner *scanner,
gint nest_level,
gpointer data)
{
GimpSessionInfo *info = GIMP_SESSION_INFO (config);
GTokenType token;
guint scope_id;
guint old_scope_id;
scope_id = g_type_qname (G_TYPE_FROM_INSTANCE (config));
old_scope_id = g_scanner_set_scope (scanner, scope_id);
g_scanner_scope_add_symbol (scanner, scope_id, "factory-entry",
GINT_TO_POINTER (SESSION_INFO_FACTORY_ENTRY));
g_scanner_scope_add_symbol (scanner, scope_id, "position",
GINT_TO_POINTER (SESSION_INFO_POSITION));
g_scanner_scope_add_symbol (scanner, scope_id, "size",
GINT_TO_POINTER (SESSION_INFO_SIZE));
g_scanner_scope_add_symbol (scanner, scope_id, "monitor",
GINT_TO_POINTER (SESSION_INFO_MONITOR));
g_scanner_scope_add_symbol (scanner, scope_id, "open-on-exit",
GINT_TO_POINTER (SESSION_INFO_OPEN));
g_scanner_scope_add_symbol (scanner, scope_id, "aux-info",
GINT_TO_POINTER (SESSION_INFO_AUX));
g_scanner_scope_add_symbol (scanner, scope_id, "gimp-dock",
GINT_TO_POINTER (SESSION_INFO_GIMP_DOCK));
g_scanner_scope_add_symbol (scanner, scope_id, "gimp-toolbox",
GINT_TO_POINTER (SESSION_INFO_GIMP_TOOLBOX));
/* For sessionrc files from version <= GIMP 2.6 */
g_scanner_scope_add_symbol (scanner, scope_id, "dock",
GINT_TO_POINTER (SESSION_INFO_DOCK));
token = G_TOKEN_LEFT_PAREN;
while (g_scanner_peek_next_token (scanner) == token)
{
token = g_scanner_get_next_token (scanner);
switch (token)
{
gint dummy;
case G_TOKEN_LEFT_PAREN:
token = G_TOKEN_SYMBOL;
break;
case G_TOKEN_SYMBOL:
switch (GPOINTER_TO_INT (scanner->value.v_symbol))
{
case SESSION_INFO_FACTORY_ENTRY:
{
gchar *identifier = NULL;
GimpDialogFactoryEntry *entry = NULL;
token = G_TOKEN_STRING;
if (! gimp_scanner_parse_string (scanner, &identifier))
goto error;
entry = gimp_dialog_factory_find_entry (gimp_dialog_factory_get_singleton (),
identifier);
if (! entry)
goto error;
gimp_session_info_set_factory_entry (info, entry);
g_free (identifier);
}
break;
case SESSION_INFO_POSITION:
token = G_TOKEN_INT;
if (! gimp_session_info_parse_offset (scanner,
&info->p->x,
&info->p->right_align))
goto error;
if (! gimp_session_info_parse_offset (scanner,
&info->p->y,
&info->p->bottom_align))
goto error;
break;
case SESSION_INFO_SIZE:
token = G_TOKEN_INT;
if (! gimp_scanner_parse_int (scanner, &info->p->width))
goto error;
if (! gimp_scanner_parse_int (scanner, &info->p->height))
goto error;
break;
case SESSION_INFO_MONITOR:
token = G_TOKEN_INT;
if (gimp_scanner_parse_int (scanner, &dummy))
{
info->p->monitor =
gdk_display_get_monitor (gdk_display_get_default (), dummy);
}
else
goto error;
break;
case SESSION_INFO_OPEN:
info->p->open = TRUE;
/* the screen number is optional, and obsolete */
if (g_scanner_peek_next_token (scanner) == G_TOKEN_RIGHT_PAREN)
break;
token = G_TOKEN_INT;
if (! gimp_scanner_parse_int (scanner, &dummy))
goto error;
break;
case SESSION_INFO_AUX:
token = gimp_session_info_aux_deserialize (scanner,
&info->p->aux_info);
if (token != G_TOKEN_LEFT_PAREN)
goto error;
break;
case SESSION_INFO_GIMP_TOOLBOX:
case SESSION_INFO_GIMP_DOCK:
case SESSION_INFO_DOCK:
{
GimpSessionInfoDock *dock_info = NULL;
const gchar *dock_type = NULL;
/* Handle old sessionrc:s from versions <= GIMP 2.6 */
if (GPOINTER_TO_INT (scanner->value.v_symbol) == SESSION_INFO_DOCK &&
info->p->factory_entry &&
info->p->factory_entry->identifier &&
strcmp ("gimp-toolbox-window",
info->p->factory_entry->identifier) == 0)
{
dock_type = "gimp-toolbox";
}
else
{
dock_type = ((GPOINTER_TO_INT (scanner->value.v_symbol) ==
SESSION_INFO_GIMP_TOOLBOX) ?
"gimp-toolbox" :
"gimp-dock");
}
g_scanner_set_scope (scanner, scope_id + 1);
token = gimp_session_info_dock_deserialize (scanner, scope_id + 1,
&dock_info,
dock_type);
if (token == G_TOKEN_LEFT_PAREN)
{
g_scanner_set_scope (scanner, scope_id);
info->p->docks = g_list_append (info->p->docks, dock_info);
}
else
goto error;
}
break;
default:
break;
}
token = G_TOKEN_RIGHT_PAREN;
break;
case G_TOKEN_RIGHT_PAREN:
token = G_TOKEN_LEFT_PAREN;
break;
default:
break;
}
}
error:
/* If we don't have docks, assume it is a toolbox dock window from a
* sessionrc file from GIMP <= 2.6 and add a toolbox dock manually
*/
if (! info->p->docks &&
info->p->factory_entry &&
strcmp ("gimp-toolbox-window",
info->p->factory_entry->identifier) == 0)
{
info->p->docks =
g_list_append (info->p->docks,
gimp_session_info_dock_new ("gimp-toolbox"));
}
g_scanner_scope_remove_symbol (scanner, scope_id, "factory-entry");
g_scanner_scope_remove_symbol (scanner, scope_id, "position");
g_scanner_scope_remove_symbol (scanner, scope_id, "size");
g_scanner_scope_remove_symbol (scanner, scope_id, "open-on-exit");
g_scanner_scope_remove_symbol (scanner, scope_id, "aux-info");
g_scanner_scope_remove_symbol (scanner, scope_id, "gimp-dock");
g_scanner_scope_remove_symbol (scanner, scope_id, "gimp-toolbox");
g_scanner_scope_remove_symbol (scanner, scope_id, "dock");
g_scanner_set_scope (scanner, old_scope_id);
return gimp_config_deserialize_return (scanner, token, nest_level);
}
