[packages/mate-netbook] - new
qboosh
qboosh at pld-linux.org
Wed Jan 1 15:16:04 CET 2014
commit c5ee8a66af2e8e0600217398b9195369d4bff401
Author: Jakub Bogusz <qboosh at pld-linux.org>
Date: Wed Jan 1 15:16:21 2014 +0100
- new
mate-netbook-use-libwnck.patch | 1410 ++++++++++++++++++++++++++++++++++++++++
mate-netbook.spec | 97 +++
2 files changed, 1507 insertions(+)
---
diff --git a/mate-netbook.spec b/mate-netbook.spec
new file mode 100644
index 0000000..1ee062a
--- /dev/null
+++ b/mate-netbook.spec
@@ -0,0 +1,97 @@
+Summary: Simple window management tool
+Summary(pl.UTF-8): Proste narzędzie do zarządzania oknami
+Name: mate-netbook
+Version: 1.6.0
+Release: 1
+License: LGPL v2+
+Group: X11/Applications
+Source0: http://pub.mate-desktop.org/releases/1.6/%{name}-%{version}.tar.xz
+# Source0-md5: 26cfc4e44f7cda7153b8ecb7d21d6a4c
+Patch0: %{name}-use-libwnck.patch
+URL: http://mate-desktop.org/
+BuildRequires: autoconf >= 2.53
+BuildRequires: automake >= 1:1.9
+BuildRequires: gettext-devel >= 0.10.40
+BuildRequires: glib2-devel >= 2.0
+BuildRequires: gtk+2-devel >= 2.0
+BuildRequires: intltool >= 0.34
+BuildRequires: libfakekey-devel
+BuildRequires: libtool >= 1:1.4.3
+BuildRequires: libunique-devel >= 1.0
+BuildRequires: libwnck2-devel >= 1.0
+BuildRequires: mate-panel-devel
+BuildRequires: pkgconfig
+BuildRequires: rpmbuild(find_lang) >= 1.36
+BuildRequires: tar >= 1:1.22
+BuildRequires: xorg-lib-libXtst-devel
+BuildRequires: xz
+Requires(post,postun): glib2 >= 2.0
+Requires: mate-panel
+BuildRoot: %{tmpdir}/%{name}-%{version}-root-%(id -u -n)
+
+%description
+A simple window management tool which:
+- allows you to set basic rules for a window type, such as maximise
+ or undecorate
+- allows exceptions to the rules, based on string matching for window
+ name and window class
+- allows 'reversing' of rules when the user manually changes
+ something:
+ - re-decorates windows on un-maximise
+
+%description -l pl.UTF-8
+Proste narzędzie do zarządzania oknami, które:
+- pozwala na ustawianie podstawowych reguł dla typu okna, takich jak
+ maksymalizacja lub usunięcie dekoracji
+- pozwala na wyjątki od reguł, w oparciu o dopasowywanie nazwy lub
+ klasy okna
+- pozwala na odwrócenie reguł, kiedy użytkownik coś zmieni:
+ - ponownie włącza dekoracje okien przy wyłączeniu maksymalizacji
+
+%prep
+%setup -q
+%patch0 -p1
+
+%build
+%{__intltoolize}
+%{__libtoolize}
+%{__aclocal}
+%{__autoconf}
+%{__autoheader}
+%{__automake}
+%configure \
+ --disable-silent-rules
+
+%{__make}
+
+%install
+rm -rf $RPM_BUILD_ROOT
+
+%{__make} install \
+ DESTDIR=$RPM_BUILD_ROOT
+
+# mate < 1.5 did not exist in PLD, avoid dependency on mate-conf
+%{__rm} $RPM_BUILD_ROOT%{_datadir}/MateConf/gsettings/mate-maximus.convert
+
+%find_lang %{name}
+
+%clean
+rm -rf $RPM_BUILD_ROOT
+
+%post
+%glib_compile_schemas
+
+%postun
+%glib_compile_schemas
+
+%files -f %{name}.lang
+%defattr(644,root,root,755)
+%doc AUTHORS ChangeLog NEWS README
+%attr(755,root,root) %{_bindir}/mate-maximus
+%attr(755,root,root) %{_libexecdir}/mate-window-picker-applet
+/etc/xdg/autostart/mate-maximus-autostart.desktop
+%{_datadir}/dbus-1/services/org.mate.panel.applet.MateWindowPickerFactory.service
+%{_datadir}/glib-2.0/schemas/org.mate.maximus.gschema.xml
+%{_datadir}/glib-2.0/schemas/org.mate.panel.applet.mate-window-picker-applet.gschema.xml
+%{_datadir}/mate-panel/applets/org.mate.panel.MateWindowPicker.mate-panel-applet
+%{_datadir}/mate-panel/ui/mate-window-picker-applet-menu.xml
diff --git a/mate-netbook-use-libwnck.patch b/mate-netbook-use-libwnck.patch
new file mode 100644
index 0000000..1ce945f
--- /dev/null
+++ b/mate-netbook-use-libwnck.patch
@@ -0,0 +1,1410 @@
+--- mate-netbook-1.6.0/configure.ac.orig 2013-04-01 16:05:35.000000000 +0200
++++ mate-netbook-1.6.0/configure.ac 2014-01-01 14:29:05.696093665 +0100
+@@ -34,7 +34,7 @@
+ PKG_CHECK_MODULES(MAXIMUS_DEPS,
+ gtk+-2.0
+ gio-2.0
+- libmatewnck
++ libwnck-1.0
+ xtst
+ libfakekey
+ unique-1.0
+@@ -47,7 +47,7 @@
+ gtk+-2.0
+ glib-2.0
+ gio-2.0
+- libmatewnck
++ libwnck-1.0
+ )
+ AC_SUBST(MATEWINDOWPICKER_DEPS_CFLAGS)
+ AC_SUBST(MATEWINDOWPICKER_DEPS_LIBS)
+--- mate-netbook-1.6.0/mate-window-picker-applet/applet.c.orig 2014-01-01 14:42:12.359393985 +0100
++++ mate-netbook-1.6.0/mate-window-picker-applet/applet.c 2014-01-01 14:42:24.176060156 +0100
+@@ -28,7 +28,8 @@
+ #include <glib/gi18n.h>
+ #include <gtk/gtk.h>
+
+-#include <libmatewnck/libmatewnck.h>
++#define WNCK_I_KNOW_THIS_IS_UNSTABLE
++#include <libwnck/libwnck.h>
+
+ #include <gio/gio.h>
+ #include <mate-panel-applet.h>
+@@ -138,7 +138,7 @@ cw_applet_fill (MatePanelApplet *applet,
+ const gchar *iid,
+ gpointer data)
+ {
+- MatewnckScreen *screen;
++ WnckScreen *screen;
+ WinPickerApp *app;
+ GtkWidget *eb, *tasks, *title;
+ gchar *ui_path;
+@@ -152,11 +152,11 @@ cw_applet_fill (MatePanelApplet *applet,
+ bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
+ textdomain (GETTEXT_PACKAGE);
+
+- matewnck_set_client_type (MATEWNCK_CLIENT_TYPE_PAGER);
++ wnck_set_client_type (WNCK_CLIENT_TYPE_PAGER);
+
+ app = g_slice_new0 (WinPickerApp);
+ mainapp = app;
+- screen = matewnck_screen_get_default ();
++ screen = wnck_screen_get_default ();
+
+ /* prepare to disable Maximus */
+ object_class = G_OBJECT_GET_CLASS (G_OBJECT(applet));
+--- mate-netbook-1.6.0/mate-window-picker-applet/task-item.c.orig 2013-04-01 16:05:35.000000000 +0200
++++ mate-netbook-1.6.0/mate-window-picker-applet/task-item.c 2014-01-01 14:44:45.849387544 +0100
+@@ -35,8 +35,8 @@ G_DEFINE_TYPE (TaskItem, task_item, GTK_
+
+ struct _TaskItemPrivate
+ {
+- MatewnckWindow *window;
+- MatewnckScreen *screen;
++ WnckWindow *window;
++ WnckScreen *screen;
+ GdkPixbuf *pixbuf;
+ GdkRectangle area;
+
+@@ -66,13 +66,13 @@ update_hints (TaskItem *item)
+ {
+ GtkWidget *parent;
+ GtkWidget *widget;
+- MatewnckWindow *window;
++ WnckWindow *window;
+ gint x, y, x1, y1;
+
+ widget = GTK_WIDGET (item);
+ window = item->priv->window;
+ /* Skip problems */
+- if (!MATEWNCK_IS_WINDOW (window)) return;
++ if (!WNCK_IS_WINDOW (window)) return;
+ if (!GTK_IS_WIDGET (widget)) return;
+
+ /* Skip invisible windows */
+@@ -99,7 +99,7 @@ update_hints (TaskItem *item)
+ }
+
+ /* Set the minimize hint for the window */
+- matewnck_window_set_icon_geometry (window, x, y,
++ wnck_window_set_icon_geometry (window, x, y,
+ widget->allocation.width,
+ widget->allocation.height);
+ }
+@@ -109,9 +109,9 @@ on_task_item_button_released (GtkWidget
+ GdkEventButton *event,
+ TaskItem *item)
+ {
+- MatewnckWindow *window;
+- MatewnckScreen *screen;
+- MatewnckWorkspace *workspace;
++ WnckWindow *window;
++ WnckScreen *screen;
++ WnckWorkspace *workspace;
+ TaskItemPrivate *priv;
+
+ g_return_val_if_fail (TASK_IS_ITEM (item), TRUE);
+@@ -119,25 +119,25 @@ on_task_item_button_released (GtkWidget
+ priv = item->priv;
+ window = priv->window;
+
+- g_return_val_if_fail (MATEWNCK_IS_WINDOW (window), TRUE);
++ g_return_val_if_fail (WNCK_IS_WINDOW (window), TRUE);
+
+ screen = priv->screen;
+- workspace = matewnck_window_get_workspace (window);
++ workspace = wnck_window_get_workspace (window);
+
+ if (event->button == 1)
+ {
+
+- if (MATEWNCK_IS_WORKSPACE (workspace) && workspace != matewnck_screen_get_active_workspace (screen))
++ if (WNCK_IS_WORKSPACE (workspace) && workspace != wnck_screen_get_active_workspace (screen))
+ {
+- matewnck_workspace_activate (workspace, GDK_CURRENT_TIME);
++ wnck_workspace_activate (workspace, GDK_CURRENT_TIME);
+ }
+- if (matewnck_window_is_active (window))
++ if (wnck_window_is_active (window))
+ {
+- matewnck_window_minimize (window);
++ wnck_window_minimize (window);
+ }
+ else
+ {
+- matewnck_window_activate (window, GDK_CURRENT_TIME);
++ wnck_window_activate (window, GDK_CURRENT_TIME);
+ }
+ }
+ return TRUE;
+@@ -146,15 +146,15 @@ on_task_item_button_released (GtkWidget
+ static void
+ task_item_set_visibility (TaskItem *item)
+ {
+- MatewnckScreen *screen;
+- MatewnckWindow *window;
+- MatewnckWorkspace *workspace;
++ WnckScreen *screen;
++ WnckWindow *window;
++ WnckWorkspace *workspace;
+
+ g_return_if_fail (TASK_IS_ITEM (item));
+
+ TaskItemPrivate *priv = item->priv;
+
+- if (!MATEWNCK_IS_WINDOW (priv->window))
++ if (!WNCK_IS_WINDOW (priv->window))
+ {
+ gtk_widget_hide (GTK_WIDGET (item));
+ return;
+@@ -163,20 +163,20 @@ task_item_set_visibility (TaskItem *item
+ window = priv->window;
+
+ screen = priv->screen;
+- workspace = matewnck_screen_get_active_workspace (screen);
++ workspace = wnck_screen_get_active_workspace (screen);
+
+ gboolean show_all = task_list_get_show_all_windows (TASK_LIST (task_list_get_default ()));
+ gboolean show_window = FALSE;
+
+- if (!matewnck_window_is_skip_tasklist (window))
++ if (!wnck_window_is_skip_tasklist (window))
+ {
+- if (matewnck_workspace_is_virtual (workspace))
++ if (wnck_workspace_is_virtual (workspace))
+ {
+- show_window = matewnck_window_is_in_viewport (window, workspace);
++ show_window = wnck_window_is_in_viewport (window, workspace);
+ }
+ else
+ {
+- show_window = matewnck_window_is_on_workspace (window, workspace);
++ show_window = wnck_window_is_on_workspace (window, workspace);
+ }
+ show_window = show_window || show_all;
+ }
+@@ -202,16 +202,16 @@ task_item_size_request (GtkWidget *
+
+ static GdkPixbuf *
+ task_item_sized_pixbuf_for_window (TaskItem *item,
+- MatewnckWindow *window,
++ WnckWindow *window,
+ gint size)
+ {
+ GdkPixbuf *pbuf = NULL;
+
+- g_return_val_if_fail (MATEWNCK_IS_WINDOW (window), NULL);
++ g_return_val_if_fail (WNCK_IS_WINDOW (window), NULL);
+
+- if (matewnck_window_has_icon_name (window))
++ if (wnck_window_has_icon_name (window))
+ {
+- const gchar *icon_name = matewnck_window_get_icon_name (window);
++ const gchar *icon_name = wnck_window_get_icon_name (window);
+ GtkIconTheme *icon_theme = gtk_icon_theme_get_default ();
+
+ if (gtk_icon_theme_has_icon (icon_theme, icon_name))
+@@ -228,7 +228,7 @@ task_item_sized_pixbuf_for_window (TaskI
+
+ if (!pbuf)
+ {
+- pbuf = gdk_pixbuf_copy (matewnck_window_get_icon (item->priv->window));
++ pbuf = gdk_pixbuf_copy (wnck_window_get_icon (item->priv->window));
+ }
+
+ gint width = gdk_pixbuf_get_width (pbuf);
+@@ -264,7 +264,7 @@ task_item_expose_event (GtkWidget *
+ item = TASK_ITEM (widget);
+ priv = item->priv;
+
+- g_return_val_if_fail (MATEWNCK_IS_WINDOW (priv->window), FALSE);
++ g_return_val_if_fail (WNCK_IS_WINDOW (priv->window), FALSE);
+
+ area = priv->area;
+ cr = gdk_cairo_create (event->window);
+@@ -273,8 +273,8 @@ task_item_expose_event (GtkWidget *
+ desat = NULL;
+
+ gint size = MIN (area.height, area.width);
+- gboolean active = matewnck_window_is_active (priv->window);
+- gboolean attention = matewnck_window_or_transient_needs_attention (priv->window);
++ gboolean active = wnck_window_is_active (priv->window);
++ gboolean attention = wnck_window_or_transient_needs_attention (priv->window);
+
+ if (GDK_IS_PIXBUF (pbuf) &&
+ gdk_pixbuf_get_width (pbuf) != size &&
+@@ -385,14 +385,14 @@ on_button_pressed (GtkWidget *butto
+ GdkEventButton *event,
+ TaskItem *item)
+ {
+- MatewnckWindow *window;
++ WnckWindow *window;
+ g_return_val_if_fail (TASK_IS_ITEM (item), FALSE);
+ window = item->priv->window;
+- g_return_val_if_fail (MATEWNCK_IS_WINDOW (window), FALSE);
++ g_return_val_if_fail (WNCK_IS_WINDOW (window), FALSE);
+
+ if (event->button == 3)
+ {
+- GtkWidget *menu = matewnck_action_menu_new (window);
++ GtkWidget *menu = wnck_action_menu_new (window);
+ gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL,
+ event->button, event->time);
+ return TRUE;
+@@ -408,11 +408,11 @@ on_query_tooltip (GtkWidget *widget,
+ GtkTooltip *tooltip,
+ TaskItem *item)
+ {
+- MatewnckWindow *window = item->priv->window;
+- g_return_val_if_fail (MATEWNCK_IS_WINDOW (window), FALSE);
++ WnckWindow *window = item->priv->window;
++ g_return_val_if_fail (WNCK_IS_WINDOW (window), FALSE);
+
+- gtk_tooltip_set_text (tooltip, matewnck_window_get_name(window));
+- gtk_tooltip_set_icon (tooltip, matewnck_window_get_icon (window));
++ gtk_tooltip_set_text (tooltip, wnck_window_get_name(window));
++ gtk_tooltip_set_icon (tooltip, wnck_window_get_icon (window));
+
+ return TRUE;
+ }
+@@ -450,7 +450,7 @@ on_blink (TaskItem *item)
+
+ gtk_widget_queue_draw (GTK_WIDGET (item));
+
+- if (matewnck_window_or_transient_needs_attention (item->priv->window))
++ if (wnck_window_or_transient_needs_attention (item->priv->window))
+ {
+ return TRUE;
+ }
+@@ -462,17 +462,17 @@ on_blink (TaskItem *item)
+ }
+
+ static void
+-on_window_state_changed (MatewnckWindow *window,
+- MatewnckWindowState changed_mask,
+- MatewnckWindowState new_state,
++on_window_state_changed (WnckWindow *window,
++ WnckWindowState changed_mask,
++ WnckWindowState new_state,
+ TaskItem *item)
+ {
+- g_return_if_fail (MATEWNCK_IS_WINDOW (window));
++ g_return_if_fail (WNCK_IS_WINDOW (window));
+ g_return_if_fail (TASK_IS_ITEM (item));
+
+ TaskItemPrivate *priv = item->priv;
+
+- if (new_state & MATEWNCK_WINDOW_STATE_URGENT && !priv->timer)
++ if (new_state & WNCK_WINDOW_STATE_URGENT && !priv->timer)
+ {
+ priv->timer = g_timeout_add (30, (GSourceFunc)on_blink, item);
+ g_get_current_time (&priv->urgent_time);
+@@ -482,14 +482,14 @@ on_window_state_changed (MatewnckWindow
+ }
+
+ static void
+-on_window_workspace_changed (MatewnckWindow *window, TaskItem *item)
++on_window_workspace_changed (WnckWindow *window, TaskItem *item)
+ {
+ g_return_if_fail (TASK_IS_ITEM (item));
+
+ task_item_set_visibility (item);
+ }
+
+-static void on_window_icon_changed (MatewnckWindow *window, TaskItem *item)
++static void on_window_icon_changed (WnckWindow *window, TaskItem *item)
+ {
+ TaskItemPrivate *priv;
+
+@@ -507,11 +507,11 @@ static void on_window_icon_changed (Mate
+ }
+
+ static void
+-on_screen_active_window_changed (MatewnckScreen *screen,
+- MatewnckWindow *old_window,
++on_screen_active_window_changed (WnckScreen *screen,
++ WnckWindow *old_window,
+ TaskItem *item)
+ {
+- MatewnckWindow *window;
++ WnckWindow *window;
+ TaskItemPrivate *priv;
+
+ g_return_if_fail (TASK_IS_ITEM (item));
+@@ -519,10 +519,10 @@ on_screen_active_window_changed (Matewnc
+ priv = item->priv;
+ window = priv->window;
+
+- g_return_if_fail (MATEWNCK_IS_WINDOW (window));
++ g_return_if_fail (WNCK_IS_WINDOW (window));
+
+- if ((MATEWNCK_IS_WINDOW (old_window) && window == old_window) ||
+- window == matewnck_screen_get_active_window (screen))
++ if ((WNCK_IS_WINDOW (old_window) && window == old_window) ||
++ window == wnck_screen_get_active_window (screen))
+ {
+ /* queue a draw to reflect that we are [no longer] the active window */
+ gtk_widget_queue_draw (GTK_WIDGET (item));
+@@ -530,8 +530,8 @@ on_screen_active_window_changed (Matewnc
+ }
+
+ static void
+-on_screen_active_workspace_changed (MatewnckScreen *screen,
+- MatewnckWorkspace *old_workspace,
++on_screen_active_workspace_changed (WnckScreen *screen,
++ WnckWorkspace *old_workspace,
+ TaskItem *item)
+ {
+ g_return_if_fail (TASK_IS_ITEM (item));
+@@ -540,7 +540,7 @@ on_screen_active_workspace_changed (Mate
+ }
+
+ static void
+-on_screen_active_viewport_changed (MatewnckScreen *screen,
++on_screen_active_viewport_changed (WnckScreen *screen,
+ TaskItem *item)
+ {
+ g_return_if_fail (TASK_IS_ITEM (item));
+@@ -549,15 +549,15 @@ on_screen_active_viewport_changed (Matew
+ }
+
+ static void
+-on_screen_window_closed (MatewnckScreen *screen,
+- MatewnckWindow *window,
++on_screen_window_closed (WnckScreen *screen,
++ WnckWindow *window,
+ TaskItem *item)
+ {
+ TaskItemPrivate *priv;
+
+ g_return_if_fail (TASK_IS_ITEM (item));
+ priv = item->priv;
+- g_return_if_fail (MATEWNCK_IS_WINDOW (priv->window));
++ g_return_if_fail (WNCK_IS_WINDOW (priv->window));
+
+ if (priv->window == window)
+ {
+@@ -583,17 +583,17 @@ activate_window (GtkWidget *widget)
+
+ priv = TASK_ITEM (widget)->priv;
+
+- g_return_val_if_fail (MATEWNCK_IS_WINDOW (priv->window), FALSE);
++ g_return_val_if_fail (WNCK_IS_WINDOW (priv->window), FALSE);
+
+ active = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget), "drag-true"));
+
+ if (active)
+ {
+- MatewnckWindow *window;
++ WnckWindow *window;
+
+ window = priv->window;
+- if (MATEWNCK_IS_WINDOW (window))
+- matewnck_window_activate (window, time (NULL));
++ if (WNCK_IS_WINDOW (window))
++ wnck_window_activate (window, time (NULL));
+ }
+
+ g_object_set_data (G_OBJECT (widget), "drag-true", GINT_TO_POINTER (0));
+@@ -636,7 +636,7 @@ task_item_setup_atk (TaskItem *item)
+ TaskItemPrivate *priv;
+ GtkWidget *widget;
+ AtkObject *atk;
+- MatewnckWindow *window;
++ WnckWindow *window;
+
+ g_return_if_fail (TASK_IS_ITEM (item));
+
+@@ -644,11 +644,11 @@ task_item_setup_atk (TaskItem *item)
+ priv = item->priv;
+ window = priv->window;
+
+- g_return_if_fail (MATEWNCK_IS_WINDOW (window));
++ g_return_if_fail (WNCK_IS_WINDOW (window));
+
+ atk = gtk_widget_get_accessible (widget);
+ atk_object_set_name (atk, _("Window Task Button"));
+- atk_object_set_description (atk, matewnck_window_get_name (window));
++ atk_object_set_description (atk, wnck_window_get_name (window));
+ atk_object_set_role (atk, ATK_ROLE_PUSH_BUTTON);
+ }
+
+@@ -703,14 +703,14 @@ task_item_init (TaskItem *item)
+ }
+
+ GtkWidget *
+-task_item_new (MatewnckWindow *window)
++task_item_new (WnckWindow *window)
+ {
+ GtkWidget *item = NULL;
+ TaskItem *task;
+ TaskItemPrivate *priv;
+- MatewnckScreen *screen;
++ WnckScreen *screen;
+
+- g_return_val_if_fail (MATEWNCK_IS_WINDOW (window), item);
++ g_return_val_if_fail (WNCK_IS_WINDOW (window), item);
+
+ item = g_object_new (TASK_TYPE_ITEM,
+ "has-tooltip", TRUE,
+@@ -725,7 +725,7 @@ task_item_new (MatewnckWindow *window)
+ priv = task->priv;
+ priv->window = window;
+
+- screen = matewnck_window_get_screen (window);
++ screen = wnck_window_get_screen (window);
+ priv->screen = screen;
+
+ gtk_drag_dest_set (item,
+--- mate-netbook-1.6.0/mate-window-picker-applet/task-list.c.orig 2013-04-01 16:05:35.000000000 +0200
++++ mate-netbook-1.6.0/mate-window-picker-applet/task-list.c 2014-01-01 14:45:10.512719842 +0100
+@@ -20,7 +20,8 @@
+ #include "task-list.h"
+ #include "task-item.h"
+
+-#include <libmatewnck/libmatewnck.h>
++#define WNCK_I_KNOW_THIS_IS_UNSTABLE
++#include <libwnck/libwnck.h>
+
+ G_DEFINE_TYPE (TaskList, task_list, GTK_TYPE_HBOX);
+
+@@ -30,7 +30,7 @@ G_DEFINE_TYPE (TaskList, task_list, GTK_
+
+ struct _TaskListPrivate
+ {
+- MatewnckScreen *screen;
++ WnckScreen *screen;
+ GHashTable *win_table;
+ guint timer;
+ guint counter;
+@@ -65,22 +65,22 @@ on_task_item_closed (TaskItem *item,
+ }
+
+ static void
+-on_window_opened (MatewnckScreen *screen,
+- MatewnckWindow *window,
++on_window_opened (WnckScreen *screen,
++ WnckWindow *window,
+ TaskList *list)
+ {
+ TaskListPrivate *priv;
+- MatewnckWindowType type;
++ WnckWindowType type;
+
+ g_return_if_fail (TASK_IS_LIST (list));
+ priv = list->priv;
+
+- type = matewnck_window_get_window_type (window);
++ type = wnck_window_get_window_type (window);
+
+- if (type == MATEWNCK_WINDOW_DESKTOP
+- || type == MATEWNCK_WINDOW_DOCK
+- || type == MATEWNCK_WINDOW_SPLASHSCREEN
+- || type == MATEWNCK_WINDOW_MENU)
++ if (type == WNCK_WINDOW_DESKTOP
++ || type == WNCK_WINDOW_DOCK
++ || type == WNCK_WINDOW_SPLASHSCREEN
++ || type == WNCK_WINDOW_MENU)
+ return;
+
+ GtkWidget *item = task_item_new (window);
+@@ -178,7 +178,7 @@ task_list_init (TaskList *list)
+
+ priv = list->priv = TASK_LIST_GET_PRIVATE (list);
+
+- priv->screen = matewnck_screen_get_default ();
++ priv->screen = wnck_screen_get_default ();
+
+ priv->win_table = g_hash_table_new (NULL, NULL);
+
+@@ -224,14 +224,14 @@ task_list_get_desktop_visible (TaskList
+
+ g_return_val_if_fail (TASK_IS_LIST (list), TRUE);
+
+- windows = matewnck_screen_get_windows (list->priv->screen);
++ windows = wnck_screen_get_windows (list->priv->screen);
+ for (w = windows; w; w = w->next)
+ {
+- MatewnckWindow *window;
++ WnckWindow *window;
+
+ window = w->data;
+
+- if (MATEWNCK_IS_WINDOW (window) && !matewnck_window_is_minimized (window))
++ if (WNCK_IS_WINDOW (window) && !wnck_window_is_minimized (window))
+ all_minimised = FALSE;
+ }
+
+--- mate-netbook-1.6.0/mate-window-picker-applet/task-title.c.orig 2013-04-01 16:05:35.000000000 +0200
++++ mate-netbook-1.6.0/mate-window-picker-applet/task-title.c 2014-01-01 14:46:16.976050386 +0100
+@@ -19,7 +19,8 @@
+
+ #include "task-title.h"
+
+-#include <libmatewnck/libmatewnck.h>
++#define WNCK_I_KNOW_THIS_IS_UNSTABLE
++#include <libwnck/libwnck.h>
+ #include <mate-panel-applet.h>
+
+ #include "task-list.h"
+@@ -35,8 +35,8 @@ G_DEFINE_TYPE (TaskTitle, task_title, GT
+
+ struct _TaskTitlePrivate
+ {
+- MatewnckScreen *screen;
+- MatewnckWindow *window;
++ WnckScreen *screen;
++ WnckWindow *window;
+ GtkWidget *align;
+ GtkWidget *box;
+ GtkWidget *label;
+@@ -56,7 +56,7 @@ on_close_clicked (GtkButton *button,
+ TaskTitle *title)
+ {
+ TaskTitlePrivate *priv;
+- MatewnckWindow *window;
++ WnckWindow *window;
+
+ g_return_val_if_fail (TASK_IS_TITLE (title), FALSE);
+ priv = title->priv;
+@@ -64,10 +64,10 @@ on_close_clicked (GtkButton *button,
+ if (event->button != 1 || !priv->mouse_in_close_button)
+ return FALSE;
+
+- window = matewnck_screen_get_active_window (priv->screen);
++ window = wnck_screen_get_active_window (priv->screen);
+
+- if (!MATEWNCK_IS_WINDOW (window)
+- || matewnck_window_get_window_type (window) == MATEWNCK_WINDOW_DESKTOP)
++ if (!WNCK_IS_WINDOW (window)
++ || wnck_window_get_window_type (window) == WNCK_WINDOW_DESKTOP)
+ {
+ gdk_spawn_command_line_on_screen (gdk_screen_get_default (),
+ LOGOUT, NULL);
+@@ -76,7 +76,7 @@ on_close_clicked (GtkButton *button,
+ {
+ if (priv->window == window)
+ disconnect_window (title);
+- matewnck_window_close (window, GDK_CURRENT_TIME);
++ wnck_window_close (window, GDK_CURRENT_TIME);
+ }
+ gtk_widget_queue_draw (GTK_WIDGET (title));
+
+@@ -138,32 +138,32 @@ on_button_expose (GtkWidget *widget,
+ }
+
+ static void
+-on_name_changed (MatewnckWindow *window, TaskTitle *title)
++on_name_changed (WnckWindow *window, TaskTitle *title)
+ {
+ TaskTitlePrivate *priv;
+
+ g_return_if_fail (TASK_IS_TITLE (title));
+- g_return_if_fail (MATEWNCK_IS_WINDOW (window));
++ g_return_if_fail (WNCK_IS_WINDOW (window));
+
+ priv = title->priv;
+ if (priv->window != window)
+ return;
+
+ gtk_label_set_text (GTK_LABEL (title->priv->label),
+- matewnck_window_get_name (window));
++ wnck_window_get_name (window));
+ gtk_widget_set_tooltip_text (GTK_WIDGET (title),
+- matewnck_window_get_name (window));
++ wnck_window_get_name (window));
+ gtk_widget_queue_draw (GTK_WIDGET (title));
+ }
+
+
+ static void
+-on_icon_changed (MatewnckWindow *window, TaskTitle *title)
++on_icon_changed (WnckWindow *window, TaskTitle *title)
+ {
+ TaskTitlePrivate *priv;
+
+ g_return_if_fail (TASK_IS_TITLE (title));
+- g_return_if_fail (MATEWNCK_IS_WINDOW (window));
++ g_return_if_fail (WNCK_IS_WINDOW (window));
+
+ priv = title->priv;
+ if (priv->window != window)
+@@ -173,21 +173,21 @@ on_icon_changed (MatewnckWindow *window,
+ }
+
+ static void
+-on_state_changed (MatewnckWindow *window,
+- MatewnckWindowState changed_mask,
+- MatewnckWindowState new_state,
++on_state_changed (WnckWindow *window,
++ WnckWindowState changed_mask,
++ WnckWindowState new_state,
+ TaskTitle *title)
+ {
+ TaskTitlePrivate *priv;
+
+ g_return_if_fail (TASK_IS_TITLE (title));
+- g_return_if_fail (MATEWNCK_IS_WINDOW (window));
++ g_return_if_fail (WNCK_IS_WINDOW (window));
+
+ priv = title->priv;
+ if (priv->window != window)
+ return;
+
+- if (matewnck_window_is_maximized (window))
++ if (wnck_window_is_maximized (window))
+ {
+ gtk_widget_set_state (GTK_WIDGET (title), GTK_STATE_ACTIVE);
+ gtk_widget_show (priv->box);
+@@ -212,35 +212,35 @@ disconnect_window (TaskTitle *title)
+ }
+
+ static void
+-on_active_window_changed (MatewnckScreen *screen,
+- MatewnckWindow *old_window,
++on_active_window_changed (WnckScreen *screen,
++ WnckWindow *old_window,
+ TaskTitle *title)
+ {
+ TaskTitlePrivate *priv;
+- MatewnckWindow *act_window;
+- MatewnckWindowType type = MATEWNCK_WINDOW_NORMAL;
++ WnckWindow *act_window;
++ WnckWindowType type = WNCK_WINDOW_NORMAL;
+
+ g_return_if_fail (TASK_IS_TITLE (title));
+ priv = title->priv;
+
+- act_window = matewnck_screen_get_active_window (screen);
++ act_window = wnck_screen_get_active_window (screen);
+ if (act_window)
+- type = matewnck_window_get_window_type (act_window);
++ type = wnck_window_get_window_type (act_window);
+
+- if (MATEWNCK_IS_WINDOW (act_window)
+- && matewnck_window_is_skip_tasklist (act_window)
+- && type != MATEWNCK_WINDOW_DESKTOP)
++ if (WNCK_IS_WINDOW (act_window)
++ && wnck_window_is_skip_tasklist (act_window)
++ && type != WNCK_WINDOW_DESKTOP)
+ return;
+
+- if (type == MATEWNCK_WINDOW_DOCK
+- || type == MATEWNCK_WINDOW_SPLASHSCREEN
+- || type == MATEWNCK_WINDOW_MENU)
++ if (type == WNCK_WINDOW_DOCK
++ || type == WNCK_WINDOW_SPLASHSCREEN
++ || type == WNCK_WINDOW_MENU)
+ return;
+
+ disconnect_window (title);
+
+- if (!MATEWNCK_IS_WINDOW (act_window)
+- || matewnck_window_get_window_type (act_window) == MATEWNCK_WINDOW_DESKTOP)
++ if (!WNCK_IS_WINDOW (act_window)
++ || wnck_window_get_window_type (act_window) == WNCK_WINDOW_DESKTOP)
+ {
+ if (priv->show_home_title)
+ {
+@@ -264,12 +264,12 @@ on_active_window_changed (MatewnckScreen
+ else
+ {
+ gtk_label_set_text (GTK_LABEL (priv->label),
+- matewnck_window_get_name (act_window));
++ wnck_window_get_name (act_window));
+ gtk_image_set_from_stock (GTK_IMAGE (priv->button_image),
+ GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU);
+
+ gtk_widget_set_tooltip_text (GTK_WIDGET (title),
+- matewnck_window_get_name (act_window));
++ wnck_window_get_name (act_window));
+ gtk_widget_set_tooltip_text (priv->button, _("Close window"));
+
+ g_signal_connect (act_window, "name-changed",
+@@ -282,14 +282,14 @@ on_active_window_changed (MatewnckScreen
+ priv->window = act_window;
+ }
+
+- if (MATEWNCK_IS_WINDOW (act_window)
+- && !matewnck_window_is_maximized (act_window)
+- && (priv->show_home_title ? type != MATEWNCK_WINDOW_DESKTOP : 1))
++ if (WNCK_IS_WINDOW (act_window)
++ && !wnck_window_is_maximized (act_window)
++ && (priv->show_home_title ? type != WNCK_WINDOW_DESKTOP : 1))
+ {
+ gtk_widget_set_state (GTK_WIDGET (title), GTK_STATE_NORMAL);
+ gtk_widget_hide (priv->box);
+ }
+- else if (!MATEWNCK_IS_WINDOW (act_window))
++ else if (!WNCK_IS_WINDOW (act_window))
+ {
+ if (task_list_get_desktop_visible (TASK_LIST (task_list_get_default ()))
+ && priv->show_home_title)
+@@ -322,21 +322,21 @@ static gboolean
+ on_button_release (GtkWidget *title, GdkEventButton *event)
+ {
+ TaskTitlePrivate *priv;
+- MatewnckWindow *window;
++ WnckWindow *window;
+ GtkWidget *menu;
+
+ g_return_val_if_fail (TASK_IS_TITLE (title), FALSE);
+ priv = TASK_TITLE_GET_PRIVATE (title);
+
+- window = matewnck_screen_get_active_window (priv->screen);
++ window = wnck_screen_get_active_window (priv->screen);
+
+- g_return_val_if_fail (MATEWNCK_IS_WINDOW (window), FALSE);
++ g_return_val_if_fail (WNCK_IS_WINDOW (window), FALSE);
+
+ if (event->button == 3)
+ {
+- if (matewnck_window_get_window_type (window) != MATEWNCK_WINDOW_DESKTOP)
++ if (wnck_window_get_window_type (window) != WNCK_WINDOW_DESKTOP)
+ {
+- menu = matewnck_action_menu_new (window);
++ menu = wnck_action_menu_new (window);
+ gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL,
+ event->button, event->time);
+ return TRUE;
+@@ -344,9 +344,9 @@ on_button_release (GtkWidget *title, Gdk
+ }
+ else if (event->button == 1)
+ {
+- if (event->type == GDK_2BUTTON_PRESS && matewnck_window_is_maximized (window))
++ if (event->type == GDK_2BUTTON_PRESS && wnck_window_is_maximized (window))
+ {
+- matewnck_window_unmaximize (window);
++ wnck_window_unmaximize (window);
+ }
+ }
+
+@@ -411,7 +411,7 @@ task_title_init (TaskTitle *title)
+
+ priv = title->priv = TASK_TITLE_GET_PRIVATE (title);
+
+- priv->screen = matewnck_screen_get_default ();
++ priv->screen = wnck_screen_get_default ();
+ priv->window = NULL;
+
+ /* FIXME we can add an option for this in future */
+--- mate-netbook-1.6.0/maximus/maximus-app.h.orig 2013-04-01 16:05:35.000000000 +0200
++++ mate-netbook-1.6.0/maximus/maximus-app.h 2014-01-01 14:32:02.282752921 +0100
+@@ -22,7 +22,6 @@
+
+ #include <glib-object.h>
+ #include <gtk/gtk.h>
+-#include <libmatewnck/libmatewnck.h>
+
+ #define MAXIMUS_TYPE_APP (maximus_app_get_type ())
+
+--- mate-netbook-1.6.0/maximus/maximus-bind.c.orig 2013-04-01 16:05:35.000000000 +0200
++++ mate-netbook-1.6.0/maximus/maximus-bind.c 2014-01-01 14:34:33.399413246 +0100
+@@ -27,7 +27,8 @@
+
+ #include <gio/gio.h>
+
+-#include <libmatewnck/libmatewnck.h>
++#define WNCK_I_KNOW_THIS_IS_UNSTABLE
++#include <libwnck/libwnck.h>
+
+ #include <X11/Xlib.h>
+ #include <X11/Xresource.h>
+@@ -67,7 +67,7 @@ G_DEFINE_TYPE (MaximusBind, maximus_bind
+ struct _MaximusBindPrivate
+ {
+ FakeKey *fk;
+- MatewnckScreen *screen;
++ WnckScreen *screen;
+ GSettings *settings;
+
+ gchar *binding;
+@@ -83,16 +83,16 @@ typedef struct
+ } MaximusRule;
+
+ static const gchar *
+-get_fullscreen_keystroke (GList *rules, MatewnckWindow *window)
++get_fullscreen_keystroke (GList *rules, WnckWindow *window)
+ {
+- MatewnckClassGroup *group;
++ WnckClassGroup *group;
+ const gchar *class_name;
+ GList *r;
+
+- group = matewnck_window_get_class_group (window);
+- class_name = matewnck_class_group_get_name (group);
++ group = wnck_window_get_class_group (window);
++ class_name = wnck_class_group_get_name (group);
+
+- g_debug ("Searching rules for %s:\n", matewnck_window_get_name (window));
++ g_debug ("Searching rules for %s:\n", wnck_window_get_name (window));
+
+ for (r = rules; r; r = r->next)
+ {
+@@ -112,14 +112,14 @@ get_fullscreen_keystroke (GList *rules,
+ }
+
+ static const gchar *
+-get_unfullscreen_keystroke (GList *rules, MatewnckWindow *window)
++get_unfullscreen_keystroke (GList *rules, WnckWindow *window)
+ {
+- MatewnckClassGroup *group;
++ WnckClassGroup *group;
+ const gchar *class_name;
+ GList *r;
+
+- group = matewnck_window_get_class_group (window);
+- class_name = matewnck_class_group_get_name (group);
++ group = wnck_window_get_class_group (window);
++ class_name = wnck_class_group_get_name (group);
+
+ for (r = rules; r; r = r->next)
+ {
+@@ -138,16 +138,16 @@ real_fullscreen (MaximusBind *bind)
+ {
+ MaximusBindPrivate *priv;
+ GdkDisplay UNUSED_VARIABLE *display;
+- MatewnckWindow *active;
++ WnckWindow *active;
+ const gchar *keystroke;
+
+ priv = bind->priv;
+
+ display = gdk_display_get_default ();
+- active = matewnck_screen_get_active_window (priv->screen);
++ active = wnck_screen_get_active_window (priv->screen);
+
+- if (!MATEWNCK_IS_WINDOW (active)
+- || matewnck_window_get_window_type (active) != MATEWNCK_WINDOW_NORMAL)
++ if (!WNCK_IS_WINDOW (active)
++ || wnck_window_get_window_type (active) != WNCK_WINDOW_NORMAL)
+ return FALSE;
+
+ keystroke = get_fullscreen_keystroke (priv->rules, active);
+@@ -179,7 +179,7 @@ real_fullscreen (MaximusBind *bind)
+ }
+ }
+
+- if (!matewnck_window_is_fullscreen (active))
++ if (!wnck_window_is_fullscreen (active))
+ {
+ g_debug ("Sending fullscreen F11 event");
+ fakekey_press_keysym (priv->fk, XK_F11, 0);
+@@ -188,17 +188,17 @@ real_fullscreen (MaximusBind *bind)
+
+ sleep (STATE_CHANGED_SLEEP);
+
+- if (!matewnck_window_is_fullscreen (active))
++ if (!wnck_window_is_fullscreen (active))
+ {
+- g_debug ("Forcing fullscreen matewnck event");
+- matewnck_window_set_fullscreen (active, TRUE);
++ g_debug ("Forcing fullscreen wnck event");
++ wnck_window_set_fullscreen (active, TRUE);
+ }
+
+ return FALSE;
+ }
+
+ static void
+-fullscreen (MaximusBind *bind, MatewnckWindow *window)
++fullscreen (MaximusBind *bind, WnckWindow *window)
+ {
+ MaximusBindPrivate UNUSED_VARIABLE *priv;
+
+@@ -212,16 +212,16 @@ real_unfullscreen (MaximusBind *bind)
+ {
+ MaximusBindPrivate *priv;
+ GdkDisplay UNUSED_VARIABLE *display;
+- MatewnckWindow *active;
++ WnckWindow *active;
+ const gchar *keystroke;
+
+ priv = bind->priv;
+
+ display = gdk_display_get_default ();
+- active = matewnck_screen_get_active_window (priv->screen);
++ active = wnck_screen_get_active_window (priv->screen);
+
+- if (!MATEWNCK_IS_WINDOW (active)
+- || matewnck_window_get_window_type (active) != MATEWNCK_WINDOW_NORMAL)
++ if (!WNCK_IS_WINDOW (active)
++ || wnck_window_get_window_type (active) != WNCK_WINDOW_NORMAL)
+ return FALSE;
+
+ keystroke = get_unfullscreen_keystroke (priv->rules, active);
+@@ -252,7 +252,7 @@ real_unfullscreen (MaximusBind *bind)
+ return FALSE;
+ }
+ }
+- if (matewnck_window_is_fullscreen (active))
++ if (wnck_window_is_fullscreen (active))
+ {
+ g_debug ("Sending un-fullscreen F11 event");
+ fakekey_press_keysym (priv->fk, XK_F11, 0);
+@@ -261,17 +261,17 @@ real_unfullscreen (MaximusBind *bind)
+
+ sleep (STATE_CHANGED_SLEEP);
+
+- if (matewnck_window_is_fullscreen (active))
++ if (wnck_window_is_fullscreen (active))
+ {
+- g_debug ("Forcing un-fullscreen matewnck event");
+- matewnck_window_set_fullscreen (active, FALSE);
++ g_debug ("Forcing un-fullscreen wnck event");
++ wnck_window_set_fullscreen (active, FALSE);
+ }
+
+ return FALSE;
+ }
+
+ static void
+-unfullscreen (MaximusBind *bind, MatewnckWindow *window)
++unfullscreen (MaximusBind *bind, WnckWindow *window)
+ {
+ MaximusBindPrivate UNUSED_VARIABLE *priv;
+
+@@ -285,17 +285,17 @@ static void
+ on_binding_activated (gchar *keystring, MaximusBind *bind)
+ {
+ MaximusBindPrivate *priv;
+- MatewnckWindow *active;
++ WnckWindow *active;
+
+ g_return_if_fail (MAXIMUS_IS_BIND (bind));
+ priv = bind->priv;
+
+- active = matewnck_screen_get_active_window (priv->screen);
++ active = wnck_screen_get_active_window (priv->screen);
+
+- if (matewnck_window_get_window_type (active) != MATEWNCK_WINDOW_NORMAL)
++ if (wnck_window_get_window_type (active) != WNCK_WINDOW_NORMAL)
+ return;
+
+- if (matewnck_window_is_fullscreen (active))
++ if (wnck_window_is_fullscreen (active))
+ {
+ unfullscreen (bind, active);
+ }
+@@ -462,12 +462,12 @@ maximus_bind_init (MaximusBind *bind)
+ {
+ MaximusBindPrivate *priv;
+ GdkDisplay *display = gdk_display_get_default ();
+- MatewnckScreen *screen;
++ WnckScreen *screen;
+
+ priv = bind->priv = MAXIMUS_BIND_GET_PRIVATE (bind);
+
+ priv->fk = fakekey_init (GDK_DISPLAY_XDISPLAY (display));
+- priv->screen = screen = matewnck_screen_get_default ();
++ priv->screen = screen = wnck_screen_get_default ();
+ priv->rules = NULL;
+ priv->settings = g_settings_new (BIND_SCHEMA);
+
+--- mate-netbook-1.6.0/maximus/xutils.c.orig 2013-04-01 16:05:35.000000000 +0200
++++ mate-netbook-1.6.0/maximus/xutils.c 2014-01-01 14:31:37.276087304 +0100
+@@ -25,7 +25,8 @@
+ #include "xutils.h"
+ #include <string.h>
+ #include <stdio.h>
+-#include <libmatewnck/libmatewnck.h>
++#define WNCK_I_KNOW_THIS_IS_UNSTABLE
++#include <libwnck/libwnck.h>
+
+ #ifdef __GNUC__
+ #define UNUSED_VARIABLE __attribute__ ((unused))
+--- mate-netbook-1.6.0/maximus/maximus-app.c.orig 2013-04-01 16:05:35.000000000 +0200
++++ mate-netbook-1.6.0/maximus/maximus-app.c 2014-01-01 14:57:29.662688823 +0100
+@@ -25,6 +25,9 @@
+ #include <gdk/gdkx.h>
+ #include <gio/gio.h>
+
++#define WNCK_I_KNOW_THIS_IS_UNSTABLE
++#include <libwnck/libwnck.h>
++
+ #include "maximus-app.h"
+ #include "maximus-bind.h"
+ #include "xutils.h"
+@@ -71,7 +74,7 @@ static gchar *default_exclude_classes[]
+ struct _MaximusAppPrivate
+ {
+ MaximusBind *bind;
+- MatewnckScreen *screen;
++ WnckScreen *screen;
+ GSettings *settings;
+
+ gchar **exclude_class_list;
+@@ -95,7 +98,7 @@ typedef struct {
+ #define _XA_MOTIF_WM_HINTS "_MOTIF_WM_HINTS"
+
+ static gboolean
+-matewnck_window_is_decorated (MatewnckWindow *window)
++matewnck_window_is_decorated (WnckWindow *window)
+ {
+ GdkDisplay *display = gdk_display_get_default();
+ Atom hints_atom = None;
+@@ -107,13 +110,13 @@ matewnck_window_is_decorated (MatewnckWi
+ gulong bytes_after;
+ gboolean retval;
+
+- g_return_val_if_fail (MATEWNCK_IS_WINDOW (window), FALSE);
++ g_return_val_if_fail (WNCK_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),
++ wnck_window_get_xid (window),
+ hints_atom, 0, sizeof (MotifWmHints)/sizeof (long),
+ False, AnyPropertyType, &type, &format, &nitems,
+ &bytes_after, &data);
+@@ -131,7 +134,7 @@ matewnck_window_is_decorated (MatewnckWi
+ }
+
+ static void
+-gdk_window_set_mwm_hints (MatewnckWindow *window,
++gdk_window_set_mwm_hints (WnckWindow *window,
+ MotifWmHints *new_hints)
+ {
+ GdkDisplay *display = gdk_display_get_default();
+@@ -143,14 +146,14 @@ gdk_window_set_mwm_hints (MatewnckWindow
+ gulong nitems;
+ gulong bytes_after;
+
+- g_return_if_fail (MATEWNCK_IS_WINDOW (window));
++ g_return_if_fail (WNCK_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),
++ wnck_window_get_xid (window),
+ hints_atom, 0, sizeof (MotifWmHints)/sizeof (long),
+ False, AnyPropertyType, &type, &format, &nitems,
+ &bytes_after, &data);
+@@ -175,7 +178,7 @@ gdk_window_set_mwm_hints (MatewnckWindow
+
+ _matewnck_error_trap_push ();
+ XChangeProperty (GDK_DISPLAY_XDISPLAY (display),
+- matewnck_window_get_xid (window),
++ wnck_window_get_xid (window),
+ hints_atom, hints_atom, 32, PropModeReplace,
+ (guchar *)hints, sizeof (MotifWmHints)/sizeof (long));
+ gdk_flush ();
+@@ -186,12 +189,12 @@ gdk_window_set_mwm_hints (MatewnckWindow
+ }
+
+ static void
+-_window_set_decorations (MatewnckWindow *window,
++_window_set_decorations (WnckWindow *window,
+ GdkWMDecoration decorations)
+ {
+ MotifWmHints *hints;
+
+- g_return_if_fail (MATEWNCK_IS_WINDOW (window));
++ g_return_if_fail (WNCK_IS_WINDOW (window));
+
+ /* initialize to zero to avoid writing uninitialized data to socket */
+ hints = g_slice_new0 (MotifWmHints);
+@@ -206,17 +209,17 @@ _window_set_decorations (MatewnckWindow
+ /* </TAKEN FROM GDK> */
+
+ gboolean
+-window_is_too_large_for_screen (MatewnckWindow *window)
++window_is_too_large_for_screen (WnckWindow *window)
+ {
+ static GdkScreen *screen = NULL;
+ gint x=0, y=0, w=0, h=0;
+
+- g_return_val_if_fail (MATEWNCK_IS_WINDOW (window), FALSE);
++ g_return_val_if_fail (WNCK_IS_WINDOW (window), FALSE);
+
+ if (screen == NULL)
+ screen = gdk_screen_get_default ();
+
+- matewnck_window_get_geometry (window, &x, &y, &w, &h);
++ wnck_window_get_geometry (window, &x, &y, &w, &h);
+
+ /* some wiggle room */
+ return (screen &&
+@@ -225,14 +228,14 @@ window_is_too_large_for_screen (Matewnck
+ }
+
+ static gboolean
+-on_window_maximised_changed (MatewnckWindow *window)
++on_window_maximised_changed (WnckWindow *window)
+ {
+- g_return_val_if_fail (MATEWNCK_IS_WINDOW (window), FALSE);
++ g_return_val_if_fail (WNCK_IS_WINDOW (window), FALSE);
+
+ if (window_is_too_large_for_screen (window))
+ {
+ _window_set_decorations (window, 1);
+- matewnck_window_unmaximize (window);
++ wnck_window_unmaximize (window);
+ }
+ else
+ {
+@@ -242,29 +245,29 @@ on_window_maximised_changed (MatewnckWin
+ }
+
+ static gboolean
+-enable_window_decorations (MatewnckWindow *window)
++enable_window_decorations (WnckWindow *window)
+ {
+- g_return_val_if_fail (MATEWNCK_IS_WINDOW (window), FALSE);
++ g_return_val_if_fail (WNCK_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,
++on_window_state_changed (WnckWindow *window,
++ WnckWindowState change_mask,
++ WnckWindowState new_state,
+ MaximusApp *app)
+ {
+- g_return_if_fail (MATEWNCK_IS_WINDOW (window));
++ g_return_if_fail (WNCK_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 (change_mask & WNCK_WINDOW_STATE_MAXIMIZED_HORIZONTALLY
++ || change_mask & WNCK_WINDOW_STATE_MAXIMIZED_VERTICALLY)
+ {
+- if (matewnck_window_is_maximized (window) && app->priv->undecorate)
++ if (wnck_window_is_maximized (window) && app->priv->undecorate)
+ {
+ g_idle_add ((GSourceFunc)on_window_maximised_changed, window);
+ }
+@@ -276,44 +279,44 @@ on_window_state_changed (MatewnckWindow
+ }
+
+ static gboolean
+-is_excluded (MaximusApp *app, MatewnckWindow *window)
++is_excluded (MaximusApp *app, WnckWindow *window)
+ {
+ MaximusAppPrivate *priv;
+- MatewnckWindowType type;
+- MatewnckWindowActions actions;
++ WnckWindowType type;
++ WnckWindowActions actions;
+ gchar *res_name;
+ gchar *class_name;
+ gint i;
+
+ g_return_val_if_fail (MAXIMUS_IS_APP (app), TRUE);
+- g_return_val_if_fail (MATEWNCK_IS_WINDOW (window), TRUE);
++ g_return_val_if_fail (WNCK_IS_WINDOW (window), TRUE);
+ priv = app->priv;
+
+- type = matewnck_window_get_window_type (window);
+- if (type != MATEWNCK_WINDOW_NORMAL)
++ type = wnck_window_get_window_type (window);
++ if (type != WNCK_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))
++ if (wnck_window_is_fullscreen (window))
+ {
+- g_debug ("Excluding (is fullscreen): %s\n",matewnck_window_get_name (window));
++ g_debug ("Excluding (is fullscreen): %s\n",wnck_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)
++ actions = wnck_window_get_actions (window);
++ if (actions & WNCK_WINDOW_ACTION_RESIZE
++ && actions & WNCK_WINDOW_ACTION_MAXIMIZE_HORIZONTALLY
++ && actions & WNCK_WINDOW_ACTION_MAXIMIZE_VERTICALLY
++ && actions & WNCK_WINDOW_ACTION_MAXIMIZE)
+ ; /* Is good to maximise */
+ else
+ return TRUE;
+
+- _matewnck_get_wmclass (matewnck_window_get_xid (window), &res_name, &class_name);
++ _matewnck_get_wmclass (wnck_window_get_xid (window), &res_name, &class_name);
+
+ g_debug ("Window opened: res_name=%s -- class_name=%s", res_name, class_name);
+
+@@ -325,7 +328,7 @@ is_excluded (MaximusApp *app, MatewnckWi
+ || (res_name && default_exclude_classes[i] && strstr (res_name,
+ default_exclude_classes[i])))
+ {
+- g_debug ("Excluding: %s\n", matewnck_window_get_name (window));
++ g_debug ("Excluding: %s\n", wnck_window_get_name (window));
+ return TRUE;
+ }
+ }
+@@ -336,7 +339,7 @@ is_excluded (MaximusApp *app, MatewnckWi
+ if ((class_name && strstr (class_name, priv->exclude_class_list[i]))
+ || (res_name && strstr (res_name, priv->exclude_class_list[i]) ))
+ {
+- g_debug ("Excluding: %s\n", matewnck_window_get_name (window));
++ g_debug ("Excluding: %s\n", wnck_window_get_name (window));
+ return TRUE;
+ }
+ }
+@@ -349,25 +352,25 @@ is_excluded (MaximusApp *app, MatewnckWi
+ extern gboolean no_maximize;
+
+ static void
+-on_window_opened (MatewnckScreen *screen,
+- MatewnckWindow *window,
++on_window_opened (WnckScreen *screen,
++ WnckWindow *window,
+ MaximusApp *app)
+ {
+ MaximusAppPrivate *priv;
+- MatewnckWindowType type;
++ WnckWindowType type;
+ gint exclude = 0;
+
+ g_return_if_fail (MAXIMUS_IS_APP (app));
+- g_return_if_fail (MATEWNCK_IS_WINDOW (window));
++ g_return_if_fail (WNCK_IS_WINDOW (window));
+ priv = app->priv;
+
+- type = matewnck_window_get_window_type (window);
+- if (type != MATEWNCK_WINDOW_NORMAL)
++ type = wnck_window_get_window_type (window);
++ if (type != WNCK_WINDOW_NORMAL)
+ return;
+
+ /* Ignore undecorated windows */
+ exclude = matewnck_window_is_decorated (window) ? 0 : 1;
+- if (matewnck_window_is_maximized (window))
++ if (wnck_window_is_maximized (window))
+ exclude = 0;
+ g_object_set_data (G_OBJECT (window), "exclude", GINT_TO_POINTER (exclude));
+
+@@ -380,7 +383,7 @@ on_window_opened (MatewnckScreen *scree
+
+ if (no_maximize || priv->no_maximize)
+ {
+- if (matewnck_window_is_maximized(window))
++ if (wnck_window_is_maximized(window))
+ {
+ _window_set_decorations (window, 0);
+ gdk_flush ();
+@@ -400,7 +403,7 @@ on_window_opened (MatewnckScreen *scree
+ }
+ }
+
+- matewnck_window_maximize (window);
++ wnck_window_maximize (window);
+
+ g_signal_connect (window, "state-changed",
+ G_CALLBACK (on_window_state_changed), app);
+@@ -437,11 +440,11 @@ on_exclude_class_changed (GSettings *set
+ }
+
+ static gboolean
+-show_desktop (MatewnckScreen *screen)
++show_desktop (WnckScreen *screen)
+ {
+- g_return_val_if_fail (MATEWNCK_IS_SCREEN (screen), FALSE);
++ g_return_val_if_fail (WNCK_IS_SCREEN (screen), FALSE);
+
+- matewnck_screen_toggle_showing_desktop (screen, TRUE);
++ wnck_screen_toggle_showing_desktop (screen, TRUE);
+ return FALSE;
+ }
+
+@@ -455,22 +458,22 @@ on_app_undecorate_changed (GSettings
+
+ g_return_if_fail (MAXIMUS_IS_APP (app));
+ priv = app->priv;
+- g_return_if_fail (MATEWNCK_IS_SCREEN (priv->screen));
++ g_return_if_fail (WNCK_IS_SCREEN (priv->screen));
+
+ priv->undecorate = g_settings_get_boolean (settings, APP_UNDECORATE);
+ g_debug ("%s\n", priv->undecorate ? "Undecorating" : "Decorating");
+
+- windows = matewnck_screen_get_windows (priv->screen);
++ windows = wnck_screen_get_windows (priv->screen);
+ for (w = windows; w; w = w->next)
+ {
+- MatewnckWindow *window = w->data;
++ WnckWindow *window = w->data;
+
+- if (!MATEWNCK_IS_WINDOW (window))
++ if (!WNCK_IS_WINDOW (window))
+ continue;
+
+ if (no_maximize || priv->no_maximize)
+ {
+- if (!matewnck_window_is_maximized(window))
++ if (!wnck_window_is_maximized(window))
+ continue;
+ }
+
+@@ -478,8 +481,8 @@ on_app_undecorate_changed (GSettings
+ {
+ gdk_error_trap_push ();
+ _window_set_decorations (window, priv->undecorate ? 0 : 1);
+- matewnck_window_unmaximize (window);
+- matewnck_window_maximize (window);
++ wnck_window_unmaximize (window);
++ wnck_window_maximize (window);
+ gdk_flush ();
+ gdk_error_trap_pop ();
+
+@@ -504,7 +507,7 @@ static void
+ maximus_app_init (MaximusApp *app)
+ {
+ MaximusAppPrivate *priv;
+- MatewnckScreen *screen;
++ WnckScreen *screen;
+
+ priv = app->priv = MAXIMUS_APP_GET_PRIVATE (app);
+
+@@ -523,7 +526,7 @@ maximus_app_init (MaximusApp *app)
+ G_CALLBACK (on_app_undecorate_changed), app);
+
+
+- priv->screen = screen = matewnck_screen_get_default ();
++ priv->screen = screen = wnck_screen_get_default ();
+ g_signal_connect (screen, "window-opened",
+ G_CALLBACK (on_window_opened), app);
+
+--- mate-netbook-1.6.0/mate-window-picker-applet/task-item.h.orig 2013-04-01 16:05:35.000000000 +0200
++++ mate-netbook-1.6.0/mate-window-picker-applet/task-item.h 2014-01-01 14:58:56.632685173 +0100
+@@ -23,7 +23,8 @@
+
+ #include <glib.h>
+ #include <gtk/gtk.h>
+-#include <libmatewnck/libmatewnck.h>
++#define WNCK_I_KNOW_THIS_IS_UNSTABLE
++#include <libwnck/libwnck.h>
+
+ #define TASK_TYPE_ITEM (task_item_get_type ())
+
+@@ -62,7 +63,7 @@ struct _TaskItemClass
+
+ GType task_item_get_type (void) G_GNUC_CONST;
+
+-GtkWidget * task_item_new (MatewnckWindow *window);
++GtkWidget * task_item_new (WnckWindow *window);
+
+ GtkWidget * task_item_get_default (void);
+
================================================================
---- gitweb:
http://git.pld-linux.org/gitweb.cgi/packages/mate-netbook.git/commitdiff/c5ee8a66af2e8e0600217398b9195369d4bff401
More information about the pld-cvs-commit
mailing list