main.c

系统任务管理器

	{
	return gtree.monitor_vbox;
	}

void
gkrellm_build()
	{
	GkrellmMonitor		*mon;
	GList		*list;
	static gint	first_create	= TRUE;

	_GK.initialized = FALSE;
	monitor_previous_height = 0;
	_GK.total_frame_height = 0;
	_GK.any_transparency = FALSE;
	gkrellm_winop_reset();
	gkrellm_start_timer(0);

	if (!first_create)
		edge_record();
	gkrellm_alert_reset_all();
	gkrellm_panel_cleanup();

	gkrellm_theme_config();
	if (first_create)
		gkrellm_load_user_config(TRUE);
	setup_colors();
	setup_fonts();
	gkrellm_load_theme_piximages();
	gkrellm_chart_setup();
	gkrellm_freeze_side_frame_packing();

	create_frame_top(gtree.top0_vbox);

	_GK.monitor_height = 0;
	for (list = gkrellm_monitor_list; list; list = list->next)
		{
		mon = (GkrellmMonitor *) list->data;
		if (mon->privat->main_vbox)
			{
			if (first_create)
				{
				if (mon == gkrellm_mon_host())
					gtk_box_pack_start(GTK_BOX(gtree.top1_vbox),
								mon->privat->main_vbox, FALSE, FALSE, 0);
				else
					gtk_box_pack_start(GTK_BOX(gtree.monitor_vbox),
								mon->privat->main_vbox, FALSE, FALSE, 0);
				gtk_box_pack_start(GTK_BOX(mon->privat->main_vbox),
							mon->privat->top_spacer.vbox, FALSE, FALSE, 0);
				gtk_box_pack_start(GTK_BOX(mon->privat->main_vbox),
							mon->privat->vbox, FALSE, FALSE, 0);
				gtk_box_pack_start(GTK_BOX(mon->privat->main_vbox),
							mon->privat->bottom_spacer.vbox, FALSE, FALSE, 0);
				}
			if (mon->create_monitor && mon->privat->enabled)
				{
				gkrellm_record_state(CREATE_MONITOR, mon);
				gtk_widget_show(mon->privat->vbox);
				gtk_widget_show(mon->privat->main_vbox);
				render_monitor_spacers(mon);
				(*(mon->create_monitor))(mon->privat->vbox,
							mon->privat->created ? FALSE : TRUE);
				mon->privat->created = TRUE;
				}
			gkrellm_record_state(INTERNAL, NULL);
			}
		}
	create_frame_bottom(gtree.bottom_vbox);

	_GK.initialized = TRUE;
	gkrellm_thaw_side_frame_packing();
	gkrellm_start_timer(_GK.update_HZ);
	if (!first_create)
		{
		fix_edges();
		if (!no_transparency)
			gkrellm_winop_apply_rootpixmap_transparency();
		}
	first_create = FALSE;
	}

static void
add_builtin(GkrellmMonitor *mon)
	{
	if (!mon)
		return;
	gkrellm_monitor_list = g_list_append(gkrellm_monitor_list, mon);
	if (!mon->privat)				/* Won't be null if style was added */
		mon->privat = g_new0(GkrellmMonprivate, 1);
	if (mon->create_monitor)
		{
		mon->privat->main_vbox = gtk_vbox_new(FALSE, 0);
		mon->privat->top_spacer.vbox = gtk_vbox_new(FALSE, 0);
		mon->privat->vbox = gtk_vbox_new(FALSE, 0);
		mon->privat->bottom_spacer.vbox = gtk_vbox_new(FALSE, 0);
		}
	mon->privat->enabled = TRUE;
	}

