applications/gnome-control-center
3
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Split code for changing window managers into libgnome-window-settings.

Browse source 
2002-06-02  Seth Nickell  <snickell@stanford.edu>

	* Makefile.am:
	* gnome-window-properties.c: (wm_selection_changed),
	(wm_widget_add_wm), (update_gui), (apply_wm), (create_dialog),
	(main):

	Split code for changing window managers into libgnome-window-settings.
	This is so in the future we can potentially move this into gnome-settings-daemon,
	though for now its not robust enough that we really want to do that.

	* metacity-window-manager.c: (window_manager_new),
	(metacity_window_manager_init), (metacity_window_manager_finalize),
	(metacity_window_manager_class_init),
	(metacity_window_manager_get_type):
	* metacity-window-manager.h:

	Update to match changes to gnome-window-manager.h

	* wm-exec.c:
	* wm-list.c:
	* wm-properties.h:

	Move these into libgnome-window-settings.

	(Jacob, I did make dist, and then built the resulting tarball, hope I
	 don't cause problems this time :-/)
This commit is contained in:
Seth Nickell 2002-06-03 00:27:15 +00:00 • committed by Seth Nickell
parent a1465dd2fc
commit 0a5695f294
8 changed files with 136 additions and 1663 deletions
Download patch file Download diff file Expand all files Collapse all files

28
capplets/windows/ChangeLog
View file

@ -1,3 +1,31 @@
2002-06-02 Seth Nickell <snickell@stanford.edu>
* Makefile.am:
* gnome-window-properties.c: (wm_selection_changed),
(wm_widget_add_wm), (update_gui), (apply_wm), (create_dialog),
(main):
Split code for changing window managers into libgnome-window-settings.
This is so in the future we can potentially move this into gnome-settings-daemon,
though for now its not robust enough that we really want to do that.
* metacity-window-manager.c: (window_manager_new),
(metacity_window_manager_init), (metacity_window_manager_finalize),
(metacity_window_manager_class_init),
(metacity_window_manager_get_type):
* metacity-window-manager.h:
Update to match changes to gnome-window-manager.h
* wm-exec.c:
* wm-list.c:
* wm-properties.h:
Move these into libgnome-window-settings.
(Jacob, I did make dist, and then built the resulting tarball, hope I
don't cause problems this time :-/)
2002-05-30 Kjartan Maraas <kmaraas@gnome.org>
* gnome-window-properties.c (main): Use GETTEXT_PACKAGE, not PACKAGE.

10
capplets/windows/Makefile.am
View file

@ -1,13 +1,11 @@
bin_PROGRAMS = gnome-window-properties
gnome_window_properties_LDADD = $(GNOMECC_CAPPLETS_LIBS) \
$(top_builddir)/libwindow-settings/libwindow-settings.la
-L$(top_builddir)/libwindow-settings/ -lgnome-window-settings
gnome_window_properties_SOURCES = \
gnome-window-properties.c \
wm-properties.h \
wm-exec.c \
wm-list.c
gnome-window-properties.c
wms_flags = -export_dynamic -avoid-version
wmsdir = $(libdir)/window-manager-settings/
@ -21,7 +19,7 @@ libmetacity_la_SOURCES = \
libmetacity_la_LDFLAGS = $(wms_flags)
libmetacity_la_LIBADD =
#libmetacity_la_LIBADD = $(top_builddir)/libwindow-settings/libwindow-settings.la
@INTLTOOL_DESKTOP_RULE@

643
capplets/windows/gnome-window-properties.c
View file

@ -13,20 +13,18 @@
#include <glade/glade.h>
#include <ctype.h>
#include <gmodule.h>
#include "capplet-util.h"
#include "gconf-property-editor.h"
#include "wm-properties.h"
//#include "gnome-startup.h"
#include <gnome-wm-manager.h>
#define THEME_KEY "/desktop/gnome/applications/window_manager/theme"
#define TITLEBAR_FONT_KEY "/desktop/gnome/applications/window_manager/titlebar_font"
#define FOCUS_FOLLOWS_MOUSE_KEY "/desktop/gnome/applications/window_manager/focus_follows_mouse"
/* prototypes */
static void restart (gboolean force);
static void revert_callback (void);
static void cancel_callback (void);
GnomeClient *client = NULL;
/* structures */
@ -39,116 +37,28 @@ typedef struct {
} WMDialog;
/* vars. */
static GtkWidget *capplet;
static GtkWidget *wm_widget;
static GtkWidget *apply_now_button;
static GtkWidget *properties_box;
static WindowManager *selected_wm = NULL;
static GtkWidget *restart_dialog = NULL;
static GtkWidget *restart_label = NULL;
guint restart_dialog_timeout;
gchar *restart_name = NULL;
/* Time until dialog times out */
gdouble restart_remaining_time;
gint restart_displayed_time;
GnomeClient *client = NULL;
gchar *argv0;
/* Enumeration describing the current state of the capplet.
* in any other state than idle, all controls are !sensitive.
*/
typedef enum {
STATE_IDLE,
STATE_TRY,
STATE_REVERT,
STATE_OK,
STATE_CANCEL,
STATE_TRY_REVERT, /* Currently trying, revert afterwards */
STATE_TRY_CANCEL /* Currently trying, cancel afterwards */
} StateType;
/* The possible transitions between states are described below.
*
* operation | try revert ok cancel finish
* ===========+=================================================
* IDLE | TRY REVERT OK CANCEL
* TRY | TRY_REVERT OK TRY_CANCEL IDLE
* REVERT | CANCEL CANCEL IDLE
* OK | (quit)
* CANCEL | (quit)
* TRY_REVERT | TRY_CANCEL TRY_CANCEL REVERT
* TRY_CANCEL | CANCEL
*
* When a restart fails, there are three cases
*
* (1) The failure was because the current window manager didn't
* die. We inform the user of the situation, and then
* abort the operation.
*
* (2) The window manager didn't start, and we don't have a
* a fallback. We pop up a error dialog, tell the user
* to start a new window manager, and abort the operation.
*
* (3) The window manager didn't start, and we previously had a
* window manager runnning. We pop up a warning dialog,
* then try to go back to the old window manager.
*
* operation | (1) (2) (3)
* ===========+=================================================
* IDLE |
* TRY | IDLE IDLE TRY
* REVERT | IDLE IDLE REVERT
* OK | (quit) (quit) OK
* CANCEL | (quit) (quit) CANCEL
* TRY_REVERT | REVERT REVERT REVERT
* TRY_CANCEL | CANCEL CANCEL CANCEL
*/
/* Current state
*/
StateType state = STATE_IDLE;
/* Set TRUE when we've exited the main loop, but restart_pending
*/
gboolean quit_pending = FALSE;
/* Set TRUE when we're waiting for the WM to restart
*/
gboolean restart_pending = FALSE;
/* Set TRUE while we are filling in the list
*/
gboolean in_fill = FALSE;
static gint cap_session_init = 0;
static struct poptOption cap_options[] = {
{"init-session-settings", '\0', POPT_ARG_NONE, &cap_session_init, 0,
N_("Initialize session settings"), NULL},
{NULL, '\0', 0, NULL, 0}
};
static void state_changed (void);
static void update_session (void);
static GtkWidget *wm_menu;
static GtkWidget *option_menu;
static GList *wm_menu_window_managers;
GnomeWindowManager *selected_wm;
gboolean in_fill;
static void
wm_selection_changed (GtkOptionMenu *option_menu, gpointer data)
{
int index;
WindowManager *wm;
GnomeWindowManager *wm;
index = gtk_option_menu_get_history (option_menu);
wm = (WindowManager *) g_list_nth (wm_menu_window_managers, index)->data;
wm = (GnomeWindowManager *) g_list_nth (wm_menu_window_managers, index)->data;
if (!in_fill) {
if (wm != selected_wm) {
@ -182,9 +92,12 @@ wm_widget_new ()
}
static void
wm_widget_add_wm (WindowManager *wm, const char *row_text)
wm_widget_add_wm (GnomeWindowManager *wm)
{
GtkWidget *menu_item;
const char *row_text;
row_text = gnome_window_manager_get_name (wm);
menu_item = gtk_menu_item_new_with_label (row_text);
gtk_widget_show_all (menu_item);
@ -221,512 +134,33 @@ state_changed (void)
set_wm_change_pending (TRUE);
}
static void
restart_label_update (void)
{
gchar *tmp;
if ((gint)restart_remaining_time != restart_displayed_time) {
restart_displayed_time = restart_remaining_time;
tmp = g_strdup_printf (_("Starting %s\n"
"(%d seconds left before operation times out)"),
restart_name,
restart_displayed_time);
gtk_label_set_text (GTK_LABEL (restart_label), tmp);
g_free (tmp);
}
}
static gboolean
restart_dialog_raise (gpointer data)
{
if (restart_dialog && GTK_WIDGET_REALIZED (restart_dialog)) {
restart_remaining_time -= 0.25;
restart_label_update();
gdk_window_raise (restart_dialog->window);
}
return TRUE;
}
static void
restart_dialog_destroyed (GtkWidget *widget)
{
if (restart_dialog_timeout) {
gtk_timeout_remove (restart_dialog_timeout);
restart_dialog_timeout = 0;
}
restart_dialog = NULL;
}
static void
show_restart_dialog (gchar *name)
{
GtkWidget *hbox;
GtkWidget *frame;
GtkWidget *pixmap;
gchar *tmp;
if (!restart_dialog) {
restart_dialog = gtk_window_new (GTK_WINDOW_POPUP);
gtk_window_set_position (GTK_WINDOW (restart_dialog),
GTK_WIN_POS_CENTER);
gtk_signal_connect (GTK_OBJECT (restart_dialog), "destroy",
GTK_SIGNAL_FUNC (restart_dialog_destroyed),
&restart_dialog);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
gtk_container_add (GTK_CONTAINER (restart_dialog), frame);
hbox = gtk_hbox_new (FALSE, GNOME_PAD);
gtk_container_set_border_width (GTK_CONTAINER (hbox), GNOME_PAD);
gtk_container_add (GTK_CONTAINER (frame), hbox);
tmp = gnome_unconditional_pixmap_file("gnome-info.png");
if (tmp) {
pixmap = gnome_pixmap_new_from_file(tmp);
g_free(tmp);
gtk_box_pack_start (GTK_BOX (hbox), pixmap, FALSE, FALSE, 0);
}
restart_label = gtk_label_new ("");
gtk_box_pack_start (GTK_BOX (hbox), restart_label, FALSE, FALSE, GNOME_PAD);
}
if (!restart_dialog_timeout) {
restart_dialog_timeout = gtk_timeout_add (250, restart_dialog_raise, NULL);
}
restart_remaining_time = 10.0;
restart_displayed_time = -1;
if (restart_name)
g_free (restart_name);
restart_name = g_strdup (name);
restart_label_update ();
gtk_widget_show_all (restart_dialog);
}
static void
hide_restart_dialog (void)
{
if (restart_dialog)
gtk_widget_destroy (restart_dialog);
}
static void
update_session (void)
{
WindowManager *current_wm = wm_list_get_current();
gchar *session_args[3];
if (!current_wm)
return;
if (current_wm->session_managed) {
gnome_client_set_restart_style (client,
GNOME_RESTART_NEVER);
} else {
session_args[0] = argv0;
session_args[1] = "--init-session-settings";
session_args[2] = NULL;
/* We use a priority of 15 so that we start after
* session-managed WM's (priority 10), for safety.
*/
gnome_client_set_priority (client, 15);
gnome_client_set_restart_style (client,
GNOME_RESTART_ANYWAY);
gnome_client_set_restart_command (client, 2,
session_args);
}
gnome_client_flush (client);
}
static void
init_session (void)
{
GnomeClientFlags flags;
gint token;
return;
client = gnome_master_client ();
flags = gnome_client_get_flags (client);
if (flags & GNOME_CLIENT_IS_CONNECTED) {
/*token = gnome_startup_acquire_token("GNOME_WM_PROPERTIES",
gnome_client_get_id(client));*/
if (token)
update_session();
else {
gnome_client_set_restart_style (client,
GNOME_RESTART_NEVER);
gnome_client_flush (client);
}
}
}
static void
update_gui (void)
{
GList *tmp_list;
GnomeWindowManager *wm;
wm_widget_clear ();
in_fill = TRUE;
tmp_list = window_managers;
while (tmp_list) {
gchar *row_text;
WindowManager *wm;
tmp_list = gnome_wm_manager_get_list ();
printf ("got a list of %d wms\n", g_list_length (tmp_list));
for (tmp_list = gnome_wm_manager_get_list (); tmp_list != NULL; tmp_list = tmp_list->next) {
wm = tmp_list->data;
if (wm->is_user && !wm->is_present) {
row_text = g_strconcat (gnome_desktop_item_get_string (wm->dentry, GNOME_DESKTOP_ITEM_NAME),
_(" (Not found)"), NULL);
} else {
row_text = g_strdup (gnome_desktop_item_get_string (wm->dentry, GNOME_DESKTOP_ITEM_NAME));
}
wm_widget_add_wm (wm, row_text);
g_free (row_text);
tmp_list = tmp_list->next;
wm_widget_add_wm (wm);
}
in_fill = FALSE;
}
static void
init_callback (WMResult result, gpointer data)
{
switch (result) {
case WM_SUCCESS:
break;
case WM_ALREADY_RUNNING:
g_warning (_("wm-properties-capplet: Unable to initialize window manager.\n"
"\tAnother window manager is already running and could not be killed\n"));
break;
case WM_CANT_START:
g_warning (_("wm-properties-capplet: Unable to initialize window manager.\n"
"\t'%s' didn't start\n"), (gchar *)data);
break;
}
g_free (data);
gtk_main_quit ();
}
static void
restart_finalize ()
{
wm_list_set_current (selected_wm);
hide_restart_dialog();
switch (state) {
case STATE_TRY:
case STATE_REVERT:
gtk_widget_set_sensitive (capplet, TRUE);
update_gui();
state = STATE_IDLE;
break;
case STATE_OK:
case STATE_CANCEL:
if (quit_pending)
gtk_main_quit();
break;
default:
g_warning ("Finalize in state %d!!!\n", state);
return;
}
restart_pending = FALSE;
}
static void
restart_failure (WMResult reason)
{
GtkWidget *msgbox;
WindowManager *current_wm;
gchar *msg = NULL;
gboolean modal = FALSE;
current_wm = wm_list_get_current ();
/* Did the previous window manager not die?
*/
if (reason == WM_ALREADY_RUNNING) {
msg = g_strdup (_("Previous window manager did not die\n"));
switch (state) {
case STATE_TRY:
case STATE_REVERT:
case STATE_OK:
case STATE_CANCEL:
selected_wm = current_wm;
restart_finalize ();
break;
case STATE_TRY_REVERT:
revert_callback ();
break;
case STATE_TRY_CANCEL:
cancel_callback ();
break;
default:
g_warning ("Failure in state %d!!!\n", state);
return;
}
}
/* Is there something reasonable to try to fall back to?
*/
else if (current_wm != selected_wm) {
switch (state) {
case STATE_TRY:
case STATE_REVERT:
case STATE_OK:
case STATE_CANCEL:
msg = g_strdup_printf (_("Could not start '%s'.\n"
"Falling back to previous window manager '%s'\n"),
selected_wm?gnome_desktop_item_get_string (selected_wm->dentry, GNOME_DESKTOP_ITEM_NAME):"Unknown",
current_wm?gnome_desktop_item_get_string (current_wm->dentry, GNOME_DESKTOP_ITEM_NAME):"Unknown");
selected_wm = current_wm;
restart(TRUE);
break;
case STATE_TRY_REVERT:
revert_callback ();
break;
case STATE_TRY_CANCEL:
cancel_callback ();
break;
default:
g_warning ("Failure in state %d!!!\n", state);
return;
}
/* Give up */
} else {
switch (state) {
case STATE_OK:
case STATE_CANCEL:
modal = TRUE; /* prevent an immediate exit */
/* Fall through */
case STATE_TRY:
case STATE_REVERT:
msg = g_strdup (_("Could not start fallback window manager.\n"
"Please run a window manager manually. You can\n"
"do this by selecting \"Run Program\" in the\n"
"foot menu\n"));
restart_finalize();
break;
case STATE_TRY_REVERT:
revert_callback ();
break;
case STATE_TRY_CANCEL:
cancel_callback ();
break;
default:
g_warning ("Failure in state %d!!!\n", state);
return;
}
}
if (msg) {
msgbox = gnome_message_box_new (msg,
GNOME_MESSAGE_BOX_ERROR,
_("OK"), NULL);
if (modal)
gnome_dialog_run (GNOME_DIALOG (msgbox));
else
gtk_widget_show (msgbox);
g_free (msg);
}
}
static void
show_restart_info (void)
{
gchar *save_session;
save_session = gnome_is_program_in_path ("save-session");
if (save_session != NULL) {
system (save_session);
}
g_free (save_session);
}
static void
restart_finish (void)
{
switch (state) {
case STATE_TRY:
case STATE_REVERT:
case STATE_OK:
case STATE_CANCEL:
hide_restart_dialog();
show_restart_info ();
restart_finalize();
break;
case STATE_TRY_REVERT:
revert_callback ();
break;
case STATE_TRY_CANCEL:
cancel_callback ();
break;
default:
g_warning ("Finished in state %d!!!\n", state);
return;
}
}
static void
restart_callback (WMResult result, gpointer data)
{
if (result == WM_SUCCESS)
restart_finish ();
else
restart_failure (result);
}
static void
restart (gboolean force)
{
WindowManager *current_wm = wm_list_get_current(), *mywm;
static gboolean last_try_was_twm = FALSE;
GnomeDesktopItem *twm_dentry = gnome_desktop_item_new ();
WindowManager twm_fallback = {twm_dentry, "twm", "twm", 0, 0, 1, 0};
gnome_desktop_item_set_entry_type (twm_dentry, GNOME_DESKTOP_ITEM_TYPE_APPLICATION);
gnome_desktop_item_set_string (twm_dentry,
GNOME_DESKTOP_ITEM_NAME, "twm");
gnome_desktop_item_set_string (twm_dentry,
GNOME_DESKTOP_ITEM_COMMENT, "twm");
gnome_desktop_item_set_string (twm_dentry,
GNOME_DESKTOP_ITEM_EXEC, "twm");
if(selected_wm) {
last_try_was_twm = FALSE;
mywm = selected_wm;
} else if(!last_try_was_twm) {
last_try_was_twm = TRUE;
mywm = (WindowManager*)&twm_fallback;
} else {
restart_finalize();
gnome_desktop_item_unref (twm_dentry);
return;
}
if (force || current_wm != mywm) {
show_restart_dialog (g_strdup (gnome_desktop_item_get_string (mywm->dentry, GNOME_DESKTOP_ITEM_NAME)));
if (state != STATE_OK && state != STATE_CANCEL)
gtk_widget_set_sensitive (capplet, FALSE);
restart_pending = TRUE;
wm_restart (mywm,
capplet->window,
restart_callback,
NULL);
} else {
restart_finalize ();
}
gnome_desktop_item_unref (twm_dentry);
}
static void
revert_callback (void)
{
StateType old_state = state;
switch (state) {
case STATE_IDLE:
case STATE_TRY_REVERT:
wm_list_revert();
selected_wm = wm_list_get_revert();
state = STATE_REVERT;
restart (old_state == STATE_TRY_REVERT);
update_gui();
break;
case STATE_TRY:
state = STATE_TRY_REVERT;
break;
default:
g_warning ("revert callback in state %d!!!\n", state);
return;
}
}
static void
cancel_callback (void)
{
StateType old_state = state;
switch (state) {
case STATE_IDLE:
case STATE_TRY_CANCEL:
wm_list_revert();
selected_wm = wm_list_get_revert();
state = STATE_CANCEL;
restart (old_state == STATE_TRY_CANCEL);
break;
case STATE_TRY:
state = STATE_TRY_CANCEL;
break;
case STATE_REVERT:
state = STATE_CANCEL;
break;
case STATE_TRY_REVERT:
state = STATE_TRY_CANCEL;
break;
default:
g_warning ("ok callback in state %d!!!\n", state);
return;
}
}
static void
apply_wm (GObject *object, gpointer data)
{
state = STATE_TRY;
restart(FALSE);
wm_list_set_current (selected_wm);
wm_list_save ();
update_session ();
gnome_wm_manager_set_current (selected_wm);
}
static GladeXML *
@ -747,8 +181,6 @@ create_dialog (void)
gtk_box_pack_start (GTK_BOX (WID ("wm_widget_box")), wm_widget, TRUE, TRUE, 0);
update_gui();
return dialog;
}
@ -766,6 +198,8 @@ setup_dialog (GladeXML *dialog)
NULL);
}
int
main (int argc, char **argv)
{
@ -776,21 +210,11 @@ main (int argc, char **argv)
bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
argv0 = g_strdup (argv[0]);
gnome_program_init ("wm-properties", VERSION,
LIBGNOMEUI_MODULE, argc, argv,
GNOME_PARAM_POPT_TABLE, &cap_options,
GNOME_PARAM_POPT_TABLE,
NULL);
/* Read in the list of window managers, and the current
* window manager
*/
wm_list_init();
selected_wm = wm_list_get_current();
if (!cap_session_init)
{
init_session();
dialog = create_dialog ();
setup_dialog (dialog);
@ -800,29 +224,20 @@ main (int argc, char **argv)
NULL);
g_signal_connect (G_OBJECT (dialog_win), "response", (GCallback)response_cb, NULL);
capplet = dialog_win;
gnome_wm_manager_init (dialog_win);
update_gui ();
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_win)->vbox), WID ("prefs_widget"), TRUE, TRUE, GNOME_PAD_SMALL);
gtk_widget_show_all (dialog_win);
gtk_main ();
/* FIXME: we need to handle this through the library somehow
if (restart_pending) {
quit_pending = TRUE;
gtk_main();
}
}
else {
if (selected_wm &&
!selected_wm->session_managed &&
!wm_is_running()) {
wm_restart (selected_wm, NULL, init_callback,
g_strdup (gnome_desktop_item_get_string (selected_wm->dentry, GNOME_DESKTOP_ITEM_NAME)));
gtk_main ();
}
init_session();
}
*/
return 0;
}

