mate-netbook-use-libwnck.patch

   1 --- mate-netbook-1.6.0/configure.ac.orig        2013-04-01 16:05:35.000000000 +0200
   2 +++ mate-netbook-1.6.0/configure.ac     2014-01-01 14:29:05.696093665 +0100
   3 @@ -34,7 +34,7 @@
   4  PKG_CHECK_MODULES(MAXIMUS_DEPS,
   5                    gtk+-2.0
   6                    gio-2.0
   7 -                  libmatewnck
   8 +                  libwnck-1.0
   9                    xtst
  10                    libfakekey
  11                    unique-1.0
  12 @@ -47,7 +47,7 @@
  13                    gtk+-2.0
  14                    glib-2.0
  15                    gio-2.0
  16 -                  libmatewnck
  17 +                  libwnck-1.0
  18                    )
  19  AC_SUBST(MATEWINDOWPICKER_DEPS_CFLAGS)
  20  AC_SUBST(MATEWINDOWPICKER_DEPS_LIBS)
  21 --- mate-netbook-1.6.0/mate-window-picker-applet/applet.c.orig  2014-01-01 14:42:12.359393985 +0100
  22 +++ mate-netbook-1.6.0/mate-window-picker-applet/applet.c       2014-01-01 14:42:24.176060156 +0100
  23 @@ -28,7 +28,8 @@
  24  #include <glib/gi18n.h>
  25  #include <gtk/gtk.h>
  26
  27 -#include <libmatewnck/libmatewnck.h>
  28 +#define WNCK_I_KNOW_THIS_IS_UNSTABLE
  29 +#include <libwnck/libwnck.h>
  30
  31  #include <gio/gio.h>
  32  #include <mate-panel-applet.h>
  33 @@ -138,7 +138,7 @@ cw_applet_fill (MatePanelApplet *applet,
  34                  const gchar *iid,
  35                  gpointer     data)
  36  {
  37 -  MatewnckScreen *screen;
  38 +  WnckScreen *screen;
  39    WinPickerApp *app;
  40    GtkWidget *eb, *tasks, *title;
  41    gchar *ui_path;
  42 @@ -152,11 +152,11 @@ cw_applet_fill (MatePanelApplet *applet,
  43    bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
  44    textdomain (GETTEXT_PACKAGE);
  45
  46 -  matewnck_set_client_type (MATEWNCK_CLIENT_TYPE_PAGER);
  47 +  wnck_set_client_type (WNCK_CLIENT_TYPE_PAGER);
  48
  49    app = g_slice_new0 (WinPickerApp);
  50    mainapp = app;
  51 -  screen = matewnck_screen_get_default ();
  52 +  screen = wnck_screen_get_default ();
  53
  54    /* prepare to disable Maximus */
  55    object_class = G_OBJECT_GET_CLASS (G_OBJECT(applet));
  56 --- mate-netbook-1.6.1/mate-window-picker-applet/task-item.c.orig       2014-01-01 19:27:09.000000000 +0100
  57 +++ mate-netbook-1.6.1/mate-window-picker-applet/task-item.c    2014-01-02 20:04:54.174955583 +0100
  58 @@ -35,8 +35,8 @@ G_DEFINE_TYPE (TaskItem, task_item, GTK_
  59
  60  struct _TaskItemPrivate
  61  {
  62 -  MatewnckWindow   *window;
  63 -  MatewnckScreen   *screen;
  64 +  WnckWindow   *window;
  65 +  WnckScreen   *screen;
  66    GdkPixbuf    *pixbuf;
  67    GdkRectangle area;
  68
  69 @@ -66,13 +66,13 @@ update_hints (TaskItem *item)
  70  {
  71    GtkWidget *parent;
  72    GtkWidget *widget;
  73 -  MatewnckWindow *window;
  74 +  WnckWindow *window;
  75    gint x, y, x1, y1;
  76
  77    widget = GTK_WIDGET (item);
  78    window = item->priv->window;
  79    /* Skip problems */
  80 -  if (!MATEWNCK_IS_WINDOW (window)) return;
  81 +  if (!WNCK_IS_WINDOW (window)) return;
  82    if (!GTK_IS_WIDGET (widget)) return;
  83
  84    /* Skip invisible windows */
  85 @@ -99,7 +99,7 @@ update_hints (TaskItem *item)
  86    }
  87
  88    /* Set the minimize hint for the window */
  89 -  matewnck_window_set_icon_geometry (window, x, y,
  90 +  wnck_window_set_icon_geometry (window, x, y,
  91                                   widget->allocation.width,
  92                                   widget->allocation.height);
  93  }
  94 @@ -109,9 +109,9 @@ on_task_item_button_released (GtkWidget
  95                                GdkEventButton *event,
  96                                TaskItem       *item)
  97  {
  98 -  MatewnckWindow *window;
  99 -  MatewnckScreen *screen;
 100 -  MatewnckWorkspace *workspace;
 101 +  WnckWindow *window;
 102 +  WnckScreen *screen;
 103 +  WnckWorkspace *workspace;
 104    TaskItemPrivate *priv;
 105
 106    g_return_val_if_fail (TASK_IS_ITEM (item), TRUE);
 107 @@ -119,25 +119,25 @@ on_task_item_button_released (GtkWidget
 108    priv = item->priv;
 109    window = priv->window;
 110
 111 -  g_return_val_if_fail (MATEWNCK_IS_WINDOW (window), TRUE);
 112 +  g_return_val_if_fail (WNCK_IS_WINDOW (window), TRUE);
 113
 114    screen = priv->screen;
 115 -  workspace = matewnck_window_get_workspace (window);
 116 +  workspace = wnck_window_get_workspace (window);
 117
 118    if (event->button == 1)
 119    {
 120
 121 -    if (MATEWNCK_IS_WORKSPACE (workspace) && workspace != matewnck_screen_get_active_workspace (screen))
 122 +    if (WNCK_IS_WORKSPACE (workspace) && workspace != wnck_screen_get_active_workspace (screen))
 123      {
 124 -      matewnck_workspace_activate (workspace, GDK_CURRENT_TIME);
 125 +      wnck_workspace_activate (workspace, GDK_CURRENT_TIME);
 126      }
 127 -    if (matewnck_window_is_active (window))
 128 +    if (wnck_window_is_active (window))
 129      {
 130 -      matewnck_window_minimize (window);
 131 +      wnck_window_minimize (window);
 132      }
 133      else
 134      {
 135 -      matewnck_window_activate (window, GDK_CURRENT_TIME);
 136 +      wnck_window_activate (window, GDK_CURRENT_TIME);
 137      }
 138    }
 139    return TRUE;
 140 @@ -146,15 +146,15 @@ on_task_item_button_released (GtkWidget
 141  static void
 142  task_item_set_visibility (TaskItem *item)
 143  {
 144 -  MatewnckScreen *screen;
 145 -  MatewnckWindow *window;
 146 -  MatewnckWorkspace *workspace;
 147 +  WnckScreen *screen;
 148 +  WnckWindow *window;
 149 +  WnckWorkspace *workspace;
 150
 151    g_return_if_fail (TASK_IS_ITEM (item));
 152
 153    TaskItemPrivate *priv = item->priv;
 154
 155 -  if (!MATEWNCK_IS_WINDOW (priv->window))
 156 +  if (!WNCK_IS_WINDOW (priv->window))
 157    {
 158      gtk_widget_hide (GTK_WIDGET (item));
 159      return;
 160 @@ -163,20 +163,20 @@ task_item_set_visibility (TaskItem *item
 161    window = priv->window;
 162
 163    screen = priv->screen;
 164 -  workspace = matewnck_screen_get_active_workspace (screen);
 165 +  workspace = wnck_screen_get_active_workspace (screen);
 166
 167    gboolean show_all = task_list_get_show_all_windows (TASK_LIST (task_list_get_default ()));
 168    gboolean show_window = FALSE;
 169
 170 -  if (!matewnck_window_is_skip_tasklist (window))
 171 +  if (!wnck_window_is_skip_tasklist (window))
 172    {
 173 -    if (matewnck_workspace_is_virtual (workspace))
 174 +    if (wnck_workspace_is_virtual (workspace))
 175      {
 176 -      show_window = matewnck_window_is_in_viewport (window, workspace);
 177 +      show_window = wnck_window_is_in_viewport (window, workspace);
 178      }
 179      else
 180      {
 181 -      show_window = matewnck_window_is_on_workspace (window, workspace);
 182 +      show_window = wnck_window_is_on_workspace (window, workspace);
 183      }
 184      show_window = show_window || show_all;
 185    }
 186 @@ -202,16 +202,16 @@ task_item_size_request (GtkWidget      *
 187
 188  static GdkPixbuf *
 189  task_item_sized_pixbuf_for_window (TaskItem   *item,
 190 -                                   MatewnckWindow *window,
 191 +                                   WnckWindow *window,
 192                                     gint size)
 193  {
 194    GdkPixbuf *pbuf = NULL;
 195
 196 -  g_return_val_if_fail (MATEWNCK_IS_WINDOW (window), NULL);
 197 +  g_return_val_if_fail (WNCK_IS_WINDOW (window), NULL);
 198
 199 -  if (matewnck_window_has_icon_name (window))
 200 +  if (wnck_window_has_icon_name (window))
 201    {
 202 -    const gchar *icon_name = matewnck_window_get_icon_name (window);
 203 +    const gchar *icon_name = wnck_window_get_icon_name (window);
 204      GtkIconTheme *icon_theme = gtk_icon_theme_get_default ();
 205
 206      if (gtk_icon_theme_has_icon (icon_theme, icon_name))
 207 @@ -228,7 +228,7 @@ task_item_sized_pixbuf_for_window (TaskI
 208
 209    if (!pbuf)
 210    {
 211 -    pbuf = gdk_pixbuf_copy (matewnck_window_get_icon (item->priv->window));
 212 +    pbuf = gdk_pixbuf_copy (wnck_window_get_icon (item->priv->window));
 213    }
 214
 215    gint width = gdk_pixbuf_get_width (pbuf);
 216 @@ -264,7 +264,7 @@ task_item_expose_event (GtkWidget      *
 217    item = TASK_ITEM (widget);
 218    priv = item->priv;
 219
 220 -  g_return_val_if_fail (MATEWNCK_IS_WINDOW (priv->window), FALSE);
 221 +  g_return_val_if_fail (WNCK_IS_WINDOW (priv->window), FALSE);
 222
 223    area = priv->area;
 224    cr = gdk_cairo_create (event->window);
 225 @@ -273,8 +273,8 @@ task_item_expose_event (GtkWidget      *
 226    desat = NULL;
 227
 228    gint size = MIN (area.height, area.width);
 229 -  gboolean active = matewnck_window_is_active (priv->window);
 230 -  gboolean attention = matewnck_window_or_transient_needs_attention (priv->window);
 231 +  gboolean active = wnck_window_is_active (priv->window);
 232 +  gboolean attention = wnck_window_or_transient_needs_attention (priv->window);
 233
 234    if (GDK_IS_PIXBUF (pbuf) &&
 235        gdk_pixbuf_get_width (pbuf) != size &&
 236 @@ -385,14 +385,14 @@ on_button_pressed (GtkWidget      *butto
 237                     GdkEventButton *event,
 238                     TaskItem       *item)
 239  {
 240 -  MatewnckWindow *window;
 241 +  WnckWindow *window;
 242    g_return_val_if_fail (TASK_IS_ITEM (item), FALSE);
 243    window = item->priv->window;
 244 -  g_return_val_if_fail (MATEWNCK_IS_WINDOW (window), FALSE);
 245 +  g_return_val_if_fail (WNCK_IS_WINDOW (window), FALSE);
 246
 247    if (event->button == 3)
 248    {
 249 -    GtkWidget *menu = matewnck_action_menu_new (window);
 250 +    GtkWidget *menu = wnck_action_menu_new (window);
 251      gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL,
 252                      event->button, event->time);
 253      return TRUE;
 254 @@ -408,11 +408,11 @@ on_query_tooltip (GtkWidget *widget,
 255                    GtkTooltip *tooltip,
 256                    TaskItem *item)
 257  {
 258 -  MatewnckWindow *window = item->priv->window;
 259 -  g_return_val_if_fail (MATEWNCK_IS_WINDOW (window), FALSE);
 260 +  WnckWindow *window = item->priv->window;
 261 +  g_return_val_if_fail (WNCK_IS_WINDOW (window), FALSE);
 262
 263 -  gtk_tooltip_set_text (tooltip, matewnck_window_get_name(window));
 264 -  gtk_tooltip_set_icon (tooltip, matewnck_window_get_icon (window));
 265 +  gtk_tooltip_set_text (tooltip, wnck_window_get_name(window));
 266 +  gtk_tooltip_set_icon (tooltip, wnck_window_get_icon (window));
 267
 268    return TRUE;
 269  }
 270 @@ -450,7 +450,7 @@ on_blink (TaskItem *item)
 271
 272    gtk_widget_queue_draw (GTK_WIDGET (item));
 273
 274 -  if (matewnck_window_or_transient_needs_attention (item->priv->window))
 275 +  if (wnck_window_or_transient_needs_attention (item->priv->window))
 276    {
 277      return TRUE;
 278    }
 279 @@ -462,17 +462,17 @@ on_blink (TaskItem *item)
 280  }
 281
 282  static void
 283 -on_window_state_changed (MatewnckWindow      *window,
 284 -                         MatewnckWindowState  changed_mask,
 285 -                         MatewnckWindowState  new_state,
 286 +on_window_state_changed (WnckWindow      *window,
 287 +                         WnckWindowState  changed_mask,
 288 +                         WnckWindowState  new_state,
 289                           TaskItem        *item)
 290  {
 291 -  g_return_if_fail (MATEWNCK_IS_WINDOW (window));
 292 +  g_return_if_fail (WNCK_IS_WINDOW (window));
 293    g_return_if_fail (TASK_IS_ITEM (item));
 294
 295    TaskItemPrivate *priv = item->priv;
 296
 297 -  if (new_state & MATEWNCK_WINDOW_STATE_URGENT && !priv->timer)
 298 +  if (new_state & WNCK_WINDOW_STATE_URGENT && !priv->timer)
 299    {
 300      priv->timer = g_timeout_add (30, (GSourceFunc)on_blink, item);
 301      g_get_current_time (&priv->urgent_time);
 302 @@ -482,14 +482,14 @@ on_window_state_changed (MatewnckWindow
 303  }
 304
 305  static void
 306 -on_window_workspace_changed (MatewnckWindow *window, TaskItem *item)
 307 +on_window_workspace_changed (WnckWindow *window, TaskItem *item)
 308  {
 309    g_return_if_fail (TASK_IS_ITEM (item));
 310
 311    task_item_set_visibility (item);
 312  }
 313
 314 -static void on_window_icon_changed (MatewnckWindow *window, TaskItem *item)
 315 +static void on_window_icon_changed (WnckWindow *window, TaskItem *item)
 316  {
 317    TaskItemPrivate *priv;
 318
 319 @@ -507,11 +507,11 @@ static void on_window_icon_changed (Mate
 320  }
 321
 322  static void
 323 -on_screen_active_window_changed (MatewnckScreen    *screen,
 324 -                                 MatewnckWindow    *old_window,
 325 +on_screen_active_window_changed (WnckScreen    *screen,
 326 +                                 WnckWindow    *old_window,
 327                                   TaskItem      *item)
 328  {
 329 -  MatewnckWindow *window;
 330 +  WnckWindow *window;
 331    TaskItemPrivate *priv;
 332
 333    g_return_if_fail (TASK_IS_ITEM (item));
 334 @@ -519,10 +519,10 @@ on_screen_active_window_changed (Matewnc
 335    priv = item->priv;
 336    window = priv->window;
 337
 338 -  g_return_if_fail (MATEWNCK_IS_WINDOW (window));
 339 +  g_return_if_fail (WNCK_IS_WINDOW (window));
 340
 341 -  if ((MATEWNCK_IS_WINDOW (old_window) && window == old_window) ||
 342 -       window == matewnck_screen_get_active_window (screen))
 343 +  if ((WNCK_IS_WINDOW (old_window) && window == old_window) ||
 344 +       window == wnck_screen_get_active_window (screen))
 345    {
 346      /* queue a draw to reflect that we are [no longer] the active window */
 347      gtk_widget_queue_draw (GTK_WIDGET (item));
 348 @@ -530,8 +530,8 @@ on_screen_active_window_changed (Matewnc
 349  }
 350
 351  static void
 352 -on_screen_active_workspace_changed (MatewnckScreen    *screen,
 353 -                                    MatewnckWorkspace *old_workspace,
 354 +on_screen_active_workspace_changed (WnckScreen    *screen,
 355 +                                    WnckWorkspace *old_workspace,
 356                                      TaskItem      *item)
 357  {
 358    g_return_if_fail (TASK_IS_ITEM (item));
 359 @@ -540,7 +540,7 @@ on_screen_active_workspace_changed (Mate
 360  }
 361
 362  static void
 363 -on_screen_active_viewport_changed (MatewnckScreen    *screen,
 364 +on_screen_active_viewport_changed (WnckScreen    *screen,
 365                                     TaskItem      *item)
 366  {
 367    g_return_if_fail (TASK_IS_ITEM (item));
 368 @@ -549,15 +549,15 @@ on_screen_active_viewport_changed (Matew
 369  }
 370
 371  static void
 372 -on_screen_window_closed (MatewnckScreen  *screen,
 373 -                         MatewnckWindow  *window,
 374 +on_screen_window_closed (WnckScreen  *screen,
 375 +                         WnckWindow  *window,
 376                           TaskItem    *item)
 377  {
 378    TaskItemPrivate *priv;
 379
 380    g_return_if_fail (TASK_IS_ITEM (item));
 381    priv = item->priv;
 382 -  g_return_if_fail (MATEWNCK_IS_WINDOW (priv->window));
 383 +  g_return_if_fail (WNCK_IS_WINDOW (priv->window));
 384
 385    if (priv->window == window)
 386    {
 387 @@ -583,17 +583,17 @@ activate_window (GtkWidget *widget)
 388
 389    priv = TASK_ITEM (widget)->priv;
 390
 391 -  g_return_val_if_fail (MATEWNCK_IS_WINDOW (priv->window), FALSE);
 392 +  g_return_val_if_fail (WNCK_IS_WINDOW (priv->window), FALSE);
 393
 394    active = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget), "drag-true"));
 395
 396    if (active)
 397    {
 398 -    MatewnckWindow *window;
 399 +    WnckWindow *window;
 400
 401      window = priv->window;
 402 -    if (MATEWNCK_IS_WINDOW (window))
 403 -      matewnck_window_activate (window, time (NULL));
 404 +    if (WNCK_IS_WINDOW (window))
 405 +      wnck_window_activate (window, time (NULL));
 406    }
 407
 408    g_object_set_data (G_OBJECT (widget), "drag-true", GINT_TO_POINTER (0));
 409 @@ -636,7 +636,7 @@ task_item_setup_atk (TaskItem *item)
 410    TaskItemPrivate *priv;
 411    GtkWidget *widget;
 412    AtkObject *atk;
 413 -  MatewnckWindow *window;
 414 +  WnckWindow *window;
 415
 416    g_return_if_fail (TASK_IS_ITEM (item));
 417
 418 @@ -644,11 +644,11 @@ task_item_setup_atk (TaskItem *item)
 419    priv = item->priv;
 420    window = priv->window;
 421
 422 -  g_return_if_fail (MATEWNCK_IS_WINDOW (window));
 423 +  g_return_if_fail (WNCK_IS_WINDOW (window));
 424
 425    atk = gtk_widget_get_accessible (widget);
 426    atk_object_set_name (atk, _("Window Task Button"));
 427 -  atk_object_set_description (atk, matewnck_window_get_name (window));
 428 +  atk_object_set_description (atk, wnck_window_get_name (window));
 429    atk_object_set_role (atk, ATK_ROLE_PUSH_BUTTON);
 430  }
 431
 432 @@ -703,14 +703,14 @@ task_item_init (TaskItem *item)
 433  }
 434
 435  GtkWidget *
 436 -task_item_new (MatewnckWindow *window)
 437 +task_item_new (WnckWindow *window)
 438  {
 439    GtkWidget *item = NULL;
 440    TaskItem *task;
 441    TaskItemPrivate *priv;
 442 -  MatewnckScreen *screen;
 443 +  WnckScreen *screen;
 444
 445 -  g_return_val_if_fail (MATEWNCK_IS_WINDOW (window), item);
 446 +  g_return_val_if_fail (WNCK_IS_WINDOW (window), item);
 447
 448    item = g_object_new (TASK_TYPE_ITEM,
 449                         "has-tooltip", TRUE,
 450 @@ -725,7 +725,7 @@ task_item_new (MatewnckWindow *window)
 451    priv = task->priv;
 452    priv->window = window;
 453
 454 -  screen = matewnck_window_get_screen (window);
 455 +  screen = wnck_window_get_screen (window);
 456    priv->screen = screen;
 457
 458    gtk_drag_dest_set (item,
 459 --- mate-netbook-1.6.1/mate-window-picker-applet/task-list.c.orig       2014-01-01 19:27:09.000000000 +0100
 460 +++ mate-netbook-1.6.1/mate-window-picker-applet/task-list.c    2014-01-02 20:12:32.018269599 +0100
 461 @@ -20,7 +20,8 @@
 462  #include "task-list.h"
 463  #include "task-item.h"
 464
 465 -#include <libmatewnck/libmatewnck.h>
 466 +#define WNCK_I_KNOW_THIS_IS_UNSTABLE
 467 +#include <libwnck/libwnck.h>
 468
 469  G_DEFINE_TYPE (TaskList, task_list, GTK_TYPE_HBOX);
 470
 471 @@ -30,7 +31,7 @@ G_DEFINE_TYPE (TaskList, task_list, GTK_
 472
 473  struct _TaskListPrivate
 474  {
 475 -  MatewnckScreen *screen;
 476 +  WnckScreen *screen;
 477    GHashTable *win_table;
 478    guint timer;
 479    guint counter;
 480 @@ -65,22 +66,22 @@ on_task_item_closed (TaskItem *item,
 481  }
 482
 483  static void
 484 -on_window_opened (MatewnckScreen *screen,
 485 -                  MatewnckWindow *window,
 486 +on_window_opened (WnckScreen *screen,
 487 +                  WnckWindow *window,
 488                    TaskList   *list)
 489  {
 490    TaskListPrivate *priv;
 491 -  MatewnckWindowType type;
 492 +  WnckWindowType type;
 493
 494    g_return_if_fail (TASK_IS_LIST (list));
 495    priv = list->priv;
 496
 497 -  type = matewnck_window_get_window_type (window);
 498 +  type = wnck_window_get_window_type (window);
 499
 500 -  if (type == MATEWNCK_WINDOW_DESKTOP
 501 -      || type == MATEWNCK_WINDOW_DOCK
 502 -      || type == MATEWNCK_WINDOW_SPLASHSCREEN
 503 -      || type == MATEWNCK_WINDOW_MENU)
 504 +  if (type == WNCK_WINDOW_DESKTOP
 505 +      || type == WNCK_WINDOW_DOCK
 506 +      || type == WNCK_WINDOW_SPLASHSCREEN
 507 +      || type == WNCK_WINDOW_MENU)
 508      return;
 509
 510    GtkWidget *item = task_item_new (window);
 511 @@ -178,7 +179,7 @@ task_list_init (TaskList *list)
 512
 513    priv = list->priv = TASK_LIST_GET_PRIVATE (list);
 514
 515 -  priv->screen = matewnck_screen_get_default ();
 516 +  priv->screen = wnck_screen_get_default ();
 517
 518    priv->win_table = g_hash_table_new (NULL, NULL);
 519
 520 @@ -224,14 +225,14 @@ task_list_get_desktop_visible (TaskList
 521
 522    g_return_val_if_fail (TASK_IS_LIST (list), TRUE);
 523
 524 -  windows = matewnck_screen_get_windows (list->priv->screen);
 525 +  windows = wnck_screen_get_windows (list->priv->screen);
 526    for (w = windows; w; w = w->next)
 527    {
 528 -    MatewnckWindow *window;
 529 +    WnckWindow *window;
 530
 531      window = w->data;
 532
 533 -    if (MATEWNCK_IS_WINDOW (window) && !matewnck_window_is_minimized (window))
 534 +    if (WNCK_IS_WINDOW (window) && !wnck_window_is_minimized (window))
 535        all_minimised = FALSE;
 536    }
 537
 538 --- mate-netbook-1.6.1/mate-window-picker-applet/task-title.c.orig      2014-01-01 19:27:09.000000000 +0100
 539 +++ mate-netbook-1.6.1/mate-window-picker-applet/task-title.c   2014-01-02 20:13:43.351600042 +0100
 540 @@ -19,7 +19,8 @@
 541
 542  #include "task-title.h"
 543
 544 -#include <libmatewnck/libmatewnck.h>
 545 +#define WNCK_I_KNOW_THIS_IS_UNSTABLE
 546 +#include <libwnck/libwnck.h>
 547  #include <mate-panel-applet.h>
 548
 549  #include "task-list.h"
 550 @@ -35,8 +36,8 @@ G_DEFINE_TYPE (TaskTitle, task_title, GT
 551
 552  struct _TaskTitlePrivate
 553  {
 554 -  MatewnckScreen *screen;
 555 -  MatewnckWindow *window;
 556 +  WnckScreen *screen;
 557 +  WnckWindow *window;
 558    GtkWidget *align;
 559    GtkWidget *box;
 560    GtkWidget *label;
 561 @@ -56,7 +57,7 @@ on_close_clicked (GtkButton *button,
 562                    TaskTitle *title)
 563  {
 564    TaskTitlePrivate *priv;
 565 -  MatewnckWindow *window;
 566 +  WnckWindow *window;
 567
 568    g_return_val_if_fail (TASK_IS_TITLE (title), FALSE);
 569    priv = title->priv;
 570 @@ -64,10 +65,10 @@ on_close_clicked (GtkButton *button,
 571    if (event->button != 1 || !priv->mouse_in_close_button)
 572      return FALSE;
 573
 574 -  window = matewnck_screen_get_active_window (priv->screen);
 575 +  window = wnck_screen_get_active_window (priv->screen);
 576
 577 -  if (!MATEWNCK_IS_WINDOW (window)
 578 -        || matewnck_window_get_window_type (window) == MATEWNCK_WINDOW_DESKTOP)
 579 +  if (!WNCK_IS_WINDOW (window)
 580 +        || wnck_window_get_window_type (window) == WNCK_WINDOW_DESKTOP)
 581    {
 582      gdk_spawn_command_line_on_screen (gdk_screen_get_default (),
 583                                        LOGOUT, NULL);
 584 @@ -76,7 +77,7 @@ on_close_clicked (GtkButton *button,
 585    {
 586      if (priv->window == window)
 587        disconnect_window (title);
 588 -    matewnck_window_close (window, GDK_CURRENT_TIME);
 589 +    wnck_window_close (window, GDK_CURRENT_TIME);
 590    }
 591    gtk_widget_queue_draw (GTK_WIDGET (title));
 592
 593 @@ -138,32 +139,32 @@ on_button_expose (GtkWidget *widget,
 594  }
 595
 596  static void
 597 -on_name_changed (MatewnckWindow *window, TaskTitle *title)
 598 +on_name_changed (WnckWindow *window, TaskTitle *title)
 599  {
 600    TaskTitlePrivate *priv;
 601
 602    g_return_if_fail (TASK_IS_TITLE (title));
 603 -  g_return_if_fail (MATEWNCK_IS_WINDOW (window));
 604 +  g_return_if_fail (WNCK_IS_WINDOW (window));
 605
 606    priv = title->priv;
 607    if (priv->window != window)
 608      return;
 609
 610    gtk_label_set_text (GTK_LABEL (title->priv->label),
 611 -                      matewnck_window_get_name (window));
 612 +                      wnck_window_get_name (window));
 613    gtk_widget_set_tooltip_text (GTK_WIDGET (title),
 614 -                               matewnck_window_get_name (window));
 615 +                               wnck_window_get_name (window));
 616    gtk_widget_queue_draw (GTK_WIDGET (title));
 617  }
 618
 619
 620  static void
 621 -on_icon_changed (MatewnckWindow *window, TaskTitle *title)
 622 +on_icon_changed (WnckWindow *window, TaskTitle *title)
 623  {
 624    TaskTitlePrivate *priv;
 625
 626    g_return_if_fail (TASK_IS_TITLE (title));
 627 -  g_return_if_fail (MATEWNCK_IS_WINDOW (window));
 628 +  g_return_if_fail (WNCK_IS_WINDOW (window));
 629
 630    priv = title->priv;
 631    if (priv->window != window)
 632 @@ -173,21 +174,21 @@ on_icon_changed (MatewnckWindow *window,
 633  }
 634
 635  static void
 636 -on_state_changed (MatewnckWindow *window,
 637 -                  MatewnckWindowState changed_mask,
 638 -                  MatewnckWindowState new_state,
 639 +on_state_changed (WnckWindow *window,
 640 +                  WnckWindowState changed_mask,
 641 +                  WnckWindowState new_state,
 642                    TaskTitle *title)
 643  {
 644    TaskTitlePrivate *priv;
 645
 646    g_return_if_fail (TASK_IS_TITLE (title));
 647 -  g_return_if_fail (MATEWNCK_IS_WINDOW (window));
 648 +  g_return_if_fail (WNCK_IS_WINDOW (window));
 649
 650    priv = title->priv;
 651    if (priv->window != window)
 652      return;
 653
 654 -  if (matewnck_window_is_maximized (window))
 655 +  if (wnck_window_is_maximized (window))
 656    {
 657      gtk_widget_set_state (GTK_WIDGET (title), GTK_STATE_ACTIVE);
 658      gtk_widget_show (priv->box);
 659 @@ -212,35 +213,35 @@ disconnect_window (TaskTitle *title)
 660  }
 661
 662  static void
 663 -on_active_window_changed (MatewnckScreen *screen,
 664 -                          MatewnckWindow *old_window,
 665 +on_active_window_changed (WnckScreen *screen,
 666 +                          WnckWindow *old_window,
 667                            TaskTitle   *title)
 668  {
 669    TaskTitlePrivate *priv;
 670 -  MatewnckWindow *act_window;
 671 -  MatewnckWindowType type = MATEWNCK_WINDOW_NORMAL;
 672 +  WnckWindow *act_window;
 673 +  WnckWindowType type = WNCK_WINDOW_NORMAL;
 674
 675    g_return_if_fail (TASK_IS_TITLE (title));
 676    priv = title->priv;
 677
 678 -  act_window = matewnck_screen_get_active_window (screen);
 679 +  act_window = wnck_screen_get_active_window (screen);
 680    if (act_window)
 681 -    type = matewnck_window_get_window_type (act_window);
 682 +    type = wnck_window_get_window_type (act_window);
 683
 684 -  if (MATEWNCK_IS_WINDOW (act_window)
 685 -      && matewnck_window_is_skip_tasklist (act_window)
 686 -      && type != MATEWNCK_WINDOW_DESKTOP)
 687 +  if (WNCK_IS_WINDOW (act_window)
 688 +      && wnck_window_is_skip_tasklist (act_window)
 689 +      && type != WNCK_WINDOW_DESKTOP)
 690      return;
 691
 692 -  if (type == MATEWNCK_WINDOW_DOCK
 693 -      || type == MATEWNCK_WINDOW_SPLASHSCREEN
 694 -      || type == MATEWNCK_WINDOW_MENU)
 695 +  if (type == WNCK_WINDOW_DOCK
 696 +      || type == WNCK_WINDOW_SPLASHSCREEN
 697 +      || type == WNCK_WINDOW_MENU)
 698      return;
 699
 700    disconnect_window (title);
 701
 702 -  if (!MATEWNCK_IS_WINDOW (act_window)
 703 -        || matewnck_window_get_window_type (act_window) == MATEWNCK_WINDOW_DESKTOP)
 704 +  if (!WNCK_IS_WINDOW (act_window)
 705 +        || wnck_window_get_window_type (act_window) == WNCK_WINDOW_DESKTOP)
 706    {
 707      if (priv->show_home_title)
 708      {
 709 @@ -264,12 +265,12 @@ on_active_window_changed (MatewnckScreen
 710    else
 711    {
 712      gtk_label_set_text (GTK_LABEL (priv->label),
 713 -                        matewnck_window_get_name (act_window));
 714 +                        wnck_window_get_name (act_window));
 715      gtk_image_set_from_stock (GTK_IMAGE (priv->button_image),
 716                                GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU);
 717
 718      gtk_widget_set_tooltip_text (GTK_WIDGET (title),
 719 -                                 matewnck_window_get_name (act_window));
 720 +                                 wnck_window_get_name (act_window));
 721      gtk_widget_set_tooltip_text (priv->button, _("Close window"));
 722
 723      g_signal_connect (act_window, "name-changed",
 724 @@ -282,14 +283,14 @@ on_active_window_changed (MatewnckScreen
 725      priv->window = act_window;
 726    }
 727
 728 -  if (MATEWNCK_IS_WINDOW (act_window)
 729 -      && !matewnck_window_is_maximized (act_window)
 730 -      && (priv->show_home_title ? type != MATEWNCK_WINDOW_DESKTOP : 1))
 731 +  if (WNCK_IS_WINDOW (act_window)
 732 +      && !wnck_window_is_maximized (act_window)
 733 +      && (priv->show_home_title ? type != WNCK_WINDOW_DESKTOP : 1))
 734    {
 735      gtk_widget_set_state (GTK_WIDGET (title), GTK_STATE_NORMAL);
 736      gtk_widget_hide (priv->box);
 737    }
 738 -  else if (!MATEWNCK_IS_WINDOW (act_window))
 739 +  else if (!WNCK_IS_WINDOW (act_window))
 740    {
 741      if (task_list_get_desktop_visible (TASK_LIST (task_list_get_default ()))
 742          && priv->show_home_title)
 743 @@ -322,21 +323,21 @@ static gboolean
 744  on_button_release (GtkWidget *title, GdkEventButton *event)
 745  {
 746    TaskTitlePrivate *priv;
 747 -  MatewnckWindow *window;
 748 +  WnckWindow *window;
 749    GtkWidget *menu;
 750
 751    g_return_val_if_fail (TASK_IS_TITLE (title), FALSE);
 752    priv = TASK_TITLE_GET_PRIVATE (title);
 753
 754 -  window = matewnck_screen_get_active_window (priv->screen);
 755 +  window = wnck_screen_get_active_window (priv->screen);
 756
 757 -  g_return_val_if_fail (MATEWNCK_IS_WINDOW (window), FALSE);
 758 +  g_return_val_if_fail (WNCK_IS_WINDOW (window), FALSE);
 759
 760    if (event->button == 3)
 761    {
 762 -    if (matewnck_window_get_window_type (window) != MATEWNCK_WINDOW_DESKTOP)
 763 +    if (wnck_window_get_window_type (window) != WNCK_WINDOW_DESKTOP)
 764      {
 765 -      menu = matewnck_action_menu_new (window);
 766 +      menu = wnck_action_menu_new (window);
 767        gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL,
 768                        event->button, event->time);
 769        return TRUE;
 770 @@ -344,9 +345,9 @@ on_button_release (GtkWidget *title, Gdk
 771    }
 772    else if (event->button == 1)
 773    {
 774 -    if (event->type == GDK_2BUTTON_PRESS && matewnck_window_is_maximized (window))
 775 +    if (event->type == GDK_2BUTTON_PRESS && wnck_window_is_maximized (window))
 776      {
 777 -      matewnck_window_unmaximize (window);
 778 +      wnck_window_unmaximize (window);
 779      }
 780    }
 781
 782 @@ -411,7 +412,7 @@ task_title_init (TaskTitle *title)
 783
 784    priv = title->priv = TASK_TITLE_GET_PRIVATE (title);
 785
 786 -  priv->screen = matewnck_screen_get_default ();
 787 +  priv->screen = wnck_screen_get_default ();
 788    priv->window = NULL;
 789
 790    /* FIXME we can add an option for this in future */
 791 --- mate-netbook-1.6.0/maximus/maximus-app.h.orig       2013-04-01 16:05:35.000000000 +0200
 792 +++ mate-netbook-1.6.0/maximus/maximus-app.h    2014-01-01 14:32:02.282752921 +0100
 793 @@ -22,7 +22,6 @@
 794
 795  #include <glib-object.h>
 796  #include <gtk/gtk.h>
 797 -#include <libmatewnck/libmatewnck.h>
 798
 799  #define MAXIMUS_TYPE_APP (maximus_app_get_type ())
 800
 801 --- mate-netbook-1.6.1/maximus/maximus-bind.c.orig      2014-01-01 19:27:09.000000000 +0100
 802 +++ mate-netbook-1.6.1/maximus/maximus-bind.c   2014-01-02 20:28:55.984895075 +0100
 803 @@ -27,7 +27,8 @@
 804
 805  #include <gio/gio.h>
 806
 807 -#include <libmatewnck/libmatewnck.h>
 808 +#define WNCK_I_KNOW_THIS_IS_UNSTABLE
 809 +#include <libwnck/libwnck.h>
 810
 811  #include <X11/Xlib.h>
 812  #include <X11/Xresource.h>
 813 @@ -67,7 +68,7 @@ G_DEFINE_TYPE (MaximusBind, maximus_bind
 814  struct _MaximusBindPrivate
 815  {
 816    FakeKey *fk;
 817 -  MatewnckScreen *screen;
 818 +  WnckScreen *screen;
 819    GSettings *settings;
 820
 821    gchar *binding;
 822 @@ -83,16 +84,16 @@ typedef struct
 823  } MaximusRule;
 824
 825  static const gchar *
 826 -get_fullscreen_keystroke (GList *rules, MatewnckWindow *window)
 827 +get_fullscreen_keystroke (GList *rules, WnckWindow *window)
 828  {
 829 -  MatewnckClassGroup *group;
 830 +  WnckClassGroup *group;
 831    const gchar *class_name;
 832    GList *r;
 833
 834 -  group = matewnck_window_get_class_group (window);
 835 -  class_name = matewnck_class_group_get_name (group);
 836 +  group = wnck_window_get_class_group (window);
 837 +  class_name = wnck_class_group_get_name (group);
 838
 839 -  g_debug ("Searching rules for %s:\n", matewnck_window_get_name (window));
 840 +  g_debug ("Searching rules for %s:\n", wnck_window_get_name (window));
 841
 842    for (r = rules; r; r = r->next)
 843    {
 844 @@ -112,14 +113,14 @@ get_fullscreen_keystroke (GList *rules,
 845  }
 846
 847  static const gchar *
 848 -get_unfullscreen_keystroke (GList *rules, MatewnckWindow *window)
 849 +get_unfullscreen_keystroke (GList *rules, WnckWindow *window)
 850  {
 851 -  MatewnckClassGroup *group;
 852 +  WnckClassGroup *group;
 853    const gchar *class_name;
 854    GList *r;
 855
 856 -  group = matewnck_window_get_class_group (window);
 857 -  class_name = matewnck_class_group_get_name (group);
 858 +  group = wnck_window_get_class_group (window);
 859 +  class_name = wnck_class_group_get_name (group);
 860
 861    for (r = rules; r; r = r->next)
 862    {
 863 @@ -138,16 +139,16 @@ real_fullscreen (MaximusBind *bind)
 864  {
 865    MaximusBindPrivate *priv;
 866    GdkDisplay UNUSED_VARIABLE *display;
 867 -  MatewnckWindow *active;
 868 +  WnckWindow *active;
 869    const gchar *keystroke;
 870
 871    priv = bind->priv;
 872
 873    display = gdk_display_get_default ();
 874 -  active = matewnck_screen_get_active_window (priv->screen);
 875 +  active = wnck_screen_get_active_window (priv->screen);
 876
 877 -  if (!MATEWNCK_IS_WINDOW (active)
 878 -        || matewnck_window_get_window_type (active) != MATEWNCK_WINDOW_NORMAL)
 879 +  if (!WNCK_IS_WINDOW (active)
 880 +        || wnck_window_get_window_type (active) != WNCK_WINDOW_NORMAL)
 881      return FALSE;
 882
 883    keystroke = get_fullscreen_keystroke (priv->rules, active);
 884 @@ -179,7 +180,7 @@ real_fullscreen (MaximusBind *bind)
 885       }
 886    }
 887
 888 -  if (!matewnck_window_is_fullscreen (active))
 889 +  if (!wnck_window_is_fullscreen (active))
 890    {
 891      g_debug ("Sending fullscreen F11 event");
 892      fakekey_press_keysym (priv->fk, XK_F11, 0);
 893 @@ -188,17 +189,17 @@ real_fullscreen (MaximusBind *bind)
 894
 895    sleep (STATE_CHANGED_SLEEP);
 896
 897 -  if (!matewnck_window_is_fullscreen (active))
 898 +  if (!wnck_window_is_fullscreen (active))
 899    {
 900 -    g_debug ("Forcing fullscreen matewnck event");
 901 -    matewnck_window_set_fullscreen (active, TRUE);
 902 +    g_debug ("Forcing fullscreen wnck event");
 903 +    wnck_window_set_fullscreen (active, TRUE);
 904    }
 905
 906    return FALSE;
 907  }
 908
 909  static void
 910 -fullscreen (MaximusBind *bind, MatewnckWindow *window)
 911 +fullscreen (MaximusBind *bind, WnckWindow *window)
 912  {
 913    MaximusBindPrivate UNUSED_VARIABLE *priv;
 914
 915 @@ -212,16 +213,16 @@ real_unfullscreen (MaximusBind *bind)
 916  {
 917    MaximusBindPrivate *priv;
 918    GdkDisplay UNUSED_VARIABLE *display;
 919 -  MatewnckWindow *active;
 920 +  WnckWindow *active;
 921    const gchar *keystroke;
 922
 923    priv = bind->priv;
 924
 925    display = gdk_display_get_default ();
 926 -  active = matewnck_screen_get_active_window (priv->screen);
 927 +  active = wnck_screen_get_active_window (priv->screen);
 928
 929 -  if (!MATEWNCK_IS_WINDOW (active)
 930 -        || matewnck_window_get_window_type (active) != MATEWNCK_WINDOW_NORMAL)
 931 +  if (!WNCK_IS_WINDOW (active)
 932 +        || wnck_window_get_window_type (active) != WNCK_WINDOW_NORMAL)
 933      return FALSE;
 934
 935    keystroke = get_unfullscreen_keystroke (priv->rules, active);
 936 @@ -252,7 +253,7 @@ real_unfullscreen (MaximusBind *bind)
 937        return FALSE;
 938       }
 939    }
 940 -  if (matewnck_window_is_fullscreen (active))
 941 +  if (wnck_window_is_fullscreen (active))
 942    {
 943      g_debug ("Sending un-fullscreen F11 event");
 944      fakekey_press_keysym (priv->fk, XK_F11, 0);
 945 @@ -261,17 +262,17 @@ real_unfullscreen (MaximusBind *bind)
 946
 947    sleep (STATE_CHANGED_SLEEP);
 948
 949 -  if (matewnck_window_is_fullscreen (active))
 950 +  if (wnck_window_is_fullscreen (active))
 951    {
 952 -    g_debug ("Forcing un-fullscreen matewnck event");
 953 -    matewnck_window_set_fullscreen (active, FALSE);
 954 +    g_debug ("Forcing un-fullscreen wnck event");
 955 +    wnck_window_set_fullscreen (active, FALSE);
 956    }
 957
 958    return FALSE;
 959  }
 960
 961  static void
 962 -unfullscreen (MaximusBind *bind, MatewnckWindow *window)
 963 +unfullscreen (MaximusBind *bind, WnckWindow *window)
 964  {
 965    MaximusBindPrivate UNUSED_VARIABLE *priv;
 966
 967 @@ -285,17 +286,17 @@ static void
 968  on_binding_activated (gchar *keystring, MaximusBind *bind)
 969  {
 970    MaximusBindPrivate *priv;
 971 -  MatewnckWindow *active;
 972 +  WnckWindow *active;
 973
 974    g_return_if_fail (MAXIMUS_IS_BIND (bind));
 975    priv = bind->priv;
 976
 977 -  active = matewnck_screen_get_active_window (priv->screen);
 978 +  active = wnck_screen_get_active_window (priv->screen);
 979
 980 -  if (matewnck_window_get_window_type (active) != MATEWNCK_WINDOW_NORMAL)
 981 +  if (wnck_window_get_window_type (active) != WNCK_WINDOW_NORMAL)
 982      return;
 983
 984 -  if (matewnck_window_is_fullscreen (active))
 985 +  if (wnck_window_is_fullscreen (active))
 986    {
 987      unfullscreen (bind, active);
 988    }
 989 @@ -462,12 +463,12 @@ maximus_bind_init (MaximusBind *bind)
 990  {
 991    MaximusBindPrivate *priv;
 992    GdkDisplay *display = gdk_display_get_default ();
 993 -  MatewnckScreen *screen;
 994 +  WnckScreen *screen;
 995
 996    priv = bind->priv = MAXIMUS_BIND_GET_PRIVATE (bind);
 997
 998    priv->fk = fakekey_init (GDK_DISPLAY_XDISPLAY (display));
 999 -  priv->screen = screen = matewnck_screen_get_default ();
1000 +  priv->screen = screen = wnck_screen_get_default ();
1001    priv->rules = NULL;
1002    priv->settings = g_settings_new (BIND_SCHEMA);
1003
1004 --- mate-netbook-1.6.0/maximus/xutils.c.orig    2013-04-01 16:05:35.000000000 +0200
1005 +++ mate-netbook-1.6.0/maximus/xutils.c 2014-01-01 14:31:37.276087304 +0100
1006 @@ -25,7 +25,8 @@
1007  #include "xutils.h"
1008  #include <string.h>
1009  #include <stdio.h>
1010 -#include <libmatewnck/libmatewnck.h>
1011 +#define WNCK_I_KNOW_THIS_IS_UNSTABLE
1012 +#include <libwnck/libwnck.h>
1013
1014  #ifdef __GNUC__
1015  #define UNUSED_VARIABLE __attribute__ ((unused))
1016 --- mate-netbook-1.6.1/maximus/maximus-app.c.orig       2014-01-01 19:27:09.000000000 +0100
1017 +++ mate-netbook-1.6.1/maximus/maximus-app.c    2014-01-02 20:30:45.454890481 +0100
1018 @@ -25,6 +25,9 @@
1019  #include <gdk/gdkx.h>
1020  #include <gio/gio.h>
1021
1022 +#define WNCK_I_KNOW_THIS_IS_UNSTABLE
1023 +#include <libwnck/libwnck.h>
1024 +
1025  #include "maximus-app.h"
1026  #include "maximus-bind.h"
1027  #include "xutils.h"
1028 @@ -71,7 +74,7 @@ static gchar *default_exclude_classes[]
1029  struct _MaximusAppPrivate
1030  {
1031    MaximusBind *bind;
1032 -  MatewnckScreen *screen;
1033 +  WnckScreen *screen;
1034    GSettings *settings;
1035
1036    gchar **exclude_class_list;
1037 @@ -98,7 +98,7 @@ typedef struct {
1038  #define _XA_MOTIF_WM_HINTS             "_MOTIF_WM_HINTS"
1039
1040  static gboolean
1041 -matewnck_window_is_decorated (MatewnckWindow *window)
1042 +matewnck_window_is_decorated (WnckWindow *window)
1043  {
1044    GdkDisplay *display = gdk_display_get_default();
1045    Atom hints_atom = None;
1046 @@ -107,13 +110,13 @@ matewnck_window_is_decorated (MatewnckWi
1047    gulong bytes_after;
1048    gboolean retval;
1049
1050 -  g_return_val_if_fail (MATEWNCK_IS_WINDOW (window), FALSE);
1051 +  g_return_val_if_fail (WNCK_IS_WINDOW (window), FALSE);
1052
1053    hints_atom = gdk_x11_get_xatom_by_name_for_display (display,
1054                                                        _XA_MOTIF_WM_HINTS);
1055
1056    XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display),
1057 -                      matewnck_window_get_xid (window),
1058 +                      wnck_window_get_xid (window),
1059                                   hints_atom, 0, sizeof (MotifWmHints)/sizeof (long),
1060                                   False, AnyPropertyType, &type, &format, &nitems,
1061                                   &bytes_after, &data);
1062 @@ -131,7 +134,7 @@ matewnck_window_is_decorated (MatewnckWi
1063  }
1064
1065  static void
1066 -gdk_window_set_mwm_hints (MatewnckWindow *window,
1067 +gdk_window_set_mwm_hints (WnckWindow *window,
1068                            MotifWmHints *new_hints)
1069  {
1070    GdkDisplay *display = gdk_display_get_default();
1071 @@ -143,14 +146,14 @@ gdk_window_set_mwm_hints (MatewnckWindow
1072    gulong nitems;
1073    gulong bytes_after;
1074
1075 -  g_return_if_fail (MATEWNCK_IS_WINDOW (window));
1076 +  g_return_if_fail (WNCK_IS_WINDOW (window));
1077    g_return_if_fail (GDK_IS_DISPLAY (display));
1078
1079    hints_atom = gdk_x11_get_xatom_by_name_for_display (display,
1080                                                        _XA_MOTIF_WM_HINTS);
1081
1082    XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display),
1083 -                      matewnck_window_get_xid (window),
1084 +                      wnck_window_get_xid (window),
1085                                   hints_atom, 0, sizeof (MotifWmHints)/sizeof (long),
1086                                   False, AnyPropertyType, &type, &format, &nitems,
1087                                   &bytes_after, &data);
1088 @@ -175,7 +178,7 @@ gdk_window_set_mwm_hints (MatewnckWindow
1089
1090    _matewnck_error_trap_push ();
1091    XChangeProperty (GDK_DISPLAY_XDISPLAY (display),
1092 -                   matewnck_window_get_xid (window),
1093 +                   wnck_window_get_xid (window),
1094                     hints_atom, hints_atom, 32, PropModeReplace,
1095                     (guchar *)hints, sizeof (MotifWmHints)/sizeof (long));
1096    gdk_flush ();
1097 @@ -186,12 +189,12 @@ gdk_window_set_mwm_hints (MatewnckWindow
1098  }
1099
1100  static void
1101 -_window_set_decorations (MatewnckWindow      *window,
1102 +_window_set_decorations (WnckWindow      *window,
1103                                            GdkWMDecoration decorations)
1104  {
1105    MotifWmHints *hints;
1106
1107 -  g_return_if_fail (MATEWNCK_IS_WINDOW (window));
1108 +  g_return_if_fail (WNCK_IS_WINDOW (window));
1109
1110    /* initialize to zero to avoid writing uninitialized data to socket */
1111    hints = g_slice_new0 (MotifWmHints);
1112 @@ -206,17 +209,17 @@ _window_set_decorations (MatewnckWindow
1113  /* </TAKEN FROM GDK> */
1114
1115  gboolean
1116 -window_is_too_large_for_screen (MatewnckWindow *window)
1117 +window_is_too_large_for_screen (WnckWindow *window)
1118  {
1119    static GdkScreen *screen = NULL;
1120    gint x=0, y=0, w=0, h=0;
1121
1122 -  g_return_val_if_fail (MATEWNCK_IS_WINDOW (window), FALSE);
1123 +  g_return_val_if_fail (WNCK_IS_WINDOW (window), FALSE);
1124
1125    if (screen == NULL)
1126      screen = gdk_screen_get_default ();
1127
1128 -  matewnck_window_get_geometry (window, &x, &y, &w, &h);
1129 +  wnck_window_get_geometry (window, &x, &y, &w, &h);
1130
1131    /* some wiggle room */
1132    return (screen &&
1133 @@ -225,14 +228,14 @@ window_is_too_large_for_screen (Matewnck
1134  }
1135
1136  static gboolean
1137 -on_window_maximised_changed (MatewnckWindow *window)
1138 +on_window_maximised_changed (WnckWindow *window)
1139  {
1140 -  g_return_val_if_fail (MATEWNCK_IS_WINDOW (window), FALSE);
1141 +  g_return_val_if_fail (WNCK_IS_WINDOW (window), FALSE);
1142
1143    if (window_is_too_large_for_screen (window))
1144      {
1145        _window_set_decorations (window, 1);
1146 -      matewnck_window_unmaximize (window);
1147 +      wnck_window_unmaximize (window);
1148      }
1149    else
1150      {
1151 @@ -242,29 +245,29 @@ on_window_maximised_changed (MatewnckWin
1152  }
1153
1154  static gboolean
1155 -enable_window_decorations (MatewnckWindow *window)
1156 +enable_window_decorations (WnckWindow *window)
1157  {
1158 -  g_return_val_if_fail (MATEWNCK_IS_WINDOW (window), FALSE);
1159 +  g_return_val_if_fail (WNCK_IS_WINDOW (window), FALSE);
1160
1161    _window_set_decorations (window, 1);
1162    return FALSE;
1163  }
1164
1165  static void
1166 -on_window_state_changed (MatewnckWindow      *window,
1167 -                         MatewnckWindowState  change_mask,
1168 -                         MatewnckWindowState  new_state,
1169 +on_window_state_changed (WnckWindow      *window,
1170 +                         WnckWindowState  change_mask,
1171 +                         WnckWindowState  new_state,
1172                           MaximusApp     *app)
1173  {
1174 -  g_return_if_fail (MATEWNCK_IS_WINDOW (window));
1175 +  g_return_if_fail (WNCK_IS_WINDOW (window));
1176
1177    if (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (window), "exclude"))==1)
1178      return;
1179
1180 -  if (change_mask & MATEWNCK_WINDOW_STATE_MAXIMIZED_HORIZONTALLY
1181 -      || change_mask & MATEWNCK_WINDOW_STATE_MAXIMIZED_VERTICALLY)
1182 +  if (change_mask & WNCK_WINDOW_STATE_MAXIMIZED_HORIZONTALLY
1183 +      || change_mask & WNCK_WINDOW_STATE_MAXIMIZED_VERTICALLY)
1184    {
1185 -    if (matewnck_window_is_maximized (window) && app->priv->undecorate)
1186 +    if (wnck_window_is_maximized (window) && app->priv->undecorate)
1187      {
1188        g_idle_add ((GSourceFunc)on_window_maximised_changed, window);
1189      }
1190 @@ -276,44 +279,44 @@ on_window_state_changed (MatewnckWindow
1191  }
1192
1193  static gboolean
1194 -is_excluded (MaximusApp *app, MatewnckWindow *window)
1195 +is_excluded (MaximusApp *app, WnckWindow *window)
1196  {
1197    MaximusAppPrivate *priv;
1198 -  MatewnckWindowType type;
1199 -  MatewnckWindowActions actions;
1200 +  WnckWindowType type;
1201 +  WnckWindowActions actions;
1202    gchar *res_name;
1203    gchar *class_name;
1204    gint i;
1205
1206    g_return_val_if_fail (MAXIMUS_IS_APP (app), TRUE);
1207 -  g_return_val_if_fail (MATEWNCK_IS_WINDOW (window), TRUE);
1208 +  g_return_val_if_fail (WNCK_IS_WINDOW (window), TRUE);
1209    priv = app->priv;
1210
1211 -  type = matewnck_window_get_window_type (window);
1212 -  if (type != MATEWNCK_WINDOW_NORMAL)
1213 +  type = wnck_window_get_window_type (window);
1214 +  if (type != WNCK_WINDOW_NORMAL)
1215      return TRUE;
1216
1217    if (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (window), "exclude"))==1)
1218      return TRUE;
1219
1220    /* Ignore if the window is already fullscreen */
1221 -  if (matewnck_window_is_fullscreen (window))
1222 +  if (wnck_window_is_fullscreen (window))
1223    {
1224 -    g_debug ("Excluding (is fullscreen): %s\n",matewnck_window_get_name (window));
1225 +    g_debug ("Excluding (is fullscreen): %s\n",wnck_window_get_name (window));
1226      return TRUE;
1227    }
1228
1229    /* Make sure the window supports maximising */
1230 -  actions = matewnck_window_get_actions (window);
1231 -  if (actions & MATEWNCK_WINDOW_ACTION_RESIZE
1232 -      && actions & MATEWNCK_WINDOW_ACTION_MAXIMIZE_HORIZONTALLY
1233 -      && actions & MATEWNCK_WINDOW_ACTION_MAXIMIZE_VERTICALLY
1234 -      && actions & MATEWNCK_WINDOW_ACTION_MAXIMIZE)
1235 +  actions = wnck_window_get_actions (window);
1236 +  if (actions & WNCK_WINDOW_ACTION_RESIZE
1237 +      && actions & WNCK_WINDOW_ACTION_MAXIMIZE_HORIZONTALLY
1238 +      && actions & WNCK_WINDOW_ACTION_MAXIMIZE_VERTICALLY
1239 +      && actions & WNCK_WINDOW_ACTION_MAXIMIZE)
1240      ; /* Is good to maximise */
1241    else
1242      return TRUE;
1243
1244 -  _matewnck_get_wmclass (matewnck_window_get_xid (window), &res_name, &class_name);
1245 +  _matewnck_get_wmclass (wnck_window_get_xid (window), &res_name, &class_name);
1246
1247    g_debug ("Window opened: res_name=%s -- class_name=%s", res_name, class_name);
1248
1249 @@ -325,7 +328,7 @@ is_excluded (MaximusApp *app, MatewnckWi
1250          || (res_name && default_exclude_classes[i] && strstr (res_name,
1251                                              default_exclude_classes[i])))
1252      {
1253 -      g_debug ("Excluding: %s\n", matewnck_window_get_name (window));
1254 +      g_debug ("Excluding: %s\n", wnck_window_get_name (window));
1255        return TRUE;
1256      }
1257    }
1258 @@ -336,7 +339,7 @@ is_excluded (MaximusApp *app, MatewnckWi
1259      if ((class_name && strstr (class_name, priv->exclude_class_list[i]))
1260          || (res_name && strstr (res_name, priv->exclude_class_list[i]) ))
1261      {
1262 -      g_debug ("Excluding: %s\n", matewnck_window_get_name (window));
1263 +      g_debug ("Excluding: %s\n", wnck_window_get_name (window));
1264        return TRUE;
1265      }
1266    }
1267 @@ -349,25 +352,25 @@ is_excluded (MaximusApp *app, MatewnckWi
1268  extern gboolean no_maximize;
1269
1270  static void
1271 -on_window_opened (MatewnckScreen  *screen,
1272 -                  MatewnckWindow  *window,
1273 +on_window_opened (WnckScreen  *screen,
1274 +                  WnckWindow  *window,
1275                    MaximusApp *app)
1276  {
1277    MaximusAppPrivate *priv;
1278 -  MatewnckWindowType type;
1279 +  WnckWindowType type;
1280    gint exclude = 0;
1281
1282    g_return_if_fail (MAXIMUS_IS_APP (app));
1283 -  g_return_if_fail (MATEWNCK_IS_WINDOW (window));
1284 +  g_return_if_fail (WNCK_IS_WINDOW (window));
1285    priv = app->priv;
1286
1287 -  type = matewnck_window_get_window_type (window);
1288 -  if (type != MATEWNCK_WINDOW_NORMAL)
1289 +  type = wnck_window_get_window_type (window);
1290 +  if (type != WNCK_WINDOW_NORMAL)
1291      return;
1292
1293    /* Ignore undecorated windows */
1294    exclude = matewnck_window_is_decorated (window) ? 0 : 1;
1295 -  if (matewnck_window_is_maximized (window))
1296 +  if (wnck_window_is_maximized (window))
1297      exclude = 0;
1298    g_object_set_data (G_OBJECT (window), "exclude", GINT_TO_POINTER (exclude));
1299
1300 @@ -380,7 +383,7 @@ on_window_opened (MatewnckScreen  *scree
1301
1302    if (no_maximize || priv->no_maximize)
1303    {
1304 -    if (matewnck_window_is_maximized(window))
1305 +    if (wnck_window_is_maximized(window))
1306      {
1307        _window_set_decorations (window, 0);
1308        gdk_flush ();
1309 @@ -400,7 +403,7 @@ on_window_opened (MatewnckScreen  *scree
1310      }
1311    }
1312
1313 -  matewnck_window_maximize (window);
1314 +  wnck_window_maximize (window);
1315
1316    g_signal_connect (window, "state-changed",
1317                      G_CALLBACK (on_window_state_changed), app);
1318 @@ -437,11 +440,11 @@ on_exclude_class_changed (GSettings *set
1319  }
1320
1321  static gboolean
1322 -show_desktop (MatewnckScreen *screen)
1323 +show_desktop (WnckScreen *screen)
1324  {
1325 -  g_return_val_if_fail (MATEWNCK_IS_SCREEN (screen), FALSE);
1326 +  g_return_val_if_fail (WNCK_IS_SCREEN (screen), FALSE);
1327
1328 -  matewnck_screen_toggle_showing_desktop (screen, TRUE);
1329 +  wnck_screen_toggle_showing_desktop (screen, TRUE);
1330    return FALSE;
1331  }
1332
1333 @@ -455,22 +458,22 @@ on_app_undecorate_changed (GSettings
1334
1335    g_return_if_fail (MAXIMUS_IS_APP (app));
1336    priv = app->priv;
1337 -  g_return_if_fail (MATEWNCK_IS_SCREEN (priv->screen));
1338 +  g_return_if_fail (WNCK_IS_SCREEN (priv->screen));
1339
1340    priv->undecorate = g_settings_get_boolean (settings, APP_UNDECORATE);
1341    g_debug ("%s\n", priv->undecorate ? "Undecorating" : "Decorating");
1342
1343 -  windows = matewnck_screen_get_windows (priv->screen);
1344 +  windows = wnck_screen_get_windows (priv->screen);
1345    for (w = windows; w; w = w->next)
1346    {
1347 -    MatewnckWindow *window = w->data;
1348 +    WnckWindow *window = w->data;
1349
1350 -    if (!MATEWNCK_IS_WINDOW (window))
1351 +    if (!WNCK_IS_WINDOW (window))
1352        continue;
1353
1354      if (no_maximize || priv->no_maximize)
1355      {
1356 -      if (!matewnck_window_is_maximized(window))
1357 +      if (!wnck_window_is_maximized(window))
1358          continue;
1359      }
1360
1361 @@ -478,8 +481,8 @@ on_app_undecorate_changed (GSettings
1362      {
1363        gdk_error_trap_push ();
1364        _window_set_decorations (window, priv->undecorate ? 0 : 1);
1365 -      matewnck_window_unmaximize (window);
1366 -      matewnck_window_maximize (window);
1367 +      wnck_window_unmaximize (window);
1368 +      wnck_window_maximize (window);
1369        gdk_flush ();
1370        gdk_error_trap_pop ();
1371
1372 @@ -504,7 +507,7 @@ static void
1373  maximus_app_init (MaximusApp *app)
1374  {
1375    MaximusAppPrivate *priv;
1376 -  MatewnckScreen *screen;
1377 +  WnckScreen *screen;
1378
1379    priv = app->priv = MAXIMUS_APP_GET_PRIVATE (app);
1380
1381 @@ -523,7 +526,7 @@ maximus_app_init (MaximusApp *app)
1382                      G_CALLBACK (on_app_undecorate_changed), app);
1383
1384
1385 -  priv->screen = screen = matewnck_screen_get_default ();
1386 +  priv->screen = screen = wnck_screen_get_default ();
1387    g_signal_connect (screen, "window-opened",
1388                      G_CALLBACK (on_window_opened), app);
1389
1390 --- mate-netbook-1.6.0/mate-window-picker-applet/task-item.h.orig       2013-04-01 16:05:35.000000000 +0200
1391 +++ mate-netbook-1.6.0/mate-window-picker-applet/task-item.h    2014-01-01 14:58:56.632685173 +0100
1392 @@ -23,7 +23,8 @@
1393
1394  #include <glib.h>
1395  #include <gtk/gtk.h>
1396 -#include <libmatewnck/libmatewnck.h>
1397 +#define WNCK_I_KNOW_THIS_IS_UNSTABLE
1398 +#include <libwnck/libwnck.h>
1399
1400  #define TASK_TYPE_ITEM (task_item_get_type ())
1401
1402 @@ -62,7 +63,7 @@ struct _TaskItemClass
1403
1404  GType task_item_get_type (void) G_GNUC_CONST;
1405
1406 -GtkWidget * task_item_new (MatewnckWindow *window);
1407 +GtkWidget * task_item_new (WnckWindow *window);
1408
1409  GtkWidget * task_item_get_default (void);
1410