Initial release

author: Stefano Karapetsas <[email protected]> 2012-07-04 18:01:12 +0200
committer: Stefano Karapetsas <[email protected]> 2012-07-04 18:01:12 +0200
commit: e48fc61bf4cf43a90b7ddf16e3cbb3b247333c89 (patch)
tree: 15722913e64320b18a09b2452d0a382ebeb953e9 /maximus/maximus-app.c
download: mate-netbook-e48fc61bf4cf43a90b7ddf16e3cbb3b247333c89.tar.bz2
mate-netbook-e48fc61bf4cf43a90b7ddf16e3cbb3b247333c89.tar.xz
1 files changed, 577 insertions, 0 deletions
diff --git a/maximus/maximus-app.c b/maximus/maximus-app.c
new file mode 100644
index 0000000..be9a2fc
--- /dev/null
+++ b/maximus/maximus-app.c
@@ -0,0 +1,577 @@
+/*
+ * Copyright (C) 2008 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as 
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by Neil Jagdish Patel <[email protected]>
+ *
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <gtk/gtk.h>
+#include <gdk/gdkx.h>
+
+#include <mateconf/mateconf.h>
+#include <mateconf/mateconf-client.h>
+
+#include "maximus-app.h"
+#include "maximus-bind.h"
+#include "xutils.h"
+
+G_DEFINE_TYPE (MaximusApp, maximus_app, G_TYPE_OBJECT);
+
+#define MAXIMUS_APP_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj),\
+ MAXIMUS_TYPE_APP, \
+ MaximusAppPrivate))
+
+/* Gconf keys */
+#define APP_PATH "/apps/maximus"
+#define APP_EXCLUDE_CLASS APP_PATH "/exclude_class"
+#define APP_UNDECORATE APP_PATH "/undecorate"
+#define APP_NO_MAXIMIZE APP_PATH "/no_maximize"
+
+/* A set of default exceptions */
+static gchar *default_exclude_classes[] = 
+{
+ "Apport-gtk",
+ "Bluetooth-properties",
+ "Bluetooth-wizard",
+ "Download", /* Firefox Download Window */
+ "Ekiga",
+ "Extension", /* Firefox Add-Ons/Extension Window */
+ "Gcalctool",
+ "Gimp",
+ "Global", /* Firefox Error Console Window */
+ "Mate-dictionary",
+ "Mate-language-selector",
+ "Mate-nettool",
+ "Mate-volume-control",
+ "Kiten",
+ "Kmplot",
+ "Nm-editor",
+ "Pidgin",
+ "Polkit-mate-authorization",
+ "Update-manager",
+ "Skype",
+ "Toplevel", /* Firefox "Clear Private Data" Window */
+ "Transmission"
+};
+
+struct _MaximusAppPrivate
+{
+ MaximusBind *bind;
+ MatewnckScreen *screen;
+
+ GSList *exclude_class_list;
+ gboolean undecorate;
+ gboolean no_maximize;
+};
+
+static GQuark was_decorated = 0;
+
+/* <TAKEN FROM GDK> */
+typedef struct {
+ unsigned long flags;
+ unsigned long functions;
+ unsigned long decorations;
+ long input_mode;
+ unsigned long status;
+} MotifWmHints, MwmHints;
+
+#define MWM_HINTS_FUNCTIONS (1L << 0)
+#define MWM_HINTS_DECORATIONS (1L << 1)
+#define _XA_MOTIF_WM_HINTS "_MOTIF_WM_HINTS"
+
+static gboolean
+matewnck_window_is_decorated (MatewnckWindow *window)
+{
+ GdkDisplay *display = gdk_display_get_default();
+ Atom hints_atom = None;
+ guchar *data = NULL;
+ MotifWmHints *hints = NULL;
+ Atom type = None;
+ gint format;
+ gulong nitems;
+ gulong bytes_after;
+ gboolean retval;
+
+ g_return_val_if_fail (MATEWNCK_IS_WINDOW (window), FALSE);
+ 
+ hints_atom = gdk_x11_get_xatom_by_name_for_display (display, 
+ _XA_MOTIF_WM_HINTS);
+
+ XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display), 
+ matewnck_window_get_xid (window),
+ hints_atom, 0, sizeof (MotifWmHints)/sizeof (long),
+ False, AnyPropertyType, &type, &format, &nitems,
+ &bytes_after, &data);
+ 
+ if (type == None || !data) return TRUE;
+ 
+ hints = (MotifWmHints *)data; 
+ 
+ retval = hints->decorations;
+ 
+ if (data)
+ XFree (data);
+
+ return retval;
+}
+
+static void
+gdk_window_set_mwm_hints (MatewnckWindow *window,
+ MotifWmHints *new_hints)
+{
+ GdkDisplay *display = gdk_display_get_default();
+ Atom hints_atom = None;
+ guchar *data = NULL;
+ MotifWmHints *hints = NULL;
+ Atom type = None;
+ gint format;
+ gulong nitems;
+ gulong bytes_after;
+
+ g_return_if_fail (MATEWNCK_IS_WINDOW (window));
+ g_return_if_fail (GDK_IS_DISPLAY (display));
+ 
+ hints_atom = gdk_x11_get_xatom_by_name_for_display (display, 
+ _XA_MOTIF_WM_HINTS);
+
+ XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display), 
+ matewnck_window_get_xid (window),
+ hints_atom, 0, sizeof (MotifWmHints)/sizeof (long),
+ False, AnyPropertyType, &type, &format, &nitems,
+ &bytes_after, &data);
+ 
+ if (type != hints_atom || !data)
+ hints = new_hints;
+ else
+ {
+ hints = (MotifWmHints *)data;
+ 
+ if (new_hints->flags & MWM_HINTS_FUNCTIONS)
+ {
+ hints->flags |= MWM_HINTS_FUNCTIONS;
+ hints->functions = new_hints->functions; 
+ }
+ if (new_hints->flags & MWM_HINTS_DECORATIONS)
+ {
+ hints->flags |= MWM_HINTS_DECORATIONS;
+ hints->decorations = new_hints->decorations;
+ }
+ }
+ 
+ _matewnck_error_trap_push ();
+ XChangeProperty (GDK_DISPLAY_XDISPLAY (display), 
+ matewnck_window_get_xid (window),
+ hints_atom, hints_atom, 32, PropModeReplace,
+ (guchar *)hints, sizeof (MotifWmHints)/sizeof (long));
+ gdk_flush ();
+ _matewnck_error_trap_pop ();
+ 
+ if (data)
+ XFree (data);
+}
+
+static void
+_window_set_decorations (MatewnckWindow *window,
+ GdkWMDecoration decorations)
+{
+ MotifWmHints *hints;
+ 
+ g_return_if_fail (MATEWNCK_IS_WINDOW (window));
+ 
+ /* initialize to zero to avoid writing uninitialized data to socket */
+ hints = g_slice_new0 (MotifWmHints);
+ hints->flags = MWM_HINTS_DECORATIONS;
+ hints->decorations = decorations;
+ 
+ gdk_window_set_mwm_hints (window, hints);
+
+ g_slice_free (MotifWmHints, hints);
+}
+
+/* </TAKEN FROM GDK> */
+
+gboolean
+window_is_too_large_for_screen (MatewnckWindow *window)
+{
+ static GdkScreen *screen = NULL;
+ gint x=0, y=0, w=0, h=0;
+
+ g_return_val_if_fail (MATEWNCK_IS_WINDOW (window), FALSE);
+
+ if (screen == NULL)
+ screen = gdk_screen_get_default ();
+ 
+ matewnck_window_get_geometry (window, &x, &y, &w, &h);
+ 
+ /* some wiggle room */
+ return (screen && 
+ (w > (gdk_screen_get_width (screen) + 20) ||
+ h > (gdk_screen_get_height (screen)+20)));
+}
+
+static gboolean
+on_window_maximised_changed (MatewnckWindow *window)
+{
+ g_return_val_if_fail (MATEWNCK_IS_WINDOW (window), FALSE);
+
+ if (window_is_too_large_for_screen (window))
+ {
+ _window_set_decorations (window, 1);
+ matewnck_window_unmaximize (window);
+ }
+ else
+ {
+ _window_set_decorations (window, 0);
+ }
+ return FALSE;
+}
+
+static gboolean
+enable_window_decorations (MatewnckWindow *window)
+{
+ g_return_val_if_fail (MATEWNCK_IS_WINDOW (window), FALSE);
+
+ _window_set_decorations (window, 1);
+ return FALSE;
+}
+
+static void
+on_window_state_changed (MatewnckWindow *window,
+ MatewnckWindowState change_mask,
+ MatewnckWindowState new_state,
+ MaximusApp *app)
+{
+ g_return_if_fail (MATEWNCK_IS_WINDOW (window));
+
+ if (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (window), "exclude"))==1)
+ return;
+ 
+ if (change_mask & MATEWNCK_WINDOW_STATE_MAXIMIZED_HORIZONTALLY
+ || change_mask & MATEWNCK_WINDOW_STATE_MAXIMIZED_VERTICALLY)
+ {
+ if (matewnck_window_is_maximized (window) && app->priv->undecorate)
+ {
+ g_idle_add ((GSourceFunc)on_window_maximised_changed, window);
+ }
+ else
+ {
+ g_idle_add ((GSourceFunc)enable_window_decorations, window);
+ }
+ }
+}
+
+static gboolean
+is_excluded (MaximusApp *app, MatewnckWindow *window)
+{
+ MaximusAppPrivate *priv;
+ MatewnckWindowType type;
+ MatewnckWindowActions actions;
+ gchar *res_name;
+ gchar *class_name;
+ GSList *c;
+ gint i;
+
+ g_return_val_if_fail (MAXIMUS_IS_APP (app), TRUE);
+ g_return_val_if_fail (MATEWNCK_IS_WINDOW (window), TRUE);
+ priv = app->priv;
+
+ type = matewnck_window_get_window_type (window);
+ if (type != MATEWNCK_WINDOW_NORMAL)
+ return TRUE;
+
+ if (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (window), "exclude"))==1)
+ return TRUE;
+
+ /* Ignore if the window is already fullscreen */
+ if (matewnck_window_is_fullscreen (window))
+ {
+ g_debug ("Excluding (is fullscreen): %s\n",matewnck_window_get_name (window));
+ return TRUE;
+ }
+ 
+ /* Make sure the window supports maximising */
+ actions = matewnck_window_get_actions (window);
+ if (actions & MATEWNCK_WINDOW_ACTION_RESIZE
+ && actions & MATEWNCK_WINDOW_ACTION_MAXIMIZE_HORIZONTALLY 
+ && actions & MATEWNCK_WINDOW_ACTION_MAXIMIZE_VERTICALLY
+ && actions & MATEWNCK_WINDOW_ACTION_MAXIMIZE)
+ ; /* Is good to maximise */
+ else
+ return TRUE;
+
+ _matewnck_get_wmclass (matewnck_window_get_xid (window), &res_name, &class_name);
+
+ g_debug ("Window opened: res_name=%s -- class_name=%s", res_name, class_name);
+ 
+ /* Check internal list of class_ids */
+ for (i = 0; i < G_N_ELEMENTS (default_exclude_classes); i++)
+ {
+ if ((class_name && default_exclude_classes[i] 
+ && strstr (class_name, default_exclude_classes[i]))
+ || (res_name && default_exclude_classes[i] && strstr (res_name, 
+ default_exclude_classes[i])))
+ {
+ g_debug ("Excluding: %s\n", matewnck_window_get_name (window));
+ return TRUE;
+ } 
+ }
+
+ /* Check user list */
+ for (c = priv->exclude_class_list; c; c = c->next)
+ {
+ if ((class_name && c->data && strstr (class_name, c->data))
+ || (res_name && c->data && strstr (res_name, c->data) ))
+ {
+ g_debug ("Excluding: %s\n", matewnck_window_get_name (window));
+ return TRUE;
+ }
+ }
+
+ g_free (res_name);
+ g_free (class_name);
+ return FALSE;
+}
+
+extern gboolean no_maximize;
+
+static void
+on_window_opened (MatewnckScreen *screen, 
+ MatewnckWindow *window,
+ MaximusApp *app)
+{ 
+ MaximusAppPrivate *priv;
+ MatewnckWindowType type;
+ gint exclude = 0;
+ 
+ g_return_if_fail (MAXIMUS_IS_APP (app));
+ g_return_if_fail (MATEWNCK_IS_WINDOW (window));
+ priv = app->priv;
+
+ type = matewnck_window_get_window_type (window);
+ if (type != MATEWNCK_WINDOW_NORMAL)
+ return;
+
+ /* Ignore undecorated windows */
+ exclude = matewnck_window_is_decorated (window) ? 0 : 1;
+ if (matewnck_window_is_maximized (window))
+ exclude = 0;
+ g_object_set_data (G_OBJECT (window), "exclude", GINT_TO_POINTER (exclude));
+
+ if (is_excluded (app, window))
+ {
+ g_signal_connect (window, "state-changed",
+ G_CALLBACK (on_window_state_changed), app);
+ return;
+ }
+
+ if (no_maximize || priv->no_maximize)
+ {
+ if (matewnck_window_is_maximized(window))
+ {
+ _window_set_decorations (window, 0);
+ gdk_flush ();
+ }
+ g_signal_connect (window, "state-changed",
+ G_CALLBACK (on_window_state_changed), app);
+ return;
+ }
+
+ if (priv->undecorate)
+ {
+ /* Only undecorate right now if the window is smaller than the screen */
+ if (!window_is_too_large_for_screen (window))
+ {
+ _window_set_decorations (window, 0);
+ gdk_flush ();
+ }
+ }
+
+ matewnck_window_maximize (window);
+
+ g_signal_connect (window, "state-changed",
+ G_CALLBACK (on_window_state_changed), app);
+}
+
+static void
+on_app_no_maximize_changed (MateConfClient *client,
+ guint cid,
+ MateConfEntry *entry,
+ MaximusApp *app)
+{
+ MaximusAppPrivate *priv;
+ MateConfValue* value;
+
+ g_return_if_fail (MAXIMUS_IS_APP (app));
+ priv = app->priv;
+
+ if (entry == NULL) 
+ {
+ priv->no_maximize = FALSE;
+ }
+ else
+ {
+ value = mateconf_entry_get_value(entry);
+ priv->no_maximize = value != NULL && mateconf_value_get_bool(value);
+ }
+}
+
+/* MateConf Callbacks */
+static void
+on_exclude_class_changed (MateConfClient *client,
+ guint cid,
+ MateConfEntry *entry,
+ MaximusApp *app)
+{
+ MaximusAppPrivate *priv;
+ 
+ g_return_if_fail (MAXIMUS_IS_APP (app));
+ priv = app->priv;
+
+ if (priv->exclude_class_list)
+ g_slist_free (priv->exclude_class_list);
+ 
+ priv->exclude_class_list= mateconf_client_get_list (client, 
+ APP_EXCLUDE_CLASS, 
+ MATECONF_VALUE_STRING,
+ NULL);
+}
+
+static gboolean
+show_desktop (MatewnckScreen *screen)
+{
+ g_return_val_if_fail (MATEWNCK_IS_SCREEN (screen), FALSE);
+ 
+ matewnck_screen_toggle_showing_desktop (screen, TRUE);
+ return FALSE;
+}
+
+static void
+on_app_undecorate_changed (MateConfClient *client,
+ guint cid,
+ MateConfEntry *entry,
+ MaximusApp *app)
+{
+ MaximusAppPrivate *priv;
+ GList *windows, *w;
+ 
+ g_return_if_fail (MAXIMUS_IS_APP (app));
+ priv = app->priv;
+ g_return_if_fail (MATEWNCK_IS_SCREEN (priv->screen));
+
+ priv->undecorate = mateconf_client_get_bool (client, 
+ APP_UNDECORATE, 
+ NULL);
+ g_debug ("%s\n", priv->undecorate ? "Undecorating" : "Decorating");
+ 
+ windows = matewnck_screen_get_windows (priv->screen);
+ for (w = windows; w; w = w->next)
+ {
+ MatewnckWindow *window = w->data;
+
+ if (!MATEWNCK_IS_WINDOW (window))
+ continue;
+
+ if (no_maximize || priv->no_maximize)
+ {
+ if (!matewnck_window_is_maximized(window))
+ continue;
+ }
+
+ if (!is_excluded (app, window))
+ {
+ gdk_error_trap_push ();
+ _window_set_decorations (window, priv->undecorate ? 0 : 1);
+ matewnck_window_unmaximize (window);
+ matewnck_window_maximize (window);
+ gdk_flush ();
+ gdk_error_trap_pop ();
+
+ sleep (1);
+ }
+ }
+ /* We want the user to be left on the launcher/desktop after switching modes*/
+ g_timeout_add_seconds (1, (GSourceFunc)show_desktop, priv->screen);
+}
+
+
+/* GObject stuff */
+static void
+maximus_app_class_init (MaximusAppClass *klass)
+{
+ GObjectClass *obj_class = G_OBJECT_CLASS (klass);
+
+ g_type_class_add_private (obj_class, sizeof (MaximusAppPrivate));
+}
+
+static void
+maximus_app_init (MaximusApp *app)
+{
+ MaximusAppPrivate *priv;
+ MateConfClient *client = mateconf_client_get_default ();
+ MatewnckScreen *screen;
+ 
+ priv = app->priv = MAXIMUS_APP_GET_PRIVATE (app);
+
+ priv->bind = maximus_bind_get_default ();
+
+ was_decorated = g_quark_from_static_string ("was-decorated");
+
+ mateconf_client_add_dir (client, APP_PATH, MATECONF_CLIENT_PRELOAD_NONE, NULL);
+
+ priv->exclude_class_list= mateconf_client_get_list (client, 
+ APP_EXCLUDE_CLASS, 
+ MATECONF_VALUE_STRING,
+ NULL);
+ mateconf_client_notify_add (client, APP_EXCLUDE_CLASS,
+ (MateConfClientNotifyFunc)on_exclude_class_changed,
+ app, NULL, NULL);
+
+ priv->undecorate = mateconf_client_get_bool(client, 
+ APP_UNDECORATE, 
+ NULL);
+ mateconf_client_notify_add (client, APP_UNDECORATE,
+ (MateConfClientNotifyFunc)on_app_undecorate_changed,
+ app, NULL, NULL);
+
+ 
+ priv->screen = screen = matewnck_screen_get_default ();
+ g_signal_connect (screen, "window-opened",
+ G_CALLBACK (on_window_opened), app);
+
+ priv->no_maximize = mateconf_client_get_bool(client,
+ APP_NO_MAXIMIZE,
+ NULL);
+ g_print ("no maximize: %s\n", priv->no_maximize ? "true" : "false");
+ mateconf_client_notify_add (client, APP_NO_MAXIMIZE,
+ (MateConfClientNotifyFunc)on_app_no_maximize_changed,
+ app, NULL, NULL);
+}
+
+MaximusApp *
+maximus_app_get_default (void)
+
+{
+ static MaximusApp *app = NULL;
+
+ if (!app)
+ app = g_object_new (MAXIMUS_TYPE_APP, 
+ NULL);
+
+ return app;
+}
author	Stefano Karapetsas <[email protected]>	2012-07-04 18:01:12 +0200
committer	Stefano Karapetsas <[email protected]>	2012-07-04 18:01:12 +0200
commit	e48fc61bf4cf43a90b7ddf16e3cbb3b247333c89 (patch)
tree	15722913e64320b18a09b2452d0a382ebeb953e9 /maximus/maximus-app.c
download	mate-netbook-e48fc61bf4cf43a90b7ddf16e3cbb3b247333c89.tar.bz2 mate-netbook-e48fc61bf4cf43a90b7ddf16e3cbb3b247333c89.tar.xz