[mutter] Create a MetaAltTabHandler abstraction to allow alternate implementations
- From: Dan Winship <danw src gnome org>
- To: svn-commits-list gnome org
- Subject: [mutter] Create a MetaAltTabHandler abstraction to allow alternate implementations
- Date: Mon, 4 May 2009 10:26:53 -0400 (EDT)
commit 1d5117a607b92003180779d43ef6ca568a9a9d04
Author: Dan Winship <danw gnome org>
Date: Tue Apr 28 09:32:18 2009 -0400
Create a MetaAltTabHandler abstraction to allow alternate implementations
http://bugzilla.gnome.org/show_bug.cgi?id=580917
---
src/Makefile.am | 5 +
src/core/alttabhandler.c | 138 ++++++++++++++++++++++
src/core/alttabhandlerdefault.c | 223 ++++++++++++++++++++++++++++++++++++
src/core/keybindings.c | 6 +-
src/core/screen-private.h | 8 +-
src/core/screen.c | 137 ++++------------------
src/include/alttabhandler.h | 73 ++++++++++++
src/include/alttabhandlerdefault.h | 55 +++++++++
8 files changed, 525 insertions(+), 120 deletions(-)
diff --git a/src/Makefile.am b/src/Makefile.am
index 5e44e4f..7e9954b 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -11,6 +11,10 @@ INCLUDES= METACITY_CFLAGS@ -I $(srcdir)/include -I$(srcdir)/compositor -DMETACIT
metacity_SOURCES= \
core/async-getprop.c \
core/async-getprop.h \
+ core/alttabhandler.c \
+ include/alttabhandler.h \
+ core/alttabhandlerdefault.c \
+ include/alttabhandlerdefault.h \
core/bell.c \
core/bell.h \
core/boxes.c \
@@ -142,6 +146,7 @@ libmetacity_private_la_LIBADD = @METACITY_LIBS@
libmetacityincludedir = $(includedir)/metacity-1/metacity-private
libmetacityinclude_base_headers = \
+ include/alttabhandler.h \
include/boxes.h \
ui/gradient.h \
include/util.h \
diff --git a/src/core/alttabhandler.c b/src/core/alttabhandler.c
new file mode 100644
index 0000000..cfe02a5
--- /dev/null
+++ b/src/core/alttabhandler.c
@@ -0,0 +1,138 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Metacity Alt-Tab abstraction */
+
+/*
+ * Copyright (C) 2009 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include "alttabhandlerdefault.h"
+#include "screen-private.h"
+
+static GType handler_type = G_TYPE_INVALID;
+
+GType meta_alt_tab_handler_default_get_type (void);
+
+void
+meta_alt_tab_handler_register (GType type)
+{
+ handler_type = type;
+}
+
+MetaAltTabHandler *
+meta_alt_tab_handler_new (MetaScreen *screen,
+ gboolean immediate)
+{
+ if (handler_type == G_TYPE_INVALID)
+ handler_type = meta_alt_tab_handler_default_get_type ();
+
+ return g_object_new (handler_type,
+ "screen", screen,
+ "immediate", immediate,
+ NULL);
+}
+
+static void meta_alt_tab_handler_class_init (GObjectClass *object_class);
+
+GType
+meta_alt_tab_handler_get_type (void)
+{
+ static volatile gsize g_define_type_id__volatile = 0;
+
+ if (g_once_init_enter (&g_define_type_id__volatile))
+ {
+ const GTypeInfo type_info =
+ {
+ sizeof (MetaAltTabHandlerInterface), /* class_size */
+ NULL, /* base_init */
+ NULL, /* base_finalize */
+ (GClassInitFunc)meta_alt_tab_handler_class_init,
+ NULL, /* class_finalize */
+ NULL, /* class_data */
+ 0,
+ 0, /* n_preallocs */
+ NULL
+ };
+ GType g_define_type_id =
+ g_type_register_static (G_TYPE_INTERFACE, "MetaAltTabHandler",
+ &type_info, 0);
+
+ g_type_interface_add_prerequisite (g_define_type_id, G_TYPE_OBJECT);
+
+ g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
+ }
+
+ return g_define_type_id__volatile;
+}
+
+static void
+meta_alt_tab_handler_class_init (GObjectClass *object_class)
+{
+ g_object_interface_install_property (object_class,
+ g_param_spec_object ("screen",
+ "Screen",
+ "MetaScreen this is the switcher for",
+ META_TYPE_SCREEN,
+ G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
+ g_object_interface_install_property (object_class,
+ g_param_spec_boolean ("immediate",
+ "Immediate mode",
+ "Whether or not to select windows immediately",
+ FALSE,
+ G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
+}
+
+void
+meta_alt_tab_handler_add_window (MetaAltTabHandler *handler,
+ MetaWindow *window)
+{
+ META_ALT_TAB_HANDLER_GET_INTERFACE (handler)->add_window (handler, window);
+}
+
+void
+meta_alt_tab_handler_show (MetaAltTabHandler *handler,
+ MetaWindow *initial_selection)
+{
+ META_ALT_TAB_HANDLER_GET_INTERFACE (handler)->show (handler,
+ initial_selection);
+}
+
+void
+meta_alt_tab_handler_destroy (MetaAltTabHandler *handler)
+{
+ META_ALT_TAB_HANDLER_GET_INTERFACE (handler)->destroy (handler);
+}
+
+void
+meta_alt_tab_handler_forward (MetaAltTabHandler *handler)
+{
+ META_ALT_TAB_HANDLER_GET_INTERFACE (handler)->forward (handler);
+}
+
+void
+meta_alt_tab_handler_backward (MetaAltTabHandler *handler)
+{
+ META_ALT_TAB_HANDLER_GET_INTERFACE (handler)->backward (handler);
+}
+
+MetaWindow *
+meta_alt_tab_handler_get_selected (MetaAltTabHandler *handler)
+{
+ return META_ALT_TAB_HANDLER_GET_INTERFACE (handler)->get_selected (handler);
+}
diff --git a/src/core/alttabhandlerdefault.c b/src/core/alttabhandlerdefault.c
new file mode 100644
index 0000000..d5c5f44
--- /dev/null
+++ b/src/core/alttabhandlerdefault.c
@@ -0,0 +1,223 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Metacity Alt-Tab abstraction: default implementation */
+
+/*
+ * Copyright (C) 2009 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include "alttabhandlerdefault.h"
+#include "frame-private.h"
+#include "window-private.h"
+
+static void meta_alt_tab_handler_default_interface_init (MetaAltTabHandlerInterface *handler_iface);
+
+G_DEFINE_TYPE_WITH_CODE (MetaAltTabHandlerDefault, meta_alt_tab_handler_default, G_TYPE_OBJECT,
+ G_IMPLEMENT_INTERFACE (META_TYPE_ALT_TAB_HANDLER,
+ meta_alt_tab_handler_default_interface_init))
+
+enum {
+ PROP_SCREEN = 1,
+ PROP_IMMEDIATE
+};
+
+static void
+meta_alt_tab_handler_default_init (MetaAltTabHandlerDefault *hd)
+{
+ hd->entries = g_array_new (FALSE, FALSE, sizeof (MetaTabEntry));
+}
+
+static void
+meta_alt_tab_handler_default_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ MetaAltTabHandlerDefault *hd = META_ALT_TAB_HANDLER_DEFAULT (object);
+
+ switch (prop_id)
+ {
+ case PROP_SCREEN:
+ hd->screen = g_value_get_object (value);
+ break;
+ case PROP_IMMEDIATE:
+ hd->immediate_mode = g_value_get_boolean (value);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+meta_alt_tab_handler_default_finalize (GObject *object)
+{
+ MetaAltTabHandlerDefault *hd = META_ALT_TAB_HANDLER_DEFAULT (object);
+
+ g_array_free (hd->entries, TRUE);
+
+ if (hd->tab_popup)
+ meta_ui_tab_popup_free (hd->tab_popup);
+
+ G_OBJECT_CLASS (meta_alt_tab_handler_default_parent_class)->finalize (object);
+}
+
+static void
+meta_alt_tab_handler_default_add_window (MetaAltTabHandler *handler,
+ MetaWindow *window)
+{
+ MetaAltTabHandlerDefault *hd = META_ALT_TAB_HANDLER_DEFAULT (handler);
+ MetaTabEntry entry;
+ MetaRectangle r;
+
+ entry.key = (MetaTabEntryKey) window;
+ entry.title = window->title;
+ entry.icon = window->icon;
+ entry.blank = FALSE;
+ entry.hidden = !meta_window_showing_on_its_workspace (window);
+ entry.demands_attention = window->wm_state_demands_attention;
+
+ if (hd->immediate_mode || !entry.hidden ||
+ !meta_window_get_icon_geometry (window, &r))
+ meta_window_get_outer_rect (window, &r);
+ entry.rect = r;
+
+ /* Find inside of highlight rectangle to be used when window is
+ * outlined for tabbing. This should be the size of the
+ * east/west frame, and the size of the south frame, on those
+ * sides. On the top it should be the size of the south frame
+ * edge.
+ */
+#define OUTLINE_WIDTH 5
+ /* Top side */
+ if (!entry.hidden &&
+ window->frame && window->frame->bottom_height > 0 &&
+ window->frame->child_y >= window->frame->bottom_height)
+ entry.inner_rect.y = window->frame->bottom_height;
+ else
+ entry.inner_rect.y = OUTLINE_WIDTH;
+
+ /* Bottom side */
+ if (!entry.hidden &&
+ window->frame && window->frame->bottom_height != 0)
+ entry.inner_rect.height = r.height
+ - entry.inner_rect.y - window->frame->bottom_height;
+ else
+ entry.inner_rect.height = r.height
+ - entry.inner_rect.y - OUTLINE_WIDTH;
+
+ /* Left side */
+ if (!entry.hidden && window->frame && window->frame->child_x != 0)
+ entry.inner_rect.x = window->frame->child_x;
+ else
+ entry.inner_rect.x = OUTLINE_WIDTH;
+
+ /* Right side */
+ if (!entry.hidden &&
+ window->frame && window->frame->right_width != 0)
+ entry.inner_rect.width = r.width
+ - entry.inner_rect.x - window->frame->right_width;
+ else
+ entry.inner_rect.width = r.width
+ - entry.inner_rect.x - OUTLINE_WIDTH;
+
+ g_array_append_val (hd->entries, entry);
+}
+
+static void
+meta_alt_tab_handler_default_show (MetaAltTabHandler *handler,
+ MetaWindow *initial_selection)
+{
+ MetaAltTabHandlerDefault *hd = META_ALT_TAB_HANDLER_DEFAULT (handler);
+
+ if (hd->tab_popup)
+ return;
+
+ hd->tab_popup = meta_ui_tab_popup_new ((MetaTabEntry *)hd->entries->data,
+ hd->screen->number,
+ hd->entries->len,
+ 5, /* FIXME */
+ TRUE);
+ meta_ui_tab_popup_select (hd->tab_popup, (MetaTabEntryKey) initial_selection);
+ meta_ui_tab_popup_set_showing (hd->tab_popup, !hd->immediate_mode);
+}
+
+static void
+meta_alt_tab_handler_default_destroy (MetaAltTabHandler *handler)
+{
+ MetaAltTabHandlerDefault *hd = META_ALT_TAB_HANDLER_DEFAULT (handler);
+
+ if (hd->tab_popup)
+ {
+ meta_ui_tab_popup_free (hd->tab_popup);
+ hd->tab_popup = NULL;
+ }
+}
+
+static void
+meta_alt_tab_handler_default_forward (MetaAltTabHandler *handler)
+{
+ MetaAltTabHandlerDefault *hd = META_ALT_TAB_HANDLER_DEFAULT (handler);
+
+ if (hd->tab_popup)
+ meta_ui_tab_popup_forward (hd->tab_popup);
+}
+
+static void
+meta_alt_tab_handler_default_backward (MetaAltTabHandler *handler)
+{
+ MetaAltTabHandlerDefault *hd = META_ALT_TAB_HANDLER_DEFAULT (handler);
+
+ if (hd->tab_popup)
+ meta_ui_tab_popup_backward (hd->tab_popup);
+}
+
+static MetaWindow *
+meta_alt_tab_handler_default_get_selected (MetaAltTabHandler *handler)
+{
+ MetaAltTabHandlerDefault *hd = META_ALT_TAB_HANDLER_DEFAULT (handler);
+
+ if (hd->tab_popup)
+ return (MetaWindow *)meta_ui_tab_popup_get_selected (hd->tab_popup);
+ else
+ return NULL;
+}
+
+static void
+meta_alt_tab_handler_default_class_init (MetaAltTabHandlerDefaultClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+ object_class->set_property = meta_alt_tab_handler_default_set_property;
+ object_class->finalize = meta_alt_tab_handler_default_finalize;
+
+ g_object_class_override_property (object_class, PROP_SCREEN, "screen");
+ g_object_class_override_property (object_class, PROP_IMMEDIATE, "immediate");
+}
+
+static void
+meta_alt_tab_handler_default_interface_init (MetaAltTabHandlerInterface *handler_iface)
+{
+ handler_iface->add_window = meta_alt_tab_handler_default_add_window;
+ handler_iface->show = meta_alt_tab_handler_default_show;
+ handler_iface->destroy = meta_alt_tab_handler_default_destroy;
+ handler_iface->forward = meta_alt_tab_handler_default_forward;
+ handler_iface->backward = meta_alt_tab_handler_default_backward;
+ handler_iface->get_selected = meta_alt_tab_handler_default_get_selected;
+}
diff --git a/src/core/keybindings.c b/src/core/keybindings.c
index f0c037b..7de3b8c 100644
--- a/src/core/keybindings.c
+++ b/src/core/keybindings.c
@@ -2060,7 +2060,7 @@ process_tab_grab (MetaDisplay *display,
* implementing Alt+Tab & Co., we call this custom handler; we do not
* mess about with the grab, as that is up to the handler to deal with.
*/
- if (!screen->tab_popup)
+ if (!screen->tab_handler)
{
MetaKeyHandler *handler = NULL;
const gchar *handler_name = NULL;
@@ -3060,7 +3060,7 @@ do_choose_window (MetaDisplay *display,
return;
}
- meta_screen_ensure_tab_popup (screen, type,
+ meta_screen_tab_popup_create (screen, type,
show_popup ? META_TAB_SHOW_ICON :
META_TAB_SHOW_INSTANTLY,
initial_selection);
@@ -3440,7 +3440,7 @@ handle_workspace_switch (MetaDisplay *display,
meta_workspace_activate (next, event->xkey.time);
if (grabbed_before_release && !meta_prefs_get_no_tab_popup ())
- meta_screen_ensure_workspace_popup (screen, next);
+ meta_screen_workspace_popup_create (screen, next);
}
static void
diff --git a/src/core/screen-private.h b/src/core/screen-private.h
index a75e25d..043a51d 100644
--- a/src/core/screen-private.h
+++ b/src/core/screen-private.h
@@ -36,6 +36,7 @@
#include "display-private.h"
#include "screen.h"
#include <X11/Xutil.h>
+#include "alttabhandler.h"
#include "ui.h"
typedef struct _MetaXineramaScreenInfo MetaXineramaScreenInfo;
@@ -80,7 +81,8 @@ struct _MetaScreen
Visual *default_xvisual;
MetaRectangle rect; /* Size of screen; rect.x & rect.y are always 0 */
MetaUI *ui;
- MetaTabPopup *tab_popup, *ws_popup;
+ MetaAltTabHandler *tab_handler;
+ MetaTabPopup *ws_popup;
MetaWorkspace *active_workspace;
@@ -164,7 +166,7 @@ void meta_screen_set_cursor (MetaScreen *scree
MetaCursor cursor);
void meta_screen_update_cursor (MetaScreen *screen);
-void meta_screen_ensure_tab_popup (MetaScreen *screen,
+void meta_screen_tab_popup_create (MetaScreen *screen,
MetaTabList list_type,
MetaTabShowType show_type,
MetaWindow *initial_window);
@@ -173,7 +175,7 @@ void meta_screen_tab_popup_backward (MetaScreen *scree
MetaWindow* meta_screen_tab_popup_get_selected (MetaScreen *screen);
void meta_screen_tab_popup_destroy (MetaScreen *screen);
-void meta_screen_ensure_workspace_popup (MetaScreen *screen,
+void meta_screen_workspace_popup_create (MetaScreen *screen,
MetaWorkspace *initial_selection);
void meta_screen_workspace_popup_select (MetaScreen *screen,
MetaWorkspace *workspace);
diff --git a/src/core/screen.c b/src/core/screen.c
index 9b2b90c..10fc336 100644
--- a/src/core/screen.c
+++ b/src/core/screen.c
@@ -38,6 +38,7 @@
#include "stack.h"
#include "xprops.h"
#include "compositor.h"
+#include "alttabhandlerdefault.h"
#ifdef HAVE_SOLARIS_XINERAMA
#include <X11/extensions/xinerama.h>
@@ -711,7 +712,7 @@ meta_screen_new (MetaDisplay *display,
screen->ui = meta_ui_new (screen->display->xdisplay,
screen->xscreen);
- screen->tab_popup = NULL;
+ screen->tab_handler = NULL;
screen->ws_popup = NULL;
screen->stack = meta_stack_new (screen);
@@ -1424,157 +1425,66 @@ meta_screen_update_cursor (MetaScreen *screen)
}
void
-meta_screen_ensure_tab_popup (MetaScreen *screen,
+meta_screen_tab_popup_create (MetaScreen *screen,
MetaTabList list_type,
MetaTabShowType show_type,
MetaWindow *initial_selection)
{
- MetaTabEntry *entries;
GList *tab_list;
GList *tmp;
- int len;
- int i;
- if (screen->tab_popup)
- return;
+ g_return_if_fail (screen->tab_handler == NULL);
+
+ screen->tab_handler = meta_alt_tab_handler_new (screen,
+ show_type == META_TAB_SHOW_INSTANTLY);
tab_list = meta_display_get_tab_list (screen->display,
list_type,
screen,
screen->active_workspace);
- len = g_list_length (tab_list);
-
- entries = g_new (MetaTabEntry, len + 1);
- entries[len].key = NULL;
- entries[len].title = NULL;
- entries[len].icon = NULL;
+ for (tmp = tab_list; tmp; tmp = tmp->next)
+ meta_alt_tab_handler_add_window (screen->tab_handler, tmp->data);
- i = 0;
- tmp = tab_list;
- while (i < len)
- {
- MetaWindow *window;
- MetaRectangle r;
- GdkPixbuf *win_pixbuf;
- int width, height;
-
- window = tmp->data;
-
- entries[i].key = (MetaTabEntryKey) window;
- entries[i].title = window->title;
- entries[i].icon = g_object_ref (window->icon);
- entries[i].blank = FALSE;
- entries[i].hidden = !meta_window_showing_on_its_workspace (window);
- entries[i].demands_attention = window->wm_state_demands_attention;
-
- if (show_type == META_TAB_SHOW_INSTANTLY ||
- !entries[i].hidden ||
- !meta_window_get_icon_geometry (window, &r))
- meta_window_get_outer_rect (window, &r);
-
- entries[i].rect = r;
-
- /* Find inside of highlight rectangle to be used when window is
- * outlined for tabbing. This should be the size of the
- * east/west frame, and the size of the south frame, on those
- * sides. On the top it should be the size of the south frame
- * edge.
- */
-#define OUTLINE_WIDTH 5
- /* Top side */
- if (!entries[i].hidden &&
- window->frame && window->frame->bottom_height > 0 &&
- window->frame->child_y >= window->frame->bottom_height)
- entries[i].inner_rect.y = window->frame->bottom_height;
- else
- entries[i].inner_rect.y = OUTLINE_WIDTH;
-
- /* Bottom side */
- if (!entries[i].hidden &&
- window->frame && window->frame->bottom_height != 0)
- entries[i].inner_rect.height = r.height
- - entries[i].inner_rect.y - window->frame->bottom_height;
- else
- entries[i].inner_rect.height = r.height
- - entries[i].inner_rect.y - OUTLINE_WIDTH;
-
- /* Left side */
- if (!entries[i].hidden && window->frame && window->frame->child_x != 0)
- entries[i].inner_rect.x = window->frame->child_x;
- else
- entries[i].inner_rect.x = OUTLINE_WIDTH;
-
- /* Right side */
- if (!entries[i].hidden &&
- window->frame && window->frame->right_width != 0)
- entries[i].inner_rect.width = r.width
- - entries[i].inner_rect.x - window->frame->right_width;
- else
- entries[i].inner_rect.width = r.width
- - entries[i].inner_rect.x - OUTLINE_WIDTH;
-
- ++i;
- tmp = tmp->next;
- }
-
- if (!meta_prefs_get_no_tab_popup ())
- screen->tab_popup = meta_ui_tab_popup_new (entries,
- screen->number,
- len,
- 5, /* FIXME */
- TRUE);
-
- for (i = 0; i < len; i++)
- g_object_unref (entries[i].icon);
-
- g_free (entries);
-
- g_list_free (tab_list);
-
- meta_ui_tab_popup_select (screen->tab_popup,
- (MetaTabEntryKey) initial_selection);
-
- if (show_type != META_TAB_SHOW_INSTANTLY)
- meta_ui_tab_popup_set_showing (screen->tab_popup, TRUE);
+ meta_alt_tab_handler_show (screen->tab_handler, initial_selection);
}
void
meta_screen_tab_popup_forward (MetaScreen *screen)
{
- g_return_if_fail (screen->tab_popup != NULL);
+ g_return_if_fail (screen->tab_handler != NULL);
- meta_ui_tab_popup_forward (screen->tab_popup);
+ meta_alt_tab_handler_forward (screen->tab_handler);
}
void
meta_screen_tab_popup_backward (MetaScreen *screen)
{
- g_return_if_fail (screen->tab_popup != NULL);
+ g_return_if_fail (screen->tab_handler != NULL);
- meta_ui_tab_popup_backward (screen->tab_popup);
+ meta_alt_tab_handler_backward (screen->tab_handler);
}
MetaWindow *
meta_screen_tab_popup_get_selected (MetaScreen *screen)
{
- g_return_val_if_fail (screen->tab_popup != NULL, NULL);
+ g_return_val_if_fail (screen->tab_handler != NULL, NULL);
- return (MetaWindow *) meta_ui_tab_popup_get_selected (screen->tab_popup);
+ return meta_alt_tab_handler_get_selected (screen->tab_handler);
}
void
meta_screen_tab_popup_destroy (MetaScreen *screen)
{
- if (screen->tab_popup)
- {
- meta_ui_tab_popup_free (screen->tab_popup);
- screen->tab_popup = NULL;
- }
+ g_return_if_fail (screen->tab_handler != NULL);
+
+ meta_alt_tab_handler_destroy (screen->tab_handler);
+ g_object_unref (screen->tab_handler);
+ screen->tab_handler = NULL;
}
void
-meta_screen_ensure_workspace_popup (MetaScreen *screen,
+meta_screen_workspace_popup_create (MetaScreen *screen,
MetaWorkspace *initial_selection)
{
MetaTabEntry *entries;
@@ -1584,8 +1494,7 @@ meta_screen_ensure_workspace_popup (MetaScreen *screen,
int n_workspaces;
int current_workspace;
- if (screen->ws_popup || meta_prefs_get_no_tab_popup ())
- return;
+ g_return_if_fail (screen->ws_popup == NULL);
current_workspace = meta_workspace_index (screen->active_workspace);
n_workspaces = meta_screen_get_n_workspaces (screen);
diff --git a/src/include/alttabhandler.h b/src/include/alttabhandler.h
new file mode 100644
index 0000000..8fce0d8
--- /dev/null
+++ b/src/include/alttabhandler.h
@@ -0,0 +1,73 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Metacity Alt-Tab abstraction */
+
+/*
+ * Copyright (C) 2009 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_ALT_TAB_HANDLER_H
+#define META_ALT_TAB_HANDLER_H
+
+#include <glib-object.h>
+
+#include "types.h"
+
+#define META_TYPE_ALT_TAB_HANDLER (meta_alt_tab_handler_get_type ())
+#define META_ALT_TAB_HANDLER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_ALT_TAB_HANDLER, MetaAltTabHandler))
+#define META_ALT_TAB_HANDLER_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), META_TYPE_ALT_TAB_HANDLER, MetaAltTabHandlerInterface))
+
+typedef struct _MetaAltTabHandler MetaAltTabHandler;
+typedef struct _MetaAltTabHandlerInterface MetaAltTabHandlerInterface;
+
+struct _MetaAltTabHandlerInterface {
+ GTypeInterface g_iface;
+
+ void (*add_window) (MetaAltTabHandler *handler,
+ MetaWindow *window);
+
+ void (*show) (MetaAltTabHandler *handler,
+ MetaWindow *initial_selection);
+ void (*destroy) (MetaAltTabHandler *handler);
+
+ void (*forward) (MetaAltTabHandler *handler);
+ void (*backward) (MetaAltTabHandler *handler);
+
+ MetaWindow * (*get_selected) (MetaAltTabHandler *handler);
+};
+
+GType meta_alt_tab_handler_get_type (void);
+
+void meta_alt_tab_handler_register (GType type);
+MetaAltTabHandler *meta_alt_tab_handler_new (MetaScreen *screen,
+ gboolean immediate);
+
+void meta_alt_tab_handler_add_window (MetaAltTabHandler *handler,
+ MetaWindow *window);
+
+void meta_alt_tab_handler_show (MetaAltTabHandler *handler,
+ MetaWindow *initial_selection);
+void meta_alt_tab_handler_destroy (MetaAltTabHandler *handler);
+
+void meta_alt_tab_handler_forward (MetaAltTabHandler *handler);
+void meta_alt_tab_handler_backward (MetaAltTabHandler *handler);
+
+MetaWindow *meta_alt_tab_handler_get_selected (MetaAltTabHandler *handler);
+
+#endif
+
diff --git a/src/include/alttabhandlerdefault.h b/src/include/alttabhandlerdefault.h
new file mode 100644
index 0000000..8cd0ebe
--- /dev/null
+++ b/src/include/alttabhandlerdefault.h
@@ -0,0 +1,55 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Metacity Alt-Tab abstraction: default implementation */
+
+/*
+ * Copyright (C) 2009 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_ALT_TAB_HANDLER_DEFAULT_H
+#define META_ALT_TAB_HANDLER_DEFAULT_H
+
+#include "alttabhandler.h"
+#include "tabpopup.h"
+
+#define META_TYPE_ALT_TAB_HANDLER_DEFAULT (meta_alt_tab_handler_default_get_type ())
+#define META_ALT_TAB_HANDLER_DEFAULT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_ALT_TAB_HANDLER_DEFAULT, MetaAltTabHandlerDefault))
+
+typedef struct _MetaAltTabHandlerDefault MetaAltTabHandlerDefault;
+typedef struct _MetaAltTabHandlerDefaultClass MetaAltTabHandlerDefaultClass;
+
+struct _MetaAltTabHandlerDefault {
+ GObject parent_instance;
+
+ MetaScreen *screen;
+
+ GArray *entries;
+ gboolean immediate_mode;
+
+ MetaTabPopup *tab_popup;
+};
+
+struct _MetaAltTabHandlerDefaultClass {
+ GObjectClass parent_class;
+
+};
+
+GType meta_alt_tab_handler_default_get_type (void);
+
+#endif
+
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