static void
load_builtin_monitors()
	{
	gkrellm_add_chart_style(NULL, "*");
	gkrellm_add_meter_style(NULL, "*");

	/* The sensors config does not have a create or update, but it does
	|  have an apply which needs to be called before the cpu or proc apply.
	|  So just put sensors config first.
	*/
	add_builtin(gkrellm_init_sensors_config_monitor());
	add_builtin(gkrellm_init_host_monitor());
	add_builtin(gkrellm_init_cal_monitor());
	add_builtin(gkrellm_init_clock_monitor());
	add_builtin(gkrellm_init_cpu_monitor());
	add_builtin(gkrellm_init_proc_monitor());
	add_builtin(gkrellm_init_sensor_monitor());
	add_builtin(gkrellm_init_disk_monitor());
	add_builtin(gkrellm_init_inet_monitor());
	add_builtin(gkrellm_init_net_monitor());
	add_builtin(gkrellm_init_timer_monitor());
	add_builtin(gkrellm_init_mem_monitor());
	add_builtin(gkrellm_init_swap_monitor());
	add_builtin(gkrellm_init_fs_monitor());
	add_builtin(gkrellm_init_mail_monitor());
	add_builtin(gkrellm_init_battery_monitor());
	add_builtin(gkrellm_init_uptime_monitor());
	}


void
gkrellm_print(const gchar *string)
	{
	gchar	*s;

	s = g_locale_from_utf8(string, -1, NULL, NULL, NULL);
	if (s)
		{
		fputs(s, stdout);
		g_free(s);
		}
	else
		fputs(string, stdout);
	}

static void
gkrellm_exit(gint exit_code)
	{
	gkrellm_sys_main_cleanup();
	exit(exit_code);
	}

static void
_signal_quit(gint sig)
	{
	gkrellm_save_all();
	gkrellm_exit(1);
	}

void
gkrellm_record_state(enum GkrellmState state, GkrellmMonitor *mon)
	{
	_GK.gkrellm_state = state;
	_GK.active_monitor = mon;
	}

static void
gkrellm_abort(gint sig)
	{
	gchar			*fault,
					*state,
					buf[512];
	gboolean		do_xmessage = TRUE;
	GkrellmMonitor	*mon 	= _GK.active_monitor;

	if (sig == SIGSEGV)
		fault = _("segmentation fault");
	else if (sig == SIGFPE)
		fault = _("floating point exception");
	else
		fault = _("aborted");

	if (_GK.gkrellm_state == INITIALIZING)
		state = _("initializing");
	else if (_GK.gkrellm_state == INIT_MONITOR)
		state = "init_monitor";
	else if (_GK.gkrellm_state == CREATE_MONITOR)
		state = "create_monitor";
	else if (_GK.gkrellm_state == UPDATE_MONITOR)
		state = "update_monitor";
	else if (_GK.gkrellm_state == CREATE_CONFIG)
		state = "create_config";
	else if (_GK.gkrellm_state == LOAD_CONFIG)
		state = "load_user_config";
	else if (_GK.gkrellm_state == SAVE_CONFIG)
		state = "save_user_config";
	else if (_GK.gkrellm_state == APPLY_CONFIG)
		state = "apply_config";
	else
		{
		state = "?";
		do_xmessage = FALSE;
		}

	snprintf(buf, sizeof(buf), "xmessage gkrellm %s:  %s  (%s)", fault,
				(mon && mon->name) ? mon->name : "", state);
	printf("%s\n", buf + 9);
	if (do_xmessage)
		g_spawn_command_line_async(buf, NULL);

	signal(SIGABRT, SIG_DFL);
	abort();
	}

static void
setup_signal_handler(void)
	{
	signal(SIGPIPE, SIG_IGN);
	signal(SIGINT, _signal_quit);
	signal(SIGQUIT, _signal_quit);
	signal(SIGTERM, _signal_quit);
	}