71
capplets/windows/metacity-window-manager.c
View file

@ -1,6 +1,6 @@
#include "metacity-window-manager.h"
static GnomeWindowManagerClass *parent_class = NULL;
static GnomeWindowManagerClass *parent_class;
struct _MetacityWindowManagerPrivate {
};
@ -15,7 +15,6 @@ window_manager_new (void)
return wm;
}
static void
metacity_set_theme (const char *theme_name)
{
@ -46,33 +45,39 @@ metacity_set_focus_follows_mouse (gboolean focus_follows_mouse)
}
static void
finalize (GObject *object)
{
MetacityWindowManager *wm;
wm = METACITY_WINDOW_MANAGER (object);
if (wm->private == NULL) {
return;
static void
metacity_window_manager_init (MetacityWindowManager *metacity_window_manager, MetacityWindowManagerClass *class)
{
metacity_window_manager->p = g_new0 (MetacityWindowManagerPrivate, 1);
}
g_free (wm->private);
wm->private = NULL;
static void
metacity_window_manager_finalize (GObject *object)
{
MetacityWindowManager *metacity_window_manager;
g_return_if_fail (object != NULL);
g_return_if_fail (IS_METACITY_WINDOW_MANAGER (object));
metacity_window_manager = METACITY_WINDOW_MANAGER (object);
g_free (metacity_window_manager->p);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
class_init (MetacityWindowManagerClass *klass)
static void
metacity_window_manager_class_init (MetacityWindowManagerClass *class)
{
GObjectClass *object_class;
GnomeWindowManagerClass *wm_class;
object_class = G_OBJECT_CLASS (klass);
wm_class = GNOME_WINDOW_MANAGER_CLASS (klass);
object_class = G_OBJECT_CLASS (class);
wm_class = GNOME_WINDOW_MANAGER_CLASS (class);
object_class->finalize = finalize;
object_class->finalize = metacity_window_manager_finalize;
wm_class->set_theme = metacity_set_theme;
wm_class->get_theme_list = metacity_get_theme_list;
@ -80,31 +85,35 @@ class_init (MetacityWindowManagerClass *klass)
wm_class->get_focus_follows_mouse = metacity_get_focus_follows_mouse;
wm_class->set_focus_follows_mouse = metacity_set_focus_follows_mouse;
parent_class = g_type_class_peek_parent (klass);
parent_class = g_type_class_peek_parent (class);
}
static void
init (MetacityWindowManager *wm)
{
wm->private = g_new (MetacityWindowManagerPrivate, 1);
}
/* API */
GType
metacity_window_manager_get_type (void)
{
static GType type = 0;
static GType metacity_window_manager_type = 0;
if (type == 0) {
GTypeInfo info = {
if (!metacity_window_manager_type) {
static GTypeInfo metacity_window_manager_info = {
sizeof (MetacityWindowManagerClass),
NULL, NULL, (GClassInitFunc) class_init, NULL, NULL,
sizeof (MetacityWindowManager), 0, (GInstanceInitFunc) init,
NULL, /* GBaseInitFunc */
NULL, /* GBaseFinalizeFunc */
(GClassInitFunc) metacity_window_manager_class_init,
NULL, /* GClassFinalizeFunc */
NULL, /* user-supplied data */
sizeof (MetacityWindowManager),
0, /* n_preallocs */
(GInstanceInitFunc) metacity_window_manager_init,
NULL
};
type = g_type_register_static (METACITY_WINDOW_MANAGER_TYPE, "MetacityWindowManager", &info, 0);
metacity_window_manager_type =
g_type_register_static (gnome_window_manager_get_type (),
"MetacityWindowManager",
&metacity_window_manager_info, 0);
}
return type;
return metacity_window_manager_type;
}

24
capplets/windows/metacity-window-manager.h
View file

@ -1,37 +1,29 @@
#ifndef METACITY_WINDOW_MANAGER_H
#define METACITY_WINDOW_MANAGER_H
#include <glib/gerror.h>
#include <glib-object.h>
#include "gnome-window-manager.h"
G_BEGIN_DECLS
#define METACITY_WINDOW_MANAGER_TYPE (metacity_window_manager_get_type ())
#define METACITY_WINDOW_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), METACITY_WINDOW_MANAGER_TYPE, MetacityWindowManager))
#define METACITY_WINDOW_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), METACITY_WINDOW_MANAGER_TYPE, MetacityWindowManagerClass))
#define IS_METACITY_WINDOW_MANAGER(obj) (GTK_TYPE_CHECK_INSTANCE_TYPE ((obj), METACITY_WINDOW_MANAGER_TYPE))
#define IS_METACITY_WINDOW_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), METACITY_WINDOW_MANAGER_TYPE))
#define METACITY_WINDOW_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), METACITY_WINDOW_MANAGER_TYPE, MetacityWindowManagerClass))
#define METACITY_WINDOW_MANAGER(obj) G_TYPE_CHECK_INSTANCE_CAST (obj, metacity_window_manager_get_type (), MetacityWindowManager)
#define METACITY_WINDOW_MANAGER_CLASS(klass) G_TYPE_CHECK_CLASS_CAST (klass, metacity_window_manager_get_type (), MetacityWindowManagerClass)
#define IS_METACITY_WINDOW_MANAGER(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, metacity_window_manager_get_type ())
typedef struct _MetacityWindowManager MetacityWindowManager;
typedef struct _MetacityWindowManagerClass MetacityWindowManagerClass;
typedef struct _MetacityWindowManagerPrivate MetacityWindowManagerPrivate;
struct _MetacityWindowManager
{
GnomeWindowManager parent_instance;
MetacityWindowManagerPrivate *private;
GnomeWindowManager parent;
MetacityWindowManagerPrivate *p;
};
struct _MetacityWindowManagerClass
{
GnomeWindowManagerClass parent_class;
GnomeWindowManagerClass klass;
};
GType metacity_window_manager_get_type (void);
G_END_DECLS
#endif /* METACITY_WINDOW_MANAGER_H */
#endif

331
capplets/windows/wm-exec.c
View file

@ -1,331 +0,0 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- */
/* Copyright (C) 1998 Redhat Software Inc.
* Code available under the Gnu GPL.
* Authors: Owen Taylor <otaylor@redhat.com>
*/
#include <gtk/gtk.h>
#include <gdk/gdkx.h>
#include <libgnome/libgnome.h>
#include "wm-properties.h"
typedef struct _RestartInfo RestartInfo;
struct _RestartInfo {
GnomeDesktopItem *dentry;
gint retries;
WMResultFunc callback;
gpointer data;
};
gboolean
wm_is_running (void)
{
gboolean result;
guint old_mask;
XWindowAttributes attrs;
gdk_error_trap_push ();
XGetWindowAttributes (GDK_DISPLAY(), GDK_ROOT_WINDOW(), &attrs);
XSelectInput (GDK_DISPLAY(), GDK_ROOT_WINDOW(),
SubstructureRedirectMask);
XSync (GDK_DISPLAY(), False);
if (gdk_error_trap_pop () == 0) {
result = FALSE;
XSelectInput (GDK_DISPLAY(), GDK_ROOT_WINDOW(),
attrs.your_event_mask);
} else
result = TRUE;
return result;
}
/* Cut and paste from gnome-libs/gnome_win_hints_wm_exists, except that we
* return the xid instead of a window
*/
static Window
find_gnome_wm_window(void)
{
Atom r_type;
int r_format;
unsigned long count;
unsigned long bytes_remain;
unsigned char *prop, *prop2;
GdkAtom cardinal_atom = gdk_atom_intern ("CARDINAL", FALSE);
gdk_error_trap_push ();
if (XGetWindowProperty(GDK_DISPLAY(), GDK_ROOT_WINDOW(),
gdk_x11_atom_to_xatom (gdk_atom_intern ("_WIN_SUPPORTING_WM_CHECK", FALSE)),
0, 1, False, gdk_x11_atom_to_xatom (cardinal_atom),
&r_type, &r_format,
&count, &bytes_remain, &prop) == Success && prop)
{
if (r_type == gdk_x11_atom_to_xatom (cardinal_atom) && r_format == 32 && count == 1)
{
Window n = *(long *)prop;
if (XGetWindowProperty(GDK_DISPLAY(), n,
gdk_x11_atom_to_xatom (gdk_atom_intern ("_WIN_SUPPORTING_WM_CHECK", FALSE)),
0, 1, False, gdk_x11_atom_to_xatom (cardinal_atom),
&r_type, &r_format, &count, &bytes_remain,
&prop2) == Success && prop)
{
if (r_type == gdk_x11_atom_to_xatom (cardinal_atom) && r_format == 32 && count == 1)
{
XFree(prop);
XFree(prop2);
gdk_error_trap_pop ();
return n;
}
XFree(prop2);
}
}
XFree(prop);
}
gdk_error_trap_pop ();
return None;
}
static Window
find_wm_window_from_client (GdkWindow *client)
{
Window window, frame, parent, root;
Window *children;
unsigned int nchildren;
gboolean needs_pop = TRUE;
if (!client)
return None;
frame = None;
window = GDK_WINDOW_XWINDOW (client);
gdk_error_trap_push ();
while (XQueryTree (GDK_DISPLAY(), window,
&root, &parent, &children, &nchildren))
{
if (gdk_error_trap_pop != 0)
{
needs_pop = FALSE;
break;
}
gdk_error_trap_push ();
if (children)
XFree(children);
if (window == root)
break;
if (root == parent) {
frame = window;
break;
}
window = parent;
}
if (needs_pop)
gdk_error_trap_pop ();
return frame;
}
static gboolean
window_has_wm_state (Window window)
{
Atom r_type;
int r_format;
unsigned long count;
unsigned long bytes_remain;
unsigned char *prop;
if (XGetWindowProperty(GDK_DISPLAY(), window,
gdk_x11_atom_to_xatom (gdk_atom_intern ("WM_STATE", FALSE)),
0, 0, False, AnyPropertyType,
&r_type, &r_format,
&count, &bytes_remain, &prop) == Success) {
if (r_type != None) {
XFree(prop);
return TRUE;
}
}
return FALSE;
}
static gboolean
descendent_has_wm_state (Window window)
{
gboolean result = FALSE;
Window parent, root;
Window *children;
unsigned int nchildren;
gint i;
if (!XQueryTree (GDK_DISPLAY(), window,
&root, &parent, &children, &nchildren))
return FALSE;
for (i=0; i<nchildren; i++) {
if (window_has_wm_state (children[i]) ||
descendent_has_wm_state (children[i])) {
result = TRUE;
break;
}
}
if (children)
XFree (children);
return result;
}
/* This function tries to find a window manager frame by
* hunting all the children of the root window
*/
static Window
find_wm_window_from_hunt (void)
{
Window parent, root, frame;
Window *children;
unsigned int nchildren;
gint i;
frame = None;
gdk_error_trap_push ();
XQueryTree (GDK_DISPLAY(), GDK_ROOT_WINDOW (),
&root, &parent, &children, &nchildren);
/* We are looking for a window that doesn't have WIN_STATE
* set on it, but does have a child with WIN_STATE set
*/
for (i=0; i<nchildren; i++) {
if (!window_has_wm_state (children[i]) &&
descendent_has_wm_state (children[i])) {
frame = children[i];
break;
}
}
if (children)
XFree (children);
gdk_error_trap_pop ();
return frame;
}
static Window
find_wm_window (GdkWindow *client)
{
Window wm_window = None;
/* First, try to find a GNOME compliant WM */
wm_window = find_gnome_wm_window();
if (!wm_window) {
wm_window = find_wm_window_from_client (client);
}
if (!wm_window) {
wm_window = find_wm_window_from_hunt ();
}
return wm_window;
}
static gboolean
start_timeout (gpointer data)
{
RestartInfo *info = data;
if (wm_is_running ()) {
info->callback(WM_SUCCESS, info->data);
gnome_desktop_item_unref (info->dentry);
g_free (info);
return FALSE;
} else {
info->retries--;
if (info->retries > 0)
return TRUE;
else {
info->callback(WM_CANT_START, info->data);
gnome_desktop_item_unref (info->dentry);
g_free (info);
return FALSE;
}
}
}
static void
start_do (RestartInfo *info)
{
gnome_desktop_item_launch (info->dentry, 0, 0, NULL);
info->retries = 10;
gtk_timeout_add (1000, start_timeout, info);
}
static gboolean
kill_timeout (gpointer data)
{
RestartInfo *info = data;
if (!wm_is_running ()) {
start_do (info);
return FALSE;
} else {
info->retries--;
if (info->retries > 0)
return TRUE;
else {
info->callback(WM_ALREADY_RUNNING, info->data);
gnome_desktop_item_unref (info->dentry);
g_free (info);
return FALSE;
}
}
}
void
wm_restart (WindowManager *new,
GdkWindow *client,
WMResultFunc callback,
gpointer data)
{
Window wm_window;
RestartInfo *info;
g_return_if_fail (new->is_present);
info = g_new (RestartInfo, 1);
info->dentry = gnome_desktop_item_copy (new->dentry);
info->callback = callback;
info->data = data;
info->retries = 10;
if (wm_is_running ()) {
wm_window = find_wm_window (client);
if (!wm_window) {
(*callback) (WM_ALREADY_RUNNING, data);
gnome_desktop_item_unref (info->dentry);
g_free (info);
} else {
XKillClient (GDK_DISPLAY(), wm_window);
gtk_timeout_add (1000, kill_timeout, info);
}
} else {
start_do (info);
}
}
WindowManager *
wm_guess_current (void)
{
return NULL;
}

575
capplets/windows/wm-list.c
View file

@ -1,575 +0,0 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- */
/* Copyright (C) 1998 Redhat Software Inc.
* Code available under the Gnu GPL.
* Authors: Owen Taylor <otaylor@redhat.com>,
* Bradford Hovinen <hovinen@helixcode.com>
*/
#include <sys/types.h>
#include <dirent.h>
#include <unistd.h>
#include <ctype.h>
#include <string.h>
#include <libgnome/libgnome.h>
#include <gconf/gconf-client.h>
#include "wm-properties.h"
#define CONFIG_PREFIX "/desktop/gnome/applications/window_manager"
/* Current list of window managers */
GList *window_managers = NULL;
/* List on startup */
static GList *window_managers_save = NULL;
/* Current window manager */
static WindowManager *current_wm = NULL;
/* Window manager on startup */
static WindowManager *current_wm_save = NULL;
static gboolean xml_read_bool (xmlNodePtr node);
static xmlNodePtr xml_write_bool (gchar *name,
gboolean value);
gboolean
is_blank (gchar *str)
{
while (*str) {
if (!isspace(*str))
return FALSE;
str++;
}
return TRUE;
}
static gint
wm_compare (gconstpointer a, gconstpointer b)
{
const WindowManager *wm_a = (const WindowManager *)a;
const WindowManager *wm_b = (const WindowManager *)b;
return g_strcasecmp (gnome_desktop_item_get_string (wm_a->dentry, GNOME_DESKTOP_ITEM_NAME), gnome_desktop_item_get_string (wm_b->dentry, GNOME_DESKTOP_ITEM_NAME));
}
static void
wm_free (WindowManager *wm)
{
gnome_desktop_item_unref (wm->dentry);
g_free (wm->config_exec);
g_free (wm->config_tryexec);;
g_free (wm);
}
void
wm_check_present (WindowManager *wm)
{
gchar *path;
if (gnome_desktop_item_get_string (wm->dentry, GNOME_DESKTOP_ITEM_EXEC)) {
if (gnome_desktop_item_get_string (wm->dentry, GNOME_DESKTOP_ITEM_TRY_EXEC)) {
path = gnome_is_program_in_path (gnome_desktop_item_get_string (wm->dentry, GNOME_DESKTOP_ITEM_TRY_EXEC));
wm->is_present = (path != NULL);
if (path)
g_free (path);
} else
wm->is_present = TRUE;
} else
wm->is_present = FALSE;
if (wm->config_exec) {
if (wm->config_tryexec) {
path = gnome_is_program_in_path (wm->config_tryexec);
wm->is_config_present = (path != NULL);
if (path)
g_free (path);
} else {
path = gnome_is_program_in_path (wm->config_exec);
wm->is_config_present = (path != NULL);
if (path)
g_free (path);
}
} else
wm->is_config_present = FALSE;
}
static WindowManager *
wm_copy (WindowManager *wm)
{
WindowManager *result = g_new (WindowManager, 1);
result->dentry = gnome_desktop_item_copy (wm->dentry);
result->config_exec = g_strdup (wm->config_exec);
result->config_tryexec = g_strdup (wm->config_tryexec);
result->session_managed = wm->session_managed;
result->is_user = wm->is_user;
result->is_present = wm->is_present;
result->is_config_present = wm->is_config_present;
return result;
}
static WindowManager *
wm_list_find (GList *list, const char *name)
{
GList *tmp_list = list;
while (tmp_list) {
WindowManager *wm = tmp_list->data;
if (strcmp (gnome_desktop_item_get_string (wm->dentry, GNOME_DESKTOP_ITEM_EXEC), name) == 0)
return wm;
tmp_list = tmp_list->next;
}
return NULL;
}
static WindowManager *
wm_list_find_exec (GList *list, const char *name)
{
GList *tmp_list = list;
while (tmp_list) {
WindowManager *wm = tmp_list->data;
if (!gnome_desktop_item_get_string (wm->dentry, GNOME_DESKTOP_ITEM_EXEC))
continue;
if (strcmp (gnome_desktop_item_get_string (wm->dentry, GNOME_DESKTOP_ITEM_EXEC), name) == 0)
return wm;
tmp_list = tmp_list->next;
}
return NULL;
}
static GList *
wm_list_find_files (gchar *directory)
{
DIR *dir;
struct dirent *child;
GList *result = NULL;
gchar *suffix;
dir = opendir (directory);
if (dir == NULL)
return NULL;
while ((child = readdir (dir)) != NULL) {
/* Ignore files without .desktop suffix, and ignore
* .desktop files with no prefix
*/
suffix = child->d_name + strlen (child->d_name) - 8;
/* strlen(".desktop") == 8 */
if (suffix <= child->d_name ||
strcmp (suffix, ".desktop") != 0)
continue;
result = g_list_prepend (result,
g_concat_dir_and_file (directory,
child->d_name));
}
closedir (dir);
return result;
}
static void
wm_list_read_dir (gchar *directory, gboolean is_user)
{
WindowManager *wm;
GList *tmp_list;
GList *files;
gchar *prefix;
files = wm_list_find_files (directory);
tmp_list = files;
while (tmp_list) {
wm = g_new (WindowManager, 1);
wm->dentry = gnome_desktop_item_new_from_file (tmp_list->data, GNOME_DESKTOP_ITEM_TYPE_APPLICATION, NULL);
gnome_desktop_item_set_entry_type (wm->dentry, GNOME_DESKTOP_ITEM_TYPE_APPLICATION);
if (!wm->dentry) {
g_free (wm);
tmp_list = tmp_list->next;
continue;
}
prefix = g_strconcat ("=", gnome_desktop_item_get_location (wm->dentry), "=/Window Manager/", NULL);
gnome_config_push_prefix (prefix);
g_free (prefix);
wm->config_exec = gnome_config_get_string ("ConfigExec");
wm->config_tryexec = gnome_config_get_string ("ConfigTryExec");
wm->session_managed = gnome_config_get_bool ("SessionManaged=0");
wm->is_user = is_user;
if (wm->config_exec && is_blank (wm->config_exec)) {
g_free (wm->config_exec);
wm->config_exec = NULL;
}
if (wm->config_tryexec && is_blank (wm->config_tryexec)) {
g_free (wm->config_tryexec);
wm->config_tryexec = NULL;
}
gnome_config_pop_prefix ();
wm_check_present (wm);
if (gnome_desktop_item_get_string (wm->dentry, GNOME_DESKTOP_ITEM_NAME) && gnome_desktop_item_get_string (wm->dentry, GNOME_DESKTOP_ITEM_EXEC) &&
(wm->is_user || wm->is_present)) {
window_managers =
g_list_insert_sorted (window_managers,
wm,
wm_compare);
window_managers_save =
g_list_insert_sorted (window_managers_save,
wm_copy (wm),
wm_compare);
} else {
wm_free (wm);
}
tmp_list = tmp_list->next;
}
g_list_free (files);
}
void
wm_list_init (void)
{
gchar *tempdir;
gchar *name;
GConfClient *client;
tempdir = gnome_unconditional_datadir_file ("gnome/wm-properties/");
wm_list_read_dir (tempdir, FALSE);
g_free (tempdir);
tempdir = gnome_util_home_file("wm-properties/");
wm_list_read_dir (tempdir, TRUE);
g_free (tempdir);
client = gconf_client_get_default ();
name = gconf_client_get_string (client, CONFIG_PREFIX "/current", NULL);
if (name) {
current_wm = wm_list_find (window_managers, name);
g_free (name);
}
if (!current_wm) {
name = gconf_client_get_string (client, CONFIG_PREFIX "/default", NULL);
if (name) {
current_wm = wm_list_find_exec (window_managers, name);
g_free (name);
}
}
if (!current_wm) {
gchar *wmfile, *prefix;
wmfile = gnome_unconditional_datadir_file ("default.wm");
prefix = g_strconcat ("=", wmfile, "=/Default/WM", NULL);
name = gnome_config_get_string (prefix);
g_free (wmfile);
g_free (prefix);
if (name) {
current_wm = wm_list_find_exec (window_managers, name);
g_free (name);
}
}
if (!current_wm && window_managers)
current_wm = window_managers->data;
if(current_wm)
current_wm_save = wm_list_find (window_managers_save, gnome_desktop_item_get_string (current_wm->dentry, GNOME_DESKTOP_ITEM_NAME));
g_object_unref (G_OBJECT (client));
}
void
wm_list_save (void)
{
GList *old_files;
GList *tmp_list;
gchar *tempdir;
gchar *prefix;
WindowManager *wm;
/* Clean out the current contents of .gnome/wm-desktops
*/
tempdir = gnome_util_home_file("wm-properties/");
old_files = wm_list_find_files (tempdir);
g_free (tempdir);
tmp_list = old_files;
while (tmp_list) {
prefix = g_strconcat ("=", tmp_list->data, "=", NULL);
gnome_config_clean_file (prefix);
gnome_config_sync_file (prefix);
g_free (prefix);
tmp_list = tmp_list->next;
}
g_list_free (old_files);
/* Save the user's desktops
*/
tmp_list = window_managers;
while (tmp_list) {
wm = tmp_list->data;
if (wm->is_user) {
gnome_desktop_item_save (wm->dentry, NULL, TRUE, NULL);
prefix = g_strconcat ("=", gnome_desktop_item_get_location (wm->dentry), "=/Window Manager/", NULL);
gnome_config_push_prefix (prefix);
g_free (prefix);
if (wm->config_exec)
gnome_config_set_string ("ConfigExec", wm->config_exec);
if (wm->config_tryexec)
gnome_config_set_string ("ConfigTryExec", wm->config_tryexec);
gnome_config_set_bool ("SessionManaged=0", wm->session_managed);
gnome_config_pop_prefix ();
}
tmp_list = tmp_list->next;
}
/* Save the current window manager
*/
if(current_wm)
{
GConfClient *client = gconf_client_get_default ();
gconf_client_set_string (client, CONFIG_PREFIX "/current",
gnome_desktop_item_get_string (current_wm->dentry, GNOME_DESKTOP_ITEM_EXEC),
NULL);
g_object_unref (G_OBJECT (client));
}
gnome_config_sync ();
}
void
wm_list_revert (void)
{
GList *tmp_list;
gchar *old_name = NULL;
if(current_wm)
old_name = g_strdup (gnome_desktop_item_get_string (current_wm->dentry, GNOME_DESKTOP_ITEM_NAME));
g_list_foreach (window_managers, (GFunc)wm_free, NULL);
g_list_free (window_managers);
window_managers = NULL;
tmp_list = window_managers_save;
while (tmp_list) {
window_managers = g_list_prepend (window_managers,
wm_copy (tmp_list->data));
tmp_list = tmp_list->next;
}
window_managers = g_list_reverse (window_managers);
current_wm = wm_list_find (window_managers, old_name);
g_free (old_name);
}
void
wm_list_add (WindowManager *wm)
{
g_return_if_fail (wm != NULL);
window_managers = g_list_insert_sorted (window_managers, wm,
wm_compare);
}
void
wm_list_delete (WindowManager *wm)
{
GList *node;
g_return_if_fail (wm != NULL);
g_return_if_fail (wm != current_wm);
node = g_list_find (window_managers, wm);
g_return_if_fail (node != NULL);
window_managers = g_list_remove_link (window_managers, node);
g_list_free_1 (node);
wm_free (wm);
}
void
wm_list_set_current (WindowManager *wm)
{
current_wm = wm;
}
WindowManager *
wm_list_get_current (void)
{
return current_wm;
}
WindowManager *
wm_list_get_revert (void)
{
if(current_wm_save)
return wm_list_find (window_managers, gnome_desktop_item_get_string (current_wm_save->dentry, GNOME_DESKTOP_ITEM_NAME));
else
return NULL;
}
static WindowManager *
wm_read_from_xml (xmlNodePtr wm_node)
{
xmlNodePtr node;
WindowManager *wm;
gboolean is_current = FALSE;
if (strcmp (wm_node->name, "window-manager")) return NULL;
wm = g_new0 (WindowManager, 1);
wm->dentry = gnome_desktop_item_new_from_file
(xmlGetProp (wm_node, "desktop-entry"),
GNOME_DESKTOP_ITEM_TYPE_APPLICATION, NULL);
gnome_desktop_item_set_entry_type (wm->dentry, GNOME_DESKTOP_ITEM_TYPE_APPLICATION);
for (node = wm_node->children; node; node = node->next) {
if (!strcmp (node->name, "config-exec"))
wm->config_exec = xmlNodeGetContent (node);
else if (!strcmp (node->name, "config-tryexec"))
wm->config_tryexec = xmlNodeGetContent (node);
else if (!strcmp (node->name, "session-managed"))
wm->session_managed = xml_read_bool (node);
else if (!strcmp (node->name, "is-user"))
wm->is_user = xml_read_bool (node);
else if (!strcmp (node->name, "is-current"))
is_current = xml_read_bool (node); /* FIXME: sanity check */
}
wm_check_present (wm);
if (wm->dentry == NULL ||
(wm->config_exec != NULL && is_blank (wm->config_exec)) ||
gnome_desktop_item_get_string (wm->dentry, GNOME_DESKTOP_ITEM_NAME) == NULL || gnome_desktop_item_get_string (wm->dentry, GNOME_DESKTOP_ITEM_EXEC) == NULL ||
!(wm->is_user || wm->is_present))
{
g_free (wm);
return NULL;
}
if (is_current) current_wm = wm;
return wm;
}
void
wm_list_read_from_xml (xmlDocPtr doc)
{
xmlNodePtr root_node, node;
WindowManager *wm;
root_node = xmlDocGetRootElement (doc);
if (strcmp (root_node->name, "wm-prefs")) return;
for (node = root_node; node; node = node->next) {
if (!strcmp (node->name, "window-manager")) {
wm = wm_read_from_xml (node);
if (wm) window_managers =
g_list_insert_sorted
(window_managers, wm, wm_compare);
}
}
}
static xmlNodePtr
wm_write_to_xml (WindowManager *wm)
{
xmlNodePtr node;
node = xmlNewNode (NULL, "window-manager");
xmlNewProp (node, "desktop-entry", gnome_desktop_item_get_location (wm->dentry));
if (wm->config_exec != NULL)
xmlNewChild (node, NULL, "config-exec", wm->config_exec);
xmlAddChild (node, xml_write_bool ("session-managed",
wm->session_managed));
xmlAddChild (node, xml_write_bool ("is-user", wm->is_user));
xmlAddChild (node, xml_write_bool ("is-current", wm == current_wm));
return node;
}
xmlDocPtr
wm_list_write_to_xml (void)
{
xmlDocPtr doc;
xmlNodePtr root_node, node;
GList *wm_node;
doc = xmlNewDoc ("1.0");
root_node = xmlNewDocNode (doc, NULL, "wm-prefs", NULL);
for (wm_node = window_managers; wm_node; wm_node = wm_node->next) {
node = wm_write_to_xml ((WindowManager *) wm_node->data);
if (node) xmlAddChild (root_node, node);
}
xmlDocSetRootElement (doc, root_node);
return doc;
}
/* Read a boolean value from a node */
static gboolean
xml_read_bool (xmlNodePtr node)
{
char *text;
text = xmlNodeGetContent (node);
if (!g_strcasecmp (text, "true"))
return TRUE;
else
return FALSE;
}
/* Write out a boolean value in a node */
static xmlNodePtr
xml_write_bool (gchar *name, gboolean value)
{
xmlNodePtr node;
g_return_val_if_fail (name != NULL, NULL);
node = xmlNewNode (NULL, name);
if (value)
xmlNodeSetContent (node, "true");
else
xmlNodeSetContent (node, "false");
return node;
}

63
capplets/windows/wm-properties.h
View file

@ -1,63 +0,0 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- */
/* Copyright (C) 1998 Redhat Software Inc.
* Code available under the Gnu GPL.
* Authors: Owen Taylor <otaylor@redhat.com>,
* Bradford Hovinen <hovinen@helixcode.com>
*/
#include <gdk/gdk.h>
#include <libgnome/libgnome.h>
#include <libgnome/gnome-desktop-item.h>
#include <libxml/tree.h>
typedef struct _WindowManager WindowManager;
struct _WindowManager {
GnomeDesktopItem *dentry;
gchar *config_exec;
gchar *config_tryexec;
gboolean session_managed : 1;
gboolean is_user : 1;
gboolean is_present : 1;
gboolean is_config_present : 1;
};
/* Utility functions */
gboolean is_blank (gchar *str);
/* Fill in the is_present and is_config_present fields */
void wm_check_present (WindowManager *wm);
/* Management of window manager list */
void wm_list_init (void);
void wm_list_save (void);
void wm_list_revert (void);
void wm_list_add (WindowManager *window_manager);
void wm_list_delete (WindowManager *window_manager);
void wm_list_set_current (WindowManager *window_manager);
WindowManager *wm_list_get_current (void);
WindowManager *wm_list_get_revert (void);
void wm_list_read_from_xml (xmlDocPtr doc);
xmlDocPtr wm_list_write_to_xml (void);
extern GList *window_managers;
/* Management of current window manager */
typedef enum {
WM_SUCCESS,
WM_ALREADY_RUNNING,
WM_CANT_START
} WMResult;
typedef void (*WMResultFunc) (WMResult result, gpointer data);
void wm_restart (WindowManager *new,
GdkWindow *client,
WMResultFunc callback,
gpointer data);
gboolean wm_is_running (void);
WindowManager *wm_guess_current (void);