UXManagerImpl::UXManagerImpl() :
_floatwindowIssues(false),
_widescreen(false)
{
ege::TagSet tags;
tags.setLang("en");
tags.addTag(ege::Tag("General"));
tags.addTag(ege::Tag("Icons"));
#if defined(GDK_WINDOWING_X11)
char const* wmName = gdk_x11_screen_get_window_manager_name( gdk_screen_get_default() );
//g_message("Window manager is [%s]", wmName);
//if (g_ascii_strcasecmp( wmName, UNKOWN_WINDOW_MANAGER_NAME ) == 0) {
if (g_ascii_strcasecmp( wmName, KDE_WINDOW_MANAGER_NAME ) == 0) {
_floatwindowIssues = true;
}
#elif defined(GDK_WINDOWING_WIN32)
_floatwindowIssues = true;
#endif // GDK_WINDOWING_WIN32
Glib::RefPtr<Gdk::Screen> defaultScreen = Gdk::Screen::get_default();
if (defaultScreen) {
int width = defaultScreen->get_width();
int height = defaultScreen->get_height();
gdouble aspect = static_cast<gdouble>(width) / static_cast<gdouble>(height);
if (aspect > 1.65) {
_widescreen = true;
}
}
}
static void
wm_changed_callback (GdkScreen *screen,
void *data)
{
const char *current_wm;
current_wm = gdk_x11_screen_get_window_manager_name (screen);
gtk_widget_set_sensitive (dialog_win, g_strcmp0 (current_wm, WM_COMMON_MARCO) == 0);
}
static gboolean
wm_is_fallback (void)
{
#ifdef GDK_WINDOWING_X11
const gchar *name;
name = gdk_x11_screen_get_window_manager_name (gdk_screen_get_default ());
return g_strcmp0 (name, "GNOME Shell") != 0;
#else
return TRUE;
#endif
}
/* This function will make sure that tilda window becomes active (gains
* the focus) when it is called.
*
* This has to be the worst possible way of making this work, but it was the
* only way to get metacity to play nicely. All the other WM's are so nice,
* why oh why does metacity hate us so?
*/
void tilda_window_set_active (tilda_window *tw)
{
DEBUG_FUNCTION ("tilda_window_set_active");
DEBUG_ASSERT (tw != NULL);
Display *x11_display = GDK_WINDOW_XDISPLAY (gtk_widget_get_window (tw->window) );
Window x11_window = GDK_WINDOW_XID (gtk_widget_get_window (tw->window) );
Window x11_root_window = GDK_WINDOW_XID ( gtk_widget_get_root_window (tw->window) );
GdkScreen *screen = gtk_widget_get_screen (tw->window);
XEvent event;
long mask = SubstructureRedirectMask | SubstructureNotifyMask;
gtk_window_move (GTK_WINDOW(tw->window), config_getint ("x_pos"), config_getint ("y_pos"));
if (gdk_x11_screen_supports_net_wm_hint (screen,
gdk_atom_intern_static_string ("_NET_ACTIVE_WINDOW")))
{
guint32 timestamp = gtk_get_current_event_time ();
if (timestamp == 0) {
timestamp = gdk_x11_get_server_time(gdk_screen_get_root_window (screen));
}
event.xclient.type = ClientMessage;
event.xclient.serial = 0;
event.xclient.send_event = True;
event.xclient.display = x11_display;
event.xclient.window = x11_window;
event.xclient.message_type = gdk_x11_get_xatom_by_name ("_NET_ACTIVE_WINDOW");
event.xclient.format = 32;
event.xclient.data.l[0] = 2; /* pager */
event.xclient.data.l[1] = timestamp; /* timestamp */
event.xclient.data.l[2] = 0;
event.xclient.data.l[3] = 0;
event.xclient.data.l[4] = 0;
XSendEvent (x11_display, x11_root_window, False, mask, &event);
}
else
{
/* The WM doesn't support the EWMH standards. We'll print a warning and
* try this, though it probably won't work... */
g_printerr (_("WARNING: Window manager (%s) does not support EWMH hints\n"),
gdk_x11_screen_get_window_manager_name (screen));
XRaiseWindow (x11_display, x11_window);
}
}
static void
awn_tooltip_set_type_hint (GtkWidget *widget)
{
if (gtk_widget_get_visible (widget)) return;
GdkScreen *screen = gtk_widget_get_screen (widget);
if (gdk_screen_is_composited (screen) &&
strcmp (gdk_x11_screen_get_window_manager_name (screen),
"Metacity") == 0)
{
// metacity shows a nasty shadow around our nice tooltip if we say
// we're a tooltip window, so pretend we aren't tooltip to fool it
// FIXME: always set the hint once noone cares about metacity
gtk_window_set_type_hint (GTK_WINDOW (widget),
GDK_WINDOW_TYPE_HINT_DND);
}
else
{
gtk_window_set_type_hint (GTK_WINDOW (widget),
GDK_WINDOW_TYPE_HINT_TOOLTIP);
}
}
gchar* GetCurrentWMName(GtkWidget *widget){
GdkScreen *screen = gtk_widget_get_screen(widget);
//GdkScreen *screen = gdk_screen_get_default();
return((gchar *)gdk_x11_screen_get_window_manager_name(screen));
}
static void egg_tray_icon_update_manager_window (EggTrayIcon *icon) {
static GdkPixbuf *background_pixbuf;
const gchar *window_manager=NULL;
if (icon->manager_window != None) {
GdkWindow *gdkwin;
gdkwin = gdk_window_lookup (icon->manager_window);
gdk_window_remove_filter (gdkwin, egg_tray_icon_manager_filter, icon);
}
XGrabServer (GDK_DISPLAY());
icon->manager_window = XGetSelectionOwner (GDK_DISPLAY(),
icon->selection_atom);
if (icon->manager_window != None)
XSelectInput (GDK_DISPLAY(), icon->manager_window, StructureNotifyMask);
XUngrabServer (GDK_DISPLAY());
XFlush (GDK_DISPLAY());
if (icon->manager_window == None)
return;
window_manager=gdk_x11_screen_get_window_manager_name (gdk_screen_get_default());
if ( !g_ascii_strcasecmp(window_manager, kde_window_manger) && kde_dock (icon)) {
if ((background_pixbuf=kde_dock_background(icon)) !=NULL) {
icon->box= gtk_fixed_new ();
gtk_fixed_set_has_window(GTK_FIXED (icon->box),TRUE);
gtk_container_add(GTK_CONTAINER(icon), icon->box);
icon->image=gtk_image_new ();
gtk_image_set_from_pixbuf(GTK_IMAGE(icon->image), icon->default_pix);
icon->background =gtk_image_new ();
gtk_image_set_from_pixbuf(GTK_IMAGE(icon->background), background_pixbuf);
gtk_fixed_put (GTK_FIXED (icon->box), GTK_WIDGET(icon->background), 0, 0);
gtk_fixed_put (GTK_FIXED (icon->box), GTK_WIDGET(icon->image), 0, 0);
gtk_widget_show (icon->background);
gtk_widget_show (icon->image);
gtk_widget_show(icon->box);
icon->ready=TRUE;
}
} else {
icon->box=gtk_event_box_new ();
gtk_container_add(GTK_CONTAINER(icon), icon->box);
icon->image=gtk_image_new ();
gtk_image_set_from_pixbuf(GTK_IMAGE(icon->image),icon->default_pix);
gtk_container_add(GTK_CONTAINER(icon->box), icon->image);
gtk_widget_show (icon->image);
gtk_widget_show(icon->box);
GdkWindow *gdkwin;
gdkwin = gdk_window_lookup (icon->manager_window);
gdk_window_add_filter (gdkwin, egg_tray_icon_manager_filter, icon);
/* Send a request that we'd like to dock */
egg_tray_icon_send_dock_request (icon);
}
}
int
main (int argc, char **argv)
{
GdkScreen *screen;
GtkWidget *nb;
GtkWidget *general_vbox;
GtkWidget *behaviour_vbox;
GtkWidget *placement_vbox;
GtkWidget *widget;
GtkWidget *vbox;
GtkWidget *vbox1;
GtkWidget *hbox;
GtkWidget *hbox1;
GtkWidget *hbox2;
GtkWidget *hbox3;
GtkWidget *content_area;
gchar *str;
const char *current_wm;
int i;
bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR);
bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
gtk_init (&argc, &argv);
screen = gdk_display_get_default_screen (gdk_display_get_default ());
current_wm = gdk_x11_screen_get_window_manager_name (screen);
if (g_strcmp0 (current_wm, WM_COMMON_METACITY) == 0) {
mate_metacity_config_tool ();
return 0;
}
if (g_strcmp0 (current_wm, WM_COMMON_MARCO) != 0) {
wm_unsupported ();
return 1;
}
marco_settings = g_settings_new (MARCO_SCHEMA);
/* Window */
dialog_win = gtk_dialog_new_with_buttons (_("Window Preferences"),
NULL,
GTK_DIALOG_MODAL,
#if GTK_CHECK_VERSION (3, 10, 0)
_("_Help"),
#else
GTK_STOCK_HELP,
#endif
GTK_RESPONSE_HELP,
#if GTK_CHECK_VERSION (3, 10, 0)
_("_Close"),
#else
GTK_STOCK_CLOSE,
#endif
GTK_RESPONSE_CLOSE,
NULL);
//gtk_window_set_resizable (GTK_WINDOW (dialog_win), FALSE);
gtk_window_set_icon_name (GTK_WINDOW (dialog_win), "preferences-system-windows");
gtk_container_set_border_width (GTK_CONTAINER (dialog_win), 10);
nb = gtk_notebook_new ();
general_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
behaviour_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
placement_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
widget = gtk_label_new (_("General"));
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (hbox), general_vbox, FALSE, FALSE, 6);
gtk_notebook_append_page (GTK_NOTEBOOK (nb), hbox, widget);
widget = gtk_label_new (_("Behaviour"));
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (hbox), behaviour_vbox, FALSE, FALSE, 6);
gtk_notebook_append_page (GTK_NOTEBOOK (nb), hbox, widget);
widget = gtk_label_new (_("Placement"));
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (hbox), placement_vbox, FALSE, FALSE, 6);
gtk_notebook_append_page (GTK_NOTEBOOK (nb), hbox, widget);
/* Compositing manager */
widget = title_label_new (N_("Compositing Manager"));
gtk_box_pack_start (GTK_BOX (general_vbox), widget, FALSE, FALSE, 6);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
compositing_checkbutton = gtk_check_button_new_with_mnemonic (_("Enable software _compositing window manager"));
compositing_fast_alt_tab_checkbutton = gtk_check_button_new_with_mnemonic (_("Disable _thumbnails in Alt-Tab"));
gtk_box_pack_start (GTK_BOX (vbox), compositing_checkbutton, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (hbox1), compositing_fast_alt_tab_checkbutton, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox), hbox1, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (general_vbox), hbox, FALSE, FALSE, 6);
/* Titlebar buttons */
widget = title_label_new (N_("Titlebar Buttons"));
gtk_box_pack_start (GTK_BOX (general_vbox), widget, FALSE, FALSE, 6);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
widget = gtk_label_new (_("Position:"));
gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 6);
titlebar_layout_optionmenu = gtk_combo_box_text_new ();
gtk_box_pack_start (GTK_BOX (hbox), titlebar_layout_optionmenu, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (general_vbox), hbox, FALSE, FALSE, 6);
/* New Windows */
widget = title_label_new (N_("New Windows"));
gtk_box_pack_start (GTK_BOX (placement_vbox), widget, FALSE, FALSE, 6);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
center_new_windows_checkbutton = gtk_check_button_new_with_mnemonic (_("Center _new windows"));
gtk_box_pack_start (GTK_BOX (hbox), center_new_windows_checkbutton, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (placement_vbox), hbox, FALSE, FALSE, 6);
/* Window Snapping */
widget = title_label_new (N_("Window Snapping"));
gtk_box_pack_start (GTK_BOX (placement_vbox), widget, FALSE, FALSE, 6);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
side_by_side_tiling_checkbutton = gtk_check_button_new_with_mnemonic (_("Enable side by side _tiling"));
gtk_box_pack_start (GTK_BOX (hbox), side_by_side_tiling_checkbutton, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (placement_vbox), hbox, FALSE, FALSE, 6);
/* Window Selection */
widget = title_label_new (N_("Window Selection"));
gtk_box_pack_start (GTK_BOX (behaviour_vbox), widget, FALSE, FALSE, 6);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
vbox1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
hbox3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
focus_mode_checkbutton = gtk_check_button_new_with_mnemonic (_("_Select windows when the mouse moves over them"));
gtk_box_pack_start (GTK_BOX (vbox), focus_mode_checkbutton, FALSE, FALSE, 6);
focus_mode_mouse_checkbutton = gtk_check_button_new_with_mnemonic (_("U_nselect windows when the mouse leaves them"));
gtk_box_pack_start (GTK_BOX (hbox1), focus_mode_mouse_checkbutton, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox1), hbox1, FALSE, FALSE, 6);
autoraise_checkbutton = gtk_check_button_new_with_mnemonic (_("_Raise selected windows after an interval"));
gtk_box_pack_start (GTK_BOX (hbox2), autoraise_checkbutton, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox1), hbox2, FALSE, FALSE, 6);
autoraise_delay_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
autoraise_delay_slider = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 10, 0.2);
widget = gtk_label_new_with_mnemonic (_("_Interval before raising:"));
gtk_box_pack_start (GTK_BOX (autoraise_delay_hbox), widget, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (autoraise_delay_hbox), autoraise_delay_slider, TRUE, TRUE, 6);
gtk_label_set_mnemonic_widget (GTK_LABEL (widget), autoraise_delay_slider);
widget = gtk_label_new (_("seconds"));
gtk_range_set_increments (GTK_RANGE (autoraise_delay_slider), 0.2, 1.0);
gtk_box_pack_start (GTK_BOX (autoraise_delay_hbox), widget, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox1), autoraise_delay_hbox, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (hbox3), vbox1, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox), hbox3, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (behaviour_vbox), hbox, FALSE, FALSE, 6);
/* Titlebar Action */
widget = title_label_new (N_("Titlebar Action"));
gtk_box_pack_start (GTK_BOX (behaviour_vbox), widget, FALSE, FALSE, 6);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
widget = gtk_label_new_with_mnemonic (_("_Double-click titlebar to perform this action:"));
gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 6);
double_click_titlebar_optionmenu = gtk_combo_box_text_new ();
gtk_label_set_mnemonic_widget (GTK_LABEL (widget), double_click_titlebar_optionmenu);
gtk_box_pack_start (GTK_BOX (hbox), double_click_titlebar_optionmenu, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (behaviour_vbox), hbox, FALSE, FALSE, 6);
/* Movement Key */
widget = title_label_new (N_("Movement Key"));
gtk_box_pack_start (GTK_BOX (behaviour_vbox), widget, FALSE, FALSE, 6);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
widget = gtk_label_new_with_mnemonic (_("To move a window, press-and-hold this key then grab the window:"));
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (widget), 0.0);
gtk_label_set_yalign (GTK_LABEL (widget), 0.0);
#else
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.0);
#endif
gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 6);
alt_click_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_label_set_mnemonic_widget (GTK_LABEL (widget), alt_click_vbox);
gtk_box_pack_start (GTK_BOX (vbox), alt_click_vbox, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (behaviour_vbox), hbox, FALSE, FALSE, 6);
reload_mouse_modifiers ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (titlebar_layout_optionmenu), _("Right"));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (titlebar_layout_optionmenu), _("Left"));
str = g_settings_get_string (marco_settings, MARCO_BUTTON_LAYOUT_KEY);
gtk_combo_box_set_active (GTK_COMBO_BOX (titlebar_layout_optionmenu),
g_strcmp0 (str, MARCO_BUTTON_LAYOUT_RIGHT) == 0 ? 0 : 1);
g_free (str);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (double_click_titlebar_optionmenu), _("Roll up"));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (double_click_titlebar_optionmenu), _("Maximize"));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (double_click_titlebar_optionmenu), _("Maximize Horizontally"));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (double_click_titlebar_optionmenu), _("Maximize Vertically"));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (double_click_titlebar_optionmenu), _("Minimize"));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (double_click_titlebar_optionmenu), _("None"));
gtk_combo_box_set_active (GTK_COMBO_BOX (double_click_titlebar_optionmenu),
g_settings_get_enum (marco_settings, MARCO_DOUBLE_CLICK_TITLEBAR_KEY));
set_alt_click_value ();
gtk_range_set_value (GTK_RANGE (autoraise_delay_slider),
g_settings_get_int (marco_settings, MARCO_AUTORAISE_DELAY_KEY) / 1000.0);
gtk_combo_box_set_active (GTK_COMBO_BOX (double_click_titlebar_optionmenu),
g_settings_get_enum (marco_settings, MARCO_DOUBLE_CLICK_TITLEBAR_KEY));
g_signal_connect (G_OBJECT (dialog_win), "response",
G_CALLBACK (response_cb), NULL);
g_signal_connect (G_OBJECT (dialog_win), "destroy",
G_CALLBACK (gtk_main_quit), NULL);
g_signal_connect (marco_settings, "changed",
G_CALLBACK (marco_settings_changed_callback), NULL);
g_settings_bind (marco_settings,
MARCO_COMPOSITING_MANAGER_KEY,
compositing_checkbutton,
"active",
G_SETTINGS_BIND_DEFAULT);
g_settings_bind (marco_settings,
MARCO_COMPOSITING_FAST_ALT_TAB_KEY,
compositing_fast_alt_tab_checkbutton,
"active",
G_SETTINGS_BIND_DEFAULT);
g_settings_bind (marco_settings,
MARCO_SIDE_BY_SIDE_TILING_KEY,
side_by_side_tiling_checkbutton,
"active",
G_SETTINGS_BIND_DEFAULT);
g_settings_bind (marco_settings,
MARCO_CENTER_NEW_WINDOWS_KEY,
center_new_windows_checkbutton,
"active",
G_SETTINGS_BIND_DEFAULT);
g_signal_connect (marco_settings, "changed::" MARCO_FOCUS_KEY,
G_CALLBACK (mouse_focus_changed_callback), NULL);
/* Initialize the checkbox state appropriately */
mouse_focus_changed_callback(marco_settings, MARCO_FOCUS_KEY, NULL);
g_signal_connect (focus_mode_checkbutton, "toggled",
G_CALLBACK (mouse_focus_toggled_callback), NULL);
g_signal_connect (focus_mode_mouse_checkbutton, "toggled",
G_CALLBACK (mouse_focus_toggled_callback), NULL);
g_settings_bind (marco_settings,
MARCO_AUTORAISE_KEY,
autoraise_checkbutton,
"active",
G_SETTINGS_BIND_DEFAULT);
g_signal_connect (autoraise_delay_slider, "value_changed",
G_CALLBACK (autoraise_delay_value_changed_callback), NULL);
g_signal_connect (double_click_titlebar_optionmenu, "changed",
G_CALLBACK (double_click_titlebar_changed_callback), NULL);
g_signal_connect (titlebar_layout_optionmenu, "changed",
G_CALLBACK (titlebar_layout_changed_callback), NULL);
g_signal_connect (G_OBJECT (screen), "window_manager_changed",
G_CALLBACK (wm_changed_callback), NULL);
i = 0;
while (i < n_mouse_modifiers) {
g_signal_connect (G_OBJECT (mouse_modifiers[i].radio), "toggled",
G_CALLBACK (alt_click_radio_toggled_callback),
&mouse_modifiers[i]);
++i;
}
/* update sensitivity */
update_sensitivity ();
capplet_set_icon (dialog_win, "preferences-system-windows");
content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog_win));
gtk_box_pack_start (GTK_BOX (content_area), nb, TRUE, TRUE, 0);
gtk_widget_show_all (dialog_win);
gtk_main ();
g_object_unref (marco_settings);
return 0;
}
void
detect_desktop_environment(OperatingSystem * os)
{
const gchar *tmp = g_getenv("GNOME_DESKTOP_SESSION_ID");
FILE *version;
char vers[16];
if (tmp) {
/* FIXME: this might not be true, as the gnome-panel in path
may not be the one that's running.
see where the user's running panel is and run *that* to
obtain the version. */
version = popen("gnome-about --gnome-version", "r");
if (version) {
(void)fscanf(version, _("Version: %s"), vers);
if (pclose(version))
goto unknown;
} else {
goto unknown;
}
os->desktop = g_strdup_printf("GNOME %s", vers);
} else if (g_getenv("KDE_FULL_SESSION")) {
if (g_getenv("KDE_SESSION_VERSION") && strstr(g_getenv("KDE_SESSION_VERSION"),(gchar *)"4")) {
version = popen("kwin --version", "r");
} else {
version = popen("kcontrol --version", "r");
}
if (version) {
char buf[32];
(void)fgets(buf, 32, version);
(void)fscanf(version, "KDE: %s", vers);
if (pclose(version))
goto unknown;
} else {
goto unknown;
}
os->desktop = g_strdup_printf("KDE %s", vers);
} else {
unknown:
os->desktop = NULL;
if (!g_getenv("DISPLAY")) {
os->desktop = g_strdup(_("Terminal"));
} else {
GdkScreen *screen = gdk_screen_get_default();
if (screen && GDK_IS_SCREEN(screen)) {
const gchar *windowman;
windowman = gdk_x11_screen_get_window_manager_name(screen);
if (g_str_equal(windowman, "Xfwm4")) {
/* FIXME: check if xprop -root | grep XFCE_DESKTOP_WINDOW is defined */
os->desktop = g_strdup("XFCE 4");
} else if ((tmp = g_getenv("XDG_CURRENT_DESKTOP"))) {
os->desktop = g_strdup(tmp);
if ((tmp = g_getenv("DESKTOP_SESSION")) && !g_str_equal(os->desktop, tmp)) {
g_free(os->desktop);
os->desktop = g_strdup(tmp);
}
}
if (!os->desktop) {
os->desktop = g_strdup_printf(_("Unknown (Window Manager: %s)"),
windowman);
}
} else {
os->desktop = g_strdup(_("Unknown"));
}
}
}
}
int
main (int argc, gchar **argv)
{
GtkWidget *dialog;
GtkWidget *plug;
GtkWidget *plug_child;
GtkBuilder *builder;
GError *cli_error = NULL;
const gchar *wm_name;
#ifdef ENABLE_NLS
xfce_textdomain (GETTEXT_PACKAGE, LOCALEDIR, "UTF-8");
#endif
if (!gtk_init_with_args (&argc, &argv, _ ("."), entries, PACKAGE, &cli_error))
{
if (cli_error != NULL)
{
g_print (_ ("%s: %s\nTry %s --help to see a full list of available command line options.\n"), PACKAGE, cli_error->message, PACKAGE_NAME);
g_error_free (cli_error);
return 1;
}
}
wm_name = gdk_x11_screen_get_window_manager_name (gdk_screen_get_default ());
if (G_UNLIKELY (g_ascii_strcasecmp (wm_name, "Xfwm4")))
{
g_print ("These settings cannot work with your current window manager (%s)\n", wm_name);
return 1;
}
if (opt_version)
{
g_print ("%s\n", PACKAGE_STRING);
return 0;
}
xfconf_init (NULL);
builder = gtk_builder_new ();
if (xfce_titled_dialog_get_type () == 0)
return 1;
gtk_builder_add_from_string (builder, tweaks_dialog_ui, tweaks_dialog_ui_length, NULL);
if (builder)
{
wm_tweaks_dialog_configure_widgets (builder);
if (opt_socket_id == 0)
{
dialog = GTK_WIDGET (gtk_builder_get_object (builder, "main-dialog"));
gtk_widget_show (dialog);
g_signal_connect (dialog, "response", G_CALLBACK (wm_tweaks_dialog_response), NULL);
/* To prevent the settings dialog to be saved in the session */
gdk_set_sm_client_id ("FAKE ID");
gtk_main ();
gtk_widget_destroy (dialog);
}
else
{
/* Create plug widget */
plug = gtk_plug_new (opt_socket_id);
g_signal_connect (plug, "delete-event", G_CALLBACK (gtk_main_quit), NULL);
gtk_widget_show (plug);
/* Get plug child widget */
plug_child = GTK_WIDGET (gtk_builder_get_object (builder, "plug-child"));
gtk_widget_reparent (plug_child, plug);
gtk_widget_show (plug_child);
/* To prevent the settings dialog to be saved in the session */
gdk_set_sm_client_id ("FAKE ID");
/* Stop startup notification */
gdk_notify_startup_complete ();
/* Enter main loop */
gtk_main ();
}
g_object_unref (builder);
}
xfconf_shutdown ();
return 0;
}
static gboolean
myScreenSetWMAtom (ScreenInfo *screen_info, gboolean replace_wm)
{
const char *wm_name;
gchar selection[32];
gchar *display_name;
gulong wait, timeout;
DisplayInfo *display_info;
XSetWindowAttributes attrs;
Window current_wm;
XEvent event;
Atom wm_sn_atom;
g_return_val_if_fail (screen_info, FALSE);
g_return_val_if_fail (screen_info->display_info, FALSE);
TRACE ("entering myScreenReplaceWM");
display_info = screen_info->display_info;
g_snprintf (selection, sizeof (selection), "WM_S%d", screen_info->screen);
wm_sn_atom = XInternAtom (display_info->dpy, selection, FALSE);
display_name = gdk_screen_make_display_name (screen_info->gscr);
wm_name = gdk_x11_screen_get_window_manager_name (screen_info->gscr);
XSync (display_info->dpy, FALSE);
current_wm = XGetSelectionOwner (display_info->dpy, wm_sn_atom);
if (current_wm)
{
if (!replace_wm)
{
g_message ("Another Window Manager (%s) is already running on screen %s", wm_name, display_name);
g_message ("To replace the current window manager, try \"--replace\"");
g_free (display_name);
return FALSE;
}
gdk_error_trap_push ();
attrs.event_mask = StructureNotifyMask;
XChangeWindowAttributes (display_info->dpy, current_wm, CWEventMask, &attrs);
if (gdk_error_trap_pop ())
{
current_wm = None;
}
}
if (!setXAtomManagerOwner (display_info, wm_sn_atom, screen_info->xroot, screen_info->xfwm4_win))
{
g_warning ("Cannot acquire window manager selection on screen %s", display_name);
g_free (display_name);
return FALSE;
}
/* Waiting for previous window manager to exit */
if (current_wm)
{
g_print ("Waiting for current window manager (%s) on screen %s to exit:", wm_name, display_name);
wait = 0;
timeout = WM_EXITING_TIMEOUT * G_USEC_PER_SEC;
while (wait < timeout)
{
if (XCheckWindowEvent (display_info->dpy, current_wm, StructureNotifyMask, &event) && (event.type == DestroyNotify))
{
break;
}
g_usleep(G_USEC_PER_SEC / 10);
wait += G_USEC_PER_SEC / 10;
if (wait % G_USEC_PER_SEC == 0)
{
g_print (".");
}
}
if (wait >= timeout)
{
g_print(" Failed\n");
g_warning("Previous window manager (%s) on screen %s is not exiting", wm_name, display_name);
g_free (display_name);
return FALSE;
}
g_print(" Done\n");
}
g_free (display_name);
return TRUE;
}