#if defined(WIN32) && defined(_WINDOWS)
int APIENTRY WinMain(HINSTANCE	hInstance,
					HINSTANCE	hPrevInstance,
					LPSTR		lpCmdLine,
					int			nCmdShow)
	{
	int		argc;
	gint	i;
	gchar	*s, *sm;
	gchar	**argv;
	gchar	*cmd;

	// need to get exe too
	cmd = GetCommandLine();
	g_shell_parse_argv(cmd, &argc, &argv, NULL);
#else
gint
main(gint argc, gchar **argv)
	{
	gint		i;
	gchar		*s;
#endif

	gkrellm_sys_main_init();

#ifdef ENABLE_NLS
	gtk_set_locale();
#endif

	g_thread_init(NULL);

	gtk_init(&argc, &argv);		/* Will call gdk_init() */

	gtk_widget_push_colormap(gdk_rgb_get_colormap());

#ifdef ENABLE_NLS
#ifdef LOCALEDIR
	bindtextdomain(PACKAGE, LOCALEDIR);
#endif
	textdomain(PACKAGE);
	bind_textdomain_codeset(PACKAGE, "UTF-8");
#endif	/* ENABLE_NLS */

	_GK.start_time = time(0);
	gkrellm_current_tm = *(localtime(&_GK.start_time));

	_GK.initialized = FALSE;
	gkrellm_record_state(INITIALIZING, NULL);
	signal(SIGFPE, gkrellm_abort);
	signal(SIGSEGV, gkrellm_abort);
	signal(SIGABRT, gkrellm_abort);

	g_set_print_handler(gkrellm_print);

	for (i = 1; i < argc; ++i)
		{
		s = argv[i];
		if (*s == '-')
			{
			++s;
			if (*s == '-')
				++s;
			}
		if ((!strcmp(s, "t") || !strcmp(s, "theme")) && i < argc - 1)
			{
			_GK.theme_path = g_strdup(argv[++i]);
			_GK.command_line_theme = g_strdup(_GK.theme_path);
			}
		else if (!strcmp(s, "sm-client-id") && i < argc - 1)
			_GK.session_id = g_strdup(argv[++i]);
		else if ((!strcmp(s, "s") || !strcmp(s, "server")) && i < argc - 1)
			{
			_GK.server = g_strdup(argv[++i]);
			_GK.client_mode = TRUE;
			}
		else if ((!strcmp(s, "P") || !strcmp(s, "port")) && i < argc-1)
			_GK.server_port = (gint) strtoul(argv[++i], NULL, 0);
		else if ((!strcmp(s, "p") || !strcmp(s, "plugin")) && i < argc - 1)
			_GK.command_line_plugin = g_strdup(argv[++i]);
		else if ((!strcmp(s, "config") || !strcmp(s, "c")) && i < argc - 1)
			_GK.config_suffix = g_strdup(argv[++i]);
		else if ((!strcmp(s, "geometry") || !strcmp(s, "g")) && i < argc - 1)
			geometry = argv[++i];
		else if (!strcmp(s, "wm"))
			_GK.command_line_decorated = TRUE;
		else if (!strcmp(s, "m2"))
			_GK.m2 = TRUE;
		else if ( (! strcmp(s, "withdrawn")) || (! strcmp(s, "w")))
			_GK.withdrawn = TRUE;
		else if (!strcmp(s, "force-host-config") || !strcmp(s, "f"))
			{
			_GK.force_host_config = TRUE;
			gkrellm_config_modified();
			}
		else if (!strcmp(s, "nt"))
			no_transparency = TRUE;
		else if (!strcmp(s, "nc"))
			_GK.no_config = TRUE;
		else if ((!strcmp(s, "debug-level") || !strcmp(s, "d")) && i < argc-1)
			_GK.debug_level = (gint) strtoul(argv[++i], NULL, 0);
		else if (!strncmp(s, "debug", 5))
			{
			if (s[5] != '\0')
				_GK.debug = atoi(s + 5);
			else
				_GK.debug = 1;
			}
		else if (!strcmp(s, "nolock"))
			_GK.nolock = TRUE;
		else if (!strcmp(s, "demo"))
			++_GK.demo;
		else if (!strcmp(s, "test"))
			_GK.test += 1;
		else if (!strcmp(s, "version") || !strcmp(s, "v"))
			{
			printf("%s %d.%d.%d%s\n", PACKAGE, GKRELLM_VERSION_MAJOR,
					GKRELLM_VERSION_MINOR, GKRELLM_VERSION_REV,
					GKRELLM_EXTRAVERSION);
			exit(0);
			}
		else if (strcmp(s, "help") == 0 || strcmp(s, "h") == 0)
			{
			usage();
			exit(0);
			}
		else
			{
			g_print(_("Bad arg: %s\n"), argv[i]);
			usage();
			exit(0);
			}
		}
	gdk_window_get_geometry(NULL /*gdk_root_parent*/, &i, &i, &_GK.w_display,
				&_GK.h_display, &i);

	if (_GK.debug_level)
		printf("--- GKrellM %d.%d.%d ---\n", GKRELLM_VERSION_MAJOR,
				GKRELLM_VERSION_MINOR, GKRELLM_VERSION_REV);
	if (_GK.server && !gkrellm_client_mode_connect())
		exit(0);

	check_gkrellm_directories();
	gkrellm_load_user_config(FALSE);		
	decorated = (_GK.command_line_decorated || _GK.decorated);
	if (   _GK.command_line_plugin || _GK.command_line_theme
		|| _GK.debug_level > 0 || _GK.debug > 0 || _GK.nolock
	   )
		_GK.allow_multiple_instances_real = TRUE;
	_GK.allow_multiple_instances_real |= _GK.allow_multiple_instances;

	create_widget_tree();
	top_window = gtree.window;

	load_builtin_monitors();
	gkrellm_plugins_load();

	gkrellm_build();
	gkrellm_make_themes_list();

	if ((_GK.gtk_settings = gtk_settings_get_default()) != NULL)
		{
		g_object_get(_GK.gtk_settings,
					"gtk-theme-name", &_GK.gtk_theme_name, NULL);
		g_signal_connect(_GK.gtk_settings, "notify::gtk-theme-name",
					G_CALLBACK(gkrellm_read_theme_event), NULL);
		}

	g_signal_connect(G_OBJECT(gtree.window), "delete_event",
				G_CALLBACK(cb_delete_event), NULL);
	g_signal_connect(G_OBJECT(gtree.window), "destroy",
				G_CALLBACK(cb_destroy_event), NULL);
	g_signal_connect(G_OBJECT(gtree.window), "configure_event",
				G_CALLBACK(cb_configure_notify), NULL);
	g_signal_connect(G_OBJECT(gtree.window), "map_event",
				G_CALLBACK(cb_map_event), NULL);
	g_signal_connect(G_OBJECT(gtree.window), "size_allocate",
				G_CALLBACK(cb_size_allocate), NULL);
	g_signal_connect(G_OBJECT(gtree.window), "client_event",
				G_CALLBACK(cb_client_event), NULL);

	g_signal_connect(G_OBJECT(gtree.top0_event_box), "button_press_event",
				G_CALLBACK(top_frame_button_press), NULL );
	g_signal_connect(G_OBJECT(gtree.top1_event_box), "button_press_event",
				G_CALLBACK(top_frame_button_press), NULL );
	g_signal_connect(G_OBJECT(gtree.top0_event_box), "motion_notify_event",
				G_CALLBACK(gkrellm_motion), NULL);
	g_signal_connect(G_OBJECT(gtree.top1_event_box), "motion_notify_event",
				G_CALLBACK(gkrellm_motion), NULL);
	g_signal_connect(G_OBJECT(gtree.top0_event_box), "button_release_event",
				G_CALLBACK(top_frame_button_release), NULL );
	g_signal_connect(G_OBJECT(gtree.top1_event_box), "button_release_event",
				G_CALLBACK(top_frame_button_release), NULL );

	g_signal_connect(G_OBJECT(gtree.left_event_box), "button_press_event",
				G_CALLBACK(side_frame_button_press), NULL );
	g_signal_connect(G_OBJECT(gtree.right_event_box), "button_press_event",
				G_CALLBACK(side_frame_button_press), NULL );

	item_factory = gkrellm_create_item_factory_popup();

	if (_GK.sticky_state)
		gtk_window_stick(GTK_WINDOW(top_window));
	gkrellm_winop_options(argc, argv);
	gtk_widget_show(gtree.window);
	gkrellm_winop_withdrawn();

	if (geometry || _GK.save_position)
		configure_position_lock = TRUE;		/* see cb_configure_notify */

	if (geometry)		/* Command line placement overrides */
		gkrellm_winop_place_gkrellm(geometry);
	else if (_GK.save_position)
		set_or_save_position(0);

	gkrellm_start_timer(_GK.update_HZ);
	setup_signal_handler();
	gtk_main ();
	gkrellm_save_all();
	gkrellm_exit(0);

#if defined(_WINDOWS)
    g_strfreev(argv);
#endif

	return 0;
	}