+libexec_PROGRAMS=mate-window-picker-applet

+

+PKGDATADIR = $(datadir)/mate-window-picker-applet

+AM_CFLAGS=\

+ $(MATEWINDOWPICKER_DEPS_CFLAGS) \

+ $(GCC_FLAGS) \

+ -I$(top_builddir) \

+ -I$(top_srcdir) \

+ -D_GNU_SOURCE \

+ -DMATELOCALEDIR=\""$(datadir)/locale"\" \

+ -DPKGDATADIR=\"$(PKGDATADIR)\" \

+ -DMATEWINDOWPICKER_MENU_UI_DIR=\""$(xmluidir)"\"

+

+mate_window_picker_applet_LDADD = \

+ $(MATEWINDOWPICKER_DEPS_LIBS)

+

+mate_window_picker_applet_SOURCES = \

+ applet.c \

+ task-item.c \

+ task-item.h \

+ task-list.c \

+ task-list.h \

+ task-title.c \

+ task-title.h

+

+appletdir = $(datadir)/mate-panel/applets

+applet_in_files = org.mate.panel.MateWindowPicker.mate-panel-applet.in

+applet_DATA = $(applet_in_files:.mate-panel-applet.in=.mate-panel-applet)

+

+$(applet_in_files): $(applet_in_files).in Makefile

+ $(AM_V_GEN)sed \

+ -e "s|\@LOCATION\@|$(APPLET_LOCATION)|" \

+ $< > $@

+

+org.mate.panel.MateWindowPicker.mate-panel-applet: org.mate.panel.MateWindowPicker.mate-panel-applet.in $(INTLTOOL_MERGE) $(wildcard $(top_srcdir)/po/*po) ; $(INTLTOOL_MERGE) $(top_srcdir)/po $< $@ -d -u -c $(top_builddir)/po/.intltool-merge-cache

+

+APPLET_LOCATION=$(libexecdir)/mate-window-picker-applet

+

+servicedir = $(datadir)/dbus-1/services

+service_in_files = org.mate.panel.applet.MateWindowPickerFactory.service.in

+service_DATA = $(service_in_files:.service.in=.service)

+

+org.mate.panel.applet.MateWindowPickerFactory.service: $(service_in_files)

+ $(AM_V_GEN)sed \

+ -e "s|\@LOCATION\@|$(APPLET_LOCATION)|" \

+ $< > $@

+

+schemasdir = @MATECONF_SCHEMA_FILE_DIR@

+schemas_in_files = mate-window-picker-applet.schemas.in

+schemas_DATA = $(schemas_in_files:.schemas.in=.schemas)

+@INTLTOOL_SCHEMAS_RULE@

+

+xmluidir = $(datadir)/mate-panel/ui

+xmlui_DATA = mate-window-picker-applet-menu.xml

+

+EXTRA_DIST = \

+ org.mate.panel.MateWindowPicker.panel-applet.in.in \

+ $(service_in_files) \

+ $(ui_DATA) \

+ $(schemas_in_files)

+

+CLEANFILES = $(applet_DATA) $(applet_DATA).in $(service_DATA) $(schemas_DATA)

+

+clean:

+ rm -f $(desktop_DATA) $(desktop_DATA).in $(server_DATA) $(server_DATA).in

+/*

+ * Copyright (C) 2008 Canonical Ltd

+ *

+ * This program is free software: you can redistribute it and/or modify

+ * it under the terms of the GNU General Public License version 3 as

+ * published by the Free Software Foundation.

+ *

+ * This program is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

+ * GNU General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program. If not, see <http://www.gnu.org/licenses/>.

+ *

+ * Authored by Neil Jagdish Patel <[email protected]>

+ *

+ */

+

+#if HAVE_CONFIG_H

+#include <config.h>

+#endif

+

+#include <string.h>

+#include <stdlib.h>

+

+#include <glib.h>

+#include <glib/gi18n.h>

+#include <gtk/gtk.h>

+

+#include <libmatewnck/libmatewnck.h>

+

+#include <mate-panel-applet.h>

+#include <mate-panel-applet-mateconf.h>

+#include <mateconf/mateconf-client.h>

+

+#include "task-list.h"

+#include "task-title.h"

+

+#define SHOW_WIN_KEY "show_all_windows"

+

+typedef struct

+{

+ GtkWidget *tasks;

+ GtkWidget *applet;

+ GtkWidget *title;

+

+} WinPickerApp;

+

+static WinPickerApp *mainapp;

+

+static void cw_panel_background_changed (MatePanelApplet *applet,

+ MatePanelAppletBackgroundType type,

+ GdkColor *colour,

+ GdkPixmap *pixmap,

+ gpointer user_data);

+static void display_about_dialog (GtkAction *action,

+ WinPickerApp *applet);

+

+static void display_prefs_dialog (GtkAction *action,

+ WinPickerApp *applet);

+

+static const GtkActionEntry window_picker_menu_actions [] = {

+ { "MenuPrefs", GTK_STOCK_PREFERENCES, N_("_Preferences"),

+ NULL, NULL,

+ G_CALLBACK (display_prefs_dialog) },

+ { "ShowDesktopAbout", GTK_STOCK_ABOUT, N_("_About"),

+ NULL, NULL,

+ G_CALLBACK (display_about_dialog) }

+};

+

+static const gchar *close_window_authors [] = {

+ "Neil J. Patel <[email protected]>",

+ "Stefano Karapetsas <[email protected]>",

+ NULL

+};

+

+static void

+on_show_all_windows_changed (MateConfClient *client,

+ guint conn_id,

+ MateConfEntry *entry,

+ gpointer data)

+{

+ WinPickerApp *app;

+ gboolean show_windows = TRUE;

+

+ app = (WinPickerApp*)data;

+

+ show_windows = mate_panel_applet_mateconf_get_bool (MATE_PANEL_APPLET (app->applet),

+ SHOW_WIN_KEY, NULL);

+

+ g_object_set (app->tasks, "show_all_windows", show_windows, NULL);

+}

+

+static inline void

+force_no_focus_padding (GtkWidget *widget)

+{

+ static gboolean first_time = TRUE;

+

+ if (first_time)

+ {

+ gtk_rc_parse_string ("\n"

+ " style \"na-tray-style\"\n"

+ " {\n"

+ " GtkWidget::focus-line-width=0\n"

+ " GtkWidget::focus-padding=0\n"

+ " }\n"

+ "\n"

+ " widget \"*.na-tray\" style \"na-tray-style\"\n"

+ "\n");

+ first_time = FALSE;

+ }

+

+ gtk_widget_set_name (widget, "na-tray");

+}

+

+static gboolean

+cw_applet_fill (MatePanelApplet *applet,

+ const gchar *iid,

+ gpointer data)

+{

+ MatewnckScreen *screen;

+ WinPickerApp *app;

+ GtkWidget *eb, *tasks, *title;

+ GError *error = NULL;

+ gchar *key;

+ gchar *ui_path;

+ GtkActionGroup *action_group;

+

+ if (strcmp (iid, "MateWindowPicker") != 0)

+ return FALSE;

+

+ bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR);

+ bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");

+ textdomain (GETTEXT_PACKAGE);

+

+ matewnck_set_client_type (MATEWNCK_CLIENT_TYPE_PAGER);

+

+ app = g_slice_new0 (WinPickerApp);

+ mainapp = app;

+ screen = matewnck_screen_get_default ();

+

+ /* mateconf prefs */

+ mate_panel_applet_add_preferences (applet,

+ "/schemas/apps/mate-window-picker-applet/prefs",

+ &error);

+ if (error)

+ {

+ g_warning ("%s", error->message);

+ g_error_free (error);

+ }

+

+ key = mate_panel_applet_mateconf_get_full_key (applet, SHOW_WIN_KEY);

+ mateconf_client_notify_add (mateconf_client_get_default (), key,

+ on_show_all_windows_changed, app,

+ NULL, NULL);

+ g_free (key);

+

+ app->applet = GTK_WIDGET (applet);

+ force_no_focus_padding (GTK_WIDGET (applet));

+ gtk_container_set_border_width (GTK_CONTAINER (applet), 0);

+

+ eb = gtk_hbox_new (FALSE, 6);

+ gtk_container_add (GTK_CONTAINER (applet), eb);

+ gtk_container_set_border_width (GTK_CONTAINER (eb), 0);

+

+ tasks = app->tasks = task_list_get_default ();

+ gtk_box_pack_start (GTK_BOX (eb), tasks, FALSE, FALSE, 0);

+

+ title = app->title = task_title_new ();

+ gtk_box_pack_start (GTK_BOX (eb), title, TRUE, TRUE, 0);

+

+ gtk_widget_show_all (GTK_WIDGET (applet));

+

+ on_show_all_windows_changed (NULL, 0, NULL, app);

+

+ /* Signals */

+ g_signal_connect (applet, "change-background",

+ G_CALLBACK (cw_panel_background_changed), NULL);

+

+

+ action_group = gtk_action_group_new ("MateWindowPicker Applet Actions");

+ gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);

+ gtk_action_group_add_actions (action_group,

+ window_picker_menu_actions,

+ G_N_ELEMENTS (window_picker_menu_actions),

+ app);

+ ui_path = g_build_filename (MATEWINDOWPICKER_MENU_UI_DIR, "mate-window-picker-menu.xml", NULL);

+ mate_panel_applet_setup_menu_from_file (MATE_PANEL_APPLET (app->applet),

+ ui_path, action_group);

+ g_free (ui_path);

+ g_object_unref (action_group);

+

+ mate_panel_applet_set_flags (MATE_PANEL_APPLET (applet),

+ MATE_PANEL_APPLET_EXPAND_MAJOR

+ | MATE_PANEL_APPLET_EXPAND_MINOR

+ | MATE_PANEL_APPLET_HAS_HANDLE);

+

+ return TRUE;

+}

+

+MATE_PANEL_APPLET_OUT_PROCESS_FACTORY ("MateWindowPickerFactory",

+ PANEL_TYPE_APPLET,

+ "MateWindowPicker",

+ cw_applet_fill,

+ NULL);

+

+static void

+cw_panel_background_changed (MatePanelApplet *applet,

+ MatePanelAppletBackgroundType type,

+ GdkColor *colour,

+ GdkPixmap *pixmap,

+ gpointer user_data)

+{

+ GtkRcStyle *rc_style;

+ GtkStyle *style;

+

+ /* reset style */

+ gtk_widget_set_style (GTK_WIDGET (applet), NULL);

+ rc_style = gtk_rc_style_new ();

+ gtk_widget_modify_style (GTK_WIDGET (applet), rc_style);

+ gtk_rc_style_unref (rc_style);

+

+ gtk_widget_set_style (mainapp->title, NULL);

+ rc_style = gtk_rc_style_new ();

+ gtk_widget_modify_style (mainapp->title, rc_style);

+ gtk_rc_style_unref (rc_style);

+

+ switch (type)

+ {

+ case PANEL_NO_BACKGROUND:

+ break;

+ case PANEL_COLOR_BACKGROUND:

+ gtk_widget_modify_bg (GTK_WIDGET (applet), GTK_STATE_NORMAL, colour);

+ gtk_widget_modify_bg (mainapp->title, GTK_STATE_NORMAL, colour);

+ break;

+

+ case PANEL_PIXMAP_BACKGROUND:

+ style = gtk_style_copy (GTK_WIDGET (applet)->style);

+ if (style->bg_pixmap[GTK_STATE_NORMAL])

+ g_object_unref (style->bg_pixmap[GTK_STATE_NORMAL]);

+ style->bg_pixmap[GTK_STATE_NORMAL] = g_object_ref (pixmap);

+ gtk_widget_set_style (GTK_WIDGET (applet), style);

+ g_object_unref (style);

+

+ /*style = gtk_style_copy (mainapp->title->style);

+ if (style->bg_pixmap[GTK_STATE_NORMAL])

+ g_object_unref (style->bg_pixmap[GTK_STATE_NORMAL]);

+ style->bg_pixmap[GTK_STATE_NORMAL] = g_object_ref (pixmap);

+ gtk_widget_set_style (mainapp->title, style);

+ g_object_unref (style);*/

+

+ break;

+ }

+}

+

+static void

+display_about_dialog (GtkAction *action,

+ WinPickerApp *applet)

+{

+ GtkWidget *panel_about_dialog;

+

+ panel_about_dialog = gtk_about_dialog_new ();

+

+ g_object_set (panel_about_dialog,

+ "name", _("Window Picker"),

+ "comments", _("Window Picker"),

+ "version", PACKAGE_VERSION,

+ "authors", close_window_authors,

+ "logo-icon-name", "system-preferences-windows",

+ "copyright", "Copyright \xc2\xa9 2008 Canonical Ltd",

+ NULL);

+

+ gtk_widget_show (panel_about_dialog);

+

+ g_signal_connect (panel_about_dialog, "response",

+ G_CALLBACK (gtk_widget_destroy), NULL);

+

+

+ gtk_window_present (GTK_WINDOW (panel_about_dialog));

+}

+

+static void

+on_checkbox_toggled (GtkToggleButton *check, gpointer null)

+{

+ gboolean is_active;

+

+ is_active = gtk_toggle_button_get_active (check);

+

+ mate_panel_applet_mateconf_set_bool (MATE_PANEL_APPLET (mainapp->applet),

+ SHOW_WIN_KEY, is_active, NULL);

+}

+

+static void

+display_prefs_dialog (GtkAction *action,

+ WinPickerApp *applet)

+{

+ GtkWidget *window, *box, *vbox, *nb, *hbox, *label, *check, *button;

+

+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

+ gtk_window_set_title (GTK_WINDOW (window), _("Preferences"));

+ gtk_window_set_type_hint (GTK_WINDOW (window),

+ GDK_WINDOW_TYPE_HINT_DIALOG);

+ gtk_container_set_border_width (GTK_CONTAINER (window), 12);

+

+ box = gtk_vbox_new (FALSE, 8);

+ gtk_container_add (GTK_CONTAINER (window), box);

+

+ nb = gtk_notebook_new ();

+ g_object_set (nb, "show-tabs", FALSE, "show-border", TRUE, NULL);

+ gtk_box_pack_start (GTK_BOX (box), nb, TRUE, TRUE, 0);

+

+ vbox = gtk_vbox_new (FALSE, 8);

+ gtk_container_set_border_width (GTK_CONTAINER (vbox), 8);

+ gtk_notebook_append_page (GTK_NOTEBOOK (nb), vbox, NULL);

+

+ check = gtk_check_button_new_with_label (_("Show windows from all workspaces"));

+ gtk_box_pack_start (GTK_BOX (vbox), check, FALSE, TRUE, 0);

+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check),

+ mate_panel_applet_mateconf_get_bool (

+ MATE_PANEL_APPLET (mainapp->applet),

+ SHOW_WIN_KEY, NULL));

+ g_signal_connect (check, "toggled",

+ G_CALLBACK (on_checkbox_toggled), NULL);

+

+ check = gtk_label_new (" ");

+ gtk_box_pack_start (GTK_BOX (vbox), check, TRUE, TRUE, 0);

+

+ gtk_widget_set_size_request (nb, -1, 100);

+

+ hbox = gtk_hbox_new (FALSE, 0);

+ gtk_box_pack_start (GTK_BOX (box), hbox, TRUE, TRUE, 0);

+

+ label = gtk_label_new (" ");

+ gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);

+

+ button = gtk_button_new_from_stock (GTK_STOCK_CLOSE);

+ gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);

+

+ gtk_widget_show_all (window);

+

+ g_signal_connect (window, "delete-event",

+ G_CALLBACK (gtk_widget_destroy), window);

+

+ g_signal_connect (window, "destroy",

+ G_CALLBACK (gtk_widget_destroy), window);

+ g_signal_connect_swapped (button, "clicked",

+ G_CALLBACK (gtk_widget_destroy), window);

+

+ gtk_window_present (GTK_WINDOW (window));

+}

+<menuitem name="PreferencesItem" action="MenuPrefs" />

+<menuitem name="About Item" action="MenuAbout" />

+<mateconfschemafile>

+ <schemalist>

+ <schema>

+ <key>/schemas/apps/mate-window-picker-applet/prefs/show_all_windows</key>

+ <owner>mate-window-picker-applet</owner>

+ <type>bool</type>

+ <default>true</default>

+ <locale name="C">

+ <short>Show windows from all workspaces.</short>

+ </locale>

+ </schema>

+ </schemalist>

+</mateconfschemafile>

+[Applet Factory]

+Id=MateWindowPickerFactory

+Location=@LOCATION@

+_Name=Window Picker Applet Factory

+_Description=Window Picker

+

+[MateWindowPicker]

+_Name=Window Picker

+_Description=Window Picker

+Icon=preferences-system-windows

+BonoboId=OAFIID:MATE_WindowPicker

+[D-BUS Service]

+Name=org.mate.panel.applet.MateWindowPickerFactory

+Exec=@LOCATION@

+/*

+ * Copyright (C) 2008 Canonical Ltd

+ *

+ * This program is free software: you can redistribute it and/or modify

+ * it under the terms of the GNU General Public License version 3 as

+ * published by the Free Software Foundation.

+ *

+ * This program is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

+ * GNU General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program. If not, see <http://www.gnu.org/licenses/>.

+ *

+ * Authored by Jason Smith <[email protected]>

+ *

+ */

+

+#include "task-item.h"

+#include "task-list.h"

+

+#include <math.h>

+#include <glib/gi18n.h>

+#include <cairo/cairo.h>

+

+G_DEFINE_TYPE (TaskItem, task_item, GTK_TYPE_EVENT_BOX);

+

+#define TASK_ITEM_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj),\

+ TASK_TYPE_ITEM, \

+ TaskItemPrivate))

+

+#define DEFAULT_TASK_ITEM_HEIGHT 24;

+#define DEFAULT_TASK_ITEM_WIDTH 28

+

+struct _TaskItemPrivate

+{

+ MatewnckWindow *window;

+ MatewnckScreen *screen;

+ GdkPixbuf *pixbuf;

+ GdkRectangle area;

+

+ GTimeVal urgent_time;

+ guint timer;

+ gboolean mouse_over;

+};

+

+enum {

+ TASK_ITEM_CLOSED_SIGNAL,

+ LAST_SIGNAL

+};

+

+/* D&D stuff */

+static const GtkTargetEntry drop_types[] =

+{

+ { "STRING", 0, 0 },

+ { "text/plain", 0, 0},

+ { "text/uri-list", 0, 0}

+};

+static const gint n_drop_types = G_N_ELEMENTS(drop_types);

+

+static guint task_item_signals[LAST_SIGNAL] = { 0 };

+

+static void

+update_hints (TaskItem *item)

+{

+ GtkWidget *parent;

+ GtkWidget *widget;

+ MatewnckWindow *window;

+ gint x, y, x1, y1;

+

+ widget = GTK_WIDGET (item);

+ window = item->priv->window;

+ /* Skip problems */

+ if (!MATEWNCK_IS_WINDOW (window)) return;

+ if (!GTK_IS_WIDGET (widget)) return;

+

+ /* Skip invisible windows */

+ if (!GTK_WIDGET_VISIBLE (widget)) return;

+

+ x = y = 0;

+

+ /* Recursively compute the button's coordinates */

+ for (parent = widget; parent; parent = parent->parent)

+ {

+ if (parent->parent)

+ {

+ x += parent->allocation.x;

+ y += parent->allocation.y;

+ }

+ else

+ {

+ x1 = y1 = 0;

+ if (GDK_IS_WINDOW (parent->window))

+ gdk_window_get_origin (parent->window, &x1, &y1);

+ x += x1; y += y1;

+ break;

+ }

+ }

+

+ /* Set the minimize hint for the window */

+ matewnck_window_set_icon_geometry (window, x, y,

+ widget->allocation.width,

+ widget->allocation.height);

+}

+

+static gboolean

+on_task_item_button_released (GtkWidget *widget,

+ GdkEventButton *event,

+ TaskItem *item)

+{

+ MatewnckWindow *window;

+ MatewnckScreen *screen;

+ MatewnckWorkspace *workspace;

+ TaskItemPrivate *priv;

+

+ g_return_val_if_fail (TASK_IS_ITEM (item), TRUE);

+

+ priv = item->priv;

+ window = priv->window;

+

+ g_return_val_if_fail (MATEWNCK_IS_WINDOW (window), TRUE);

+

+ screen = priv->screen;

+ workspace = matewnck_window_get_workspace (window);

+

+ if (event->button == 1)

+ {

+

+ if (MATEWNCK_IS_WORKSPACE (workspace) && workspace != matewnck_screen_get_active_workspace (screen))

+ {

+ matewnck_workspace_activate (workspace, GDK_CURRENT_TIME);

+ }

+ if (matewnck_window_is_active (window))

+ {

+ matewnck_window_minimize (window);

+ }

+ else

+ {

+ matewnck_window_activate (window, GDK_CURRENT_TIME);

+ }

+ }

+ return TRUE;

+}

+

+static void

+task_item_set_visibility (TaskItem *item)

+{

+ MatewnckScreen *screen;

+ MatewnckWindow *window;

+ MatewnckWorkspace *workspace;

+

+ g_return_if_fail (TASK_IS_ITEM (item));

+

+ TaskItemPrivate *priv = item->priv;

+

+ if (!MATEWNCK_IS_WINDOW (priv->window))

+ {

+ gtk_widget_hide (GTK_WIDGET (item));

+ return;

+ }

+

+ window = priv->window;

+

+ screen = priv->screen;

+ workspace = matewnck_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 (matewnck_workspace_is_virtual (workspace))

+ {

+ show_window = matewnck_window_is_in_viewport (window, workspace);

+ }

+ else

+ {

+ show_window = matewnck_window_is_on_workspace (window, workspace);

+ }

+ show_window = show_window || show_all;

+ }

+

+ if (show_window)

+ {

+ gtk_widget_show (GTK_WIDGET (item));

+ }

+ else

+ {

+ gtk_widget_hide (GTK_WIDGET (item));

+ }

+}

+

+static void

+task_item_size_request (GtkWidget *widget,

+ GtkRequisition *requisition)

+{

+ /* Candidate for terrible hack of the year award */

+ requisition->width = DEFAULT_TASK_ITEM_WIDTH;

+ requisition->height = DEFAULT_TASK_ITEM_HEIGHT;

+}

+

+static GdkPixbuf *

+task_item_sized_pixbuf_for_window (TaskItem *item,

+ MatewnckWindow *window,

+ gint size)

+{

+ GdkPixbuf *pbuf = NULL;

+

+ g_return_val_if_fail (MATEWNCK_IS_WINDOW (window), NULL);

+

+ if (matewnck_window_has_icon_name (window))

+ {

+ const gchar *icon_name = matewnck_window_get_icon_name (window);

+ GtkIconTheme *icon_theme = gtk_icon_theme_get_default ();

+

+ if (gtk_icon_theme_has_icon (icon_theme, icon_name))

+ {

+ GdkPixbuf *internal = gtk_icon_theme_load_icon (icon_theme,

+ icon_name,

+ size,

+ GTK_ICON_LOOKUP_FORCE_SIZE,

+ NULL);

+ pbuf = gdk_pixbuf_copy (internal);

+ g_object_unref (internal);

+ }

+ }

+

+ if (!pbuf)

+ {

+ pbuf = gdk_pixbuf_copy (matewnck_window_get_icon (item->priv->window));

+ }

+

+ gint width = gdk_pixbuf_get_width (pbuf);

+ gint height = gdk_pixbuf_get_height (pbuf);

+

+ if (MAX (width, height) != size)

+ {

+ gdouble scale = (gdouble) size / (gdouble) MAX (width, height);

+

+ GdkPixbuf *tmp = pbuf;

+ pbuf = gdk_pixbuf_scale_simple (tmp, (gint) (width * scale), (gint) (height * scale), GDK_INTERP_HYPER);

+

+ g_object_unref (tmp);

+ }

+

+ return pbuf;

+}

+static gboolean

+task_item_expose_event (GtkWidget *widget,

+ GdkEventExpose *event)

+{

+ cairo_t *cr;

+ TaskItem *item;

+ GdkRectangle area;

+ TaskItemPrivate *priv;

+ GdkPixbuf *desat;

+ GdkPixbuf *pbuf;

+

+ g_return_val_if_fail (widget != NULL, FALSE);

+ g_return_val_if_fail (TASK_IS_ITEM (widget), FALSE);

+ g_return_val_if_fail (event != NULL, FALSE);

+

+ item = TASK_ITEM (widget);

+ priv = item->priv;

+

+ g_return_val_if_fail (MATEWNCK_IS_WINDOW (priv->window), FALSE);

+

+ area = priv->area;

+ cr = gdk_cairo_create (event->window);

+

+ pbuf = priv->pixbuf;

+ 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);

+

+ if (GDK_IS_PIXBUF (pbuf) &&

+ gdk_pixbuf_get_width (pbuf) != size &&

+ gdk_pixbuf_get_height (pbuf) != size)

+ {

+ g_object_unref (pbuf);

+ pbuf = NULL;

+ }

+

+ if (active)

+ {

+ cairo_rectangle (cr, area.x + .5, area.y - 4, area.width - 1, area.height + 8);

+ cairo_set_source_rgba (cr, .8, .8, .8, .2);

+ cairo_fill_preserve (cr);

+

+ cairo_set_line_width (cr, 1);

+ cairo_set_source_rgba (cr, .8, .8, .8, .4);

+ cairo_stroke (cr);

+ }

+

+ if (!pbuf)

+ {

+ pbuf = priv->pixbuf = task_item_sized_pixbuf_for_window (item, priv->window, size);

+ }

+

+ if (active || priv->mouse_over || attention)

+ {

+ gdk_cairo_set_source_pixbuf (cr,

+ pbuf,

+ (area.x + (area.width - gdk_pixbuf_get_width (pbuf)) / 2),

+ (area.y + (area.height - gdk_pixbuf_get_height (pbuf)) / 2));

+ }

+ else

+ {

+ desat = gdk_pixbuf_new (GDK_COLORSPACE_RGB,

+ TRUE,

+ gdk_pixbuf_get_bits_per_sample (pbuf),

+ gdk_pixbuf_get_width (pbuf),

+ gdk_pixbuf_get_height (pbuf));

+

+ if (desat)

+ {

+ gdk_pixbuf_saturate_and_pixelate (pbuf,

+ desat,

+ 0,

+ FALSE);

+ }

+ else /* just paint the colored version as a fallback */

+ {

+ desat = pbuf;

+ }

+ gdk_cairo_set_source_pixbuf (cr,

+ desat,

+ (area.x + (area.width - gdk_pixbuf_get_width (desat)) / 2),

+ (area.y + (area.height - gdk_pixbuf_get_height (desat)) / 2));

+ }

+ if (!priv->mouse_over && attention) /* urgent */

+ {

+ GTimeVal current_time;

+ g_get_current_time (&current_time);

+

+ gdouble ms = (current_time.tv_sec - priv->urgent_time.tv_sec) * 1000 +

+ (current_time.tv_usec - priv->urgent_time.tv_usec) / 1000;

+

+ gdouble alpha = .66 + (cos (3.15 * ms / 600) / 3);

+ cairo_paint_with_alpha (cr, alpha);

+ }

+ else if (priv->mouse_over || active) /* focused */

+ {

+ cairo_paint (cr);

+ }

+ else /* not focused */

+ {

+ cairo_paint_with_alpha (cr, .65);

+ }

+

+ if (GDK_IS_PIXBUF (desat))

+ g_object_unref (desat);

+

+ cairo_destroy (cr);

+

+ return FALSE;

+}

+

+static void

+on_size_allocate (GtkWidget *widget,

+ GtkAllocation *allocation,

+ TaskItem *item)

+{

+ TaskItemPrivate *priv;

+

+ if (allocation->width != allocation->height + 6)

+ gtk_widget_set_size_request (widget, allocation->height + 6, -1);

+

+ g_return_if_fail (TASK_IS_ITEM (item));

+

+ priv = item->priv;

+ priv->area.x = allocation->x;

+ priv->area.y = allocation->y;

+ priv->area.width = allocation->width;

+ priv->area.height = allocation->height;

+

+ update_hints (item);

+}

+

+static gboolean

+on_button_pressed (GtkWidget *button,

+ GdkEventButton *event,

+ TaskItem *item)

+{

+ MatewnckWindow *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);

+

+ if (event->button == 3)

+ {

+ GtkWidget *menu = matewnck_action_menu_new (window);

+ gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL,

+ event->button, event->time);

+ return TRUE;

+ }

+

+ return FALSE;

+}

+

+static gboolean

+on_query_tooltip (GtkWidget *widget,

+ gint x, gint y,

+ gboolean keyboard_mode,

+ GtkTooltip *tooltip,

+ TaskItem *item)

+{

+ MatewnckWindow *window = item->priv->window;

+ g_return_val_if_fail (MATEWNCK_IS_WINDOW (window), FALSE);

+

+ gtk_tooltip_set_text (tooltip, matewnck_window_get_name(window));

+ gtk_tooltip_set_icon (tooltip, matewnck_window_get_icon (window));

+

+ return TRUE;

+}

+

+static gboolean

+on_enter_notify (GtkWidget *widget,

+ GdkEventCrossing *event,

+ TaskItem *item)

+{

+ g_return_val_if_fail (TASK_IS_ITEM (item), FALSE);

+

+ item->priv->mouse_over = TRUE;

+ gtk_widget_queue_draw (widget);

+

+ return FALSE;

+}

+

+static gboolean

+on_leave_notify (GtkWidget *widget,

+ GdkEventCrossing *event,

+ TaskItem *item)

+{

+ g_return_val_if_fail (TASK_IS_ITEM (item), FALSE);

+

+ item->priv->mouse_over = FALSE;

+ gtk_widget_queue_draw (widget);

+

+ return FALSE;

+}

+

+static gboolean

+on_blink (TaskItem *item)

+{

+ g_return_val_if_fail (TASK_IS_ITEM (item), FALSE);

+

+ gtk_widget_queue_draw (GTK_WIDGET (item));

+

+ if (matewnck_window_or_transient_needs_attention (item->priv->window))

+ {

+ return TRUE;

+ }

+ else

+ {

+ item->priv->timer = 0;

+ return FALSE;

+ }

+}

+

+static void

+on_window_state_changed (MatewnckWindow *window,

+ MatewnckWindowState changed_mask,

+ MatewnckWindowState new_state,

+ TaskItem *item)

+{

+ g_return_if_fail (MATEWNCK_IS_WINDOW (window));

+ g_return_if_fail (TASK_IS_ITEM (item));

+

+ TaskItemPrivate *priv = item->priv;

+

+ if (new_state & MATEWNCK_WINDOW_STATE_URGENT && !priv->timer)

+ {

+ priv->timer = g_timeout_add (30, (GSourceFunc)on_blink, item);

+ g_get_current_time (&priv->urgent_time);

+ }

+

+ task_item_set_visibility (item);

+}

+

+static void

+on_window_workspace_changed (MatewnckWindow *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)

+{

+ TaskItemPrivate *priv;

+

+ g_return_if_fail (TASK_IS_ITEM (item));

+

+ priv = item->priv;

+

+ if (GDK_IS_PIXBUF (priv->pixbuf))

+ {

+ g_object_unref (priv->pixbuf);

+ priv->pixbuf = NULL;

+ }

+

+ gtk_widget_queue_draw (GTK_WIDGET (item));

+}

+

+static void

+on_screen_active_window_changed (MatewnckScreen *screen,

+ MatewnckWindow *old_window,

+ TaskItem *item)

+{

+ MatewnckWindow *window;

+ TaskItemPrivate *priv;

+

+ g_return_if_fail (TASK_IS_ITEM (item));

+

+ priv = item->priv;

+ window = priv->window;

+

+ g_return_if_fail (MATEWNCK_IS_WINDOW (window));

+

+ if ((MATEWNCK_IS_WINDOW (old_window) && window == old_window) ||

+ window == matewnck_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));

+ }

+}

+

+static void

+on_screen_active_workspace_changed (MatewnckScreen *screen,

+ MatewnckWorkspace *old_workspace,

+ TaskItem *item)

+{

+ g_return_if_fail (TASK_IS_ITEM (item));

+

+ task_item_set_visibility (item);

+}

+

+static void

+on_screen_active_viewport_changed (MatewnckScreen *screen,

+ TaskItem *item)

+{

+ g_return_if_fail (TASK_IS_ITEM (item));

+

+ task_item_set_visibility (item);

+}

+

+static void

+on_screen_window_closed (MatewnckScreen *screen,

+ MatewnckWindow *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));

+

+ if (priv->window == window)

+ {

+ g_signal_handlers_disconnect_by_func (screen, G_CALLBACK (on_screen_window_closed), item);

+ g_signal_handlers_disconnect_by_func (screen, G_CALLBACK (on_screen_active_window_changed), item);

+ g_signal_handlers_disconnect_by_func (screen, G_CALLBACK (on_screen_active_workspace_changed), item);

+ g_signal_handlers_disconnect_by_func (screen, G_CALLBACK (on_screen_window_closed), item);

+ g_signal_handlers_disconnect_by_func (window, G_CALLBACK (on_window_workspace_changed), item);

+ g_signal_handlers_disconnect_by_func (window, G_CALLBACK (on_window_state_changed), item);

+

+ g_signal_emit (G_OBJECT (item), task_item_signals[TASK_ITEM_CLOSED_SIGNAL], 0);

+ }

+}

+

+static gboolean

+activate_window (GtkWidget *widget)

+{

+ gint active;

+ TaskItemPrivate *priv;

+

+ g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);

+ g_return_val_if_fail (TASK_IS_ITEM (widget), FALSE);

+

+ priv = TASK_ITEM (widget)->priv;

+

+ g_return_val_if_fail (MATEWNCK_IS_WINDOW (priv->window), FALSE);

+

+ active = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget), "drag-true"));

+

+ if (active)

+ {

+ MatewnckWindow *window;

+

+ window = priv->window;

+ if (MATEWNCK_IS_WINDOW (window))

+ matewnck_window_activate (window, time (NULL));

+ }

+

+ g_object_set_data (G_OBJECT (widget), "drag-true", GINT_TO_POINTER (0));

+

+ return FALSE;

+}

+

+static void

+on_drag_leave (GtkWidget *item,

+ GdkDragContext *context,

+ guint time)

+{

+ g_object_set_data (G_OBJECT (item), "drag-true", GINT_TO_POINTER (0));

+}

+

+static gboolean

+on_drag_motion (GtkWidget *item,

+ GdkDragContext *context,

+ gint x,

+ gint y,

+ guint t)

+{

+ gint active;

+

+ active = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (item), "drag-true"));

+

+ if (!active)

+ {

+ g_object_set_data (G_OBJECT (item), "drag-true", GINT_TO_POINTER (1));

+

+ g_timeout_add (1000, (GSourceFunc)activate_window, item);

+ }

+

+ return FALSE;

+}

+

+static void

+task_item_setup_atk (TaskItem *item)

+{

+ TaskItemPrivate *priv;

+ GtkWidget *widget;

+ AtkObject *atk;

+ MatewnckWindow *window;

+

+ g_return_if_fail (TASK_IS_ITEM (item));

+

+ widget = GTK_WIDGET (item);

+ priv = item->priv;

+ window = priv->window;

+

+ g_return_if_fail (MATEWNCK_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_role (atk, ATK_ROLE_PUSH_BUTTON);

+}

+

+static void

+task_item_finalize (GObject *object)

+{

+ TaskItemPrivate *priv;

+ priv = TASK_ITEM_GET_PRIVATE (object);

+

+ /* remove timer */

+ if (priv->timer)

+ {

+ g_source_remove (priv->timer);

+ }

+

+ if (GDK_IS_PIXBUF (priv->pixbuf))

+ {

+ g_object_unref (priv->pixbuf);

+ }

+

+ G_OBJECT_CLASS (task_item_parent_class)->finalize (object);

+}

+

+static void

+task_item_class_init (TaskItemClass *klass)

+{

+ GObjectClass *obj_class = G_OBJECT_CLASS (klass);

+ GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);

+

+ obj_class->finalize = task_item_finalize;

+ widget_class->expose_event = task_item_expose_event;

+ widget_class->size_request = task_item_size_request;

+

+ g_type_class_add_private (obj_class, sizeof (TaskItemPrivate));

+

+ task_item_signals [TASK_ITEM_CLOSED_SIGNAL] =

+ g_signal_new ("task-item-closed",

+ G_TYPE_FROM_CLASS (klass),

+ G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,

+ G_STRUCT_OFFSET (TaskItemClass, itemclosed),

+ NULL, NULL,

+ g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);

+}

+

+static void

+task_item_init (TaskItem *item)

+{

+ TaskItemPrivate *priv;

+ priv = item->priv = TASK_ITEM_GET_PRIVATE (item);

+

+ priv->timer = 0;

+}

+

+GtkWidget *

+task_item_new (MatewnckWindow *window)

+{

+ GtkWidget *item = NULL;

+ TaskItem *task;

+ TaskItemPrivate *priv;

+ MatewnckScreen *screen;

+

+ g_return_val_if_fail (MATEWNCK_IS_WINDOW (window), item);

+

+ item = g_object_new (TASK_TYPE_ITEM,

+ "has-tooltip", TRUE,

+ "visible-window", FALSE,

+ "above-child", TRUE,

+ NULL);

+

+ gtk_widget_add_events (item, GDK_ALL_EVENTS_MASK);

+ gtk_container_set_border_width (GTK_CONTAINER (item), 0);

+

+ task = TASK_ITEM (item);

+ priv = task->priv;

+ priv->window = window;

+

+ screen = matewnck_window_get_screen (window);

+ priv->screen = screen;

+

+ gtk_drag_dest_set (item,

+ GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_DROP,

+ drop_types, n_drop_types,

+ GDK_ACTION_COPY);

+ gtk_drag_dest_add_uri_targets (item);

+ gtk_drag_dest_add_text_targets (item);

+ g_signal_connect (item, "drag-motion",

+ G_CALLBACK (on_drag_motion), NULL);

+ g_signal_connect (item, "drag-leave",

+ G_CALLBACK (on_drag_leave), NULL);

+

+ g_signal_connect (screen, "viewports-changed",

+ G_CALLBACK (on_screen_active_viewport_changed), item);

+ g_signal_connect (screen, "active-window-changed",

+ G_CALLBACK (on_screen_active_window_changed), item);

+ g_signal_connect (screen, "active-workspace-changed",

+ G_CALLBACK (on_screen_active_workspace_changed), item);

+ g_signal_connect (screen, "window-closed",

+ G_CALLBACK (on_screen_window_closed), item);

+

+ g_signal_connect (window, "workspace-changed",

+ G_CALLBACK (on_window_workspace_changed), item);

+ g_signal_connect (window, "state-changed",

+ G_CALLBACK (on_window_state_changed), item);

+ g_signal_connect (window, "icon-changed",

+ G_CALLBACK (on_window_icon_changed), item);

+

+ g_signal_connect (item, "button-release-event",

+ G_CALLBACK (on_task_item_button_released), item);

+ g_signal_connect (item, "button-press-event",

+ G_CALLBACK (on_button_pressed), item);

+ g_signal_connect (item, "size-allocate",

+ G_CALLBACK (on_size_allocate), item);

+ g_signal_connect (item, "query-tooltip",

+ G_CALLBACK (on_query_tooltip), item);

+ g_signal_connect (item, "enter-notify-event",

+ G_CALLBACK (on_enter_notify), item);

+ g_signal_connect (item, "leave-notify-event",

+ G_CALLBACK (on_leave_notify), item);

+ g_signal_connect (item, "drag-motion",

+ G_CALLBACK (on_drag_motion), item);

+ g_signal_connect (item, "drag-leave",

+ G_CALLBACK (on_drag_leave), item);

+

+ task_item_set_visibility (task);

+ task_item_setup_atk (task);

+

+ return item;

+}

+/*

+ * Copyright (C) 2008 Canonical Ltd

+ *

+ * This program is free software: you can redistribute it and/or modify

+ * it under the terms of the GNU General Public License version 3 as

+ * published by the Free Software Foundation.

+ *

+ * This program is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

+ * GNU General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program. If not, see <http://www.gnu.org/licenses/>.

+ *

+ * Authored by: Neil Jagdish Patel <[email protected]>

+ * Jason Smith <[email protected]>

+ *

+ */

+

+#ifndef _TASK_ITEM_H_

+#define _TASK_ITEM_H_

+

+#include <glib.h>

+#include <gtk/gtk.h>

+#include <libmatewnck/libmatewnck.h>

+

+#define TASK_TYPE_ITEM (task_item_get_type ())

+

+#define TASK_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj),\

+ TASK_TYPE_ITEM, TaskItem))

+

+#define TASK_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass),\

+ TASK_TYPE_ITEM, TaskItemClass))

+

+#define TASK_IS_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj),\

+ TASK_TYPE_ITEM))

+

+#define TASK_IS_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),\

+ TASK_TYPE_ITEM))

+

+#define TASK_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj),\

+ TASK_TYPE_ITEM, TaskItemClass))

+

+typedef struct _TaskItem TaskItem;

+typedef struct _TaskItemClass TaskItemClass;

+typedef struct _TaskItemPrivate TaskItemPrivate;

+

+struct _TaskItem

+{

+ GtkEventBox parent;

+

+ TaskItemPrivate *priv;

+};

+

+struct _TaskItemClass

+{

+ GtkEventBoxClass parent_class;

+

+ void (* itemclosed) (TaskItem *item);

+};

+

+GType task_item_get_type (void) G_GNUC_CONST;

+

+GtkWidget * task_item_new (MatewnckWindow *window);

+

+GtkWidget * task_item_get_default (void);

+

+gboolean task_item_get_desktop_visible (TaskItem *item);

+

+#endif /* _TASK_ITEM_H_ */

+

+/*

+ * Copyright (C) 2008 Canonical Ltd

+ *

+ * This program is free software: you can redistribute it and/or modify

+ * it under the terms of the GNU General Public License version 3 as

+ * published by the Free Software Foundation.

+ *

+ * This program is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

+ * GNU General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program. If not, see <http://www.gnu.org/licenses/>.

+ *

+ * Authored by Neil Jagdish Patel <[email protected]>

+ *

+ */

+

+#include "task-list.h"

+#include "task-item.h"

+

+#include <libmatewnck/libmatewnck.h>

+

+G_DEFINE_TYPE (TaskList, task_list, GTK_TYPE_HBOX);

+

+#define TASK_LIST_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj),\

+ TASK_TYPE_LIST, \

+ TaskListPrivate))

+

+struct _TaskListPrivate

+{

+ MatewnckScreen *screen;

+ GHashTable *win_table;

+ guint timer;

+ guint counter;

+

+ gboolean show_all_windows;

+};

+

+enum

+{

+ PROP_0,

+

+ PROP_SHOW_ALL_WINDOWS

+};

+

+static void

+task_list_set_show_all_windows (TaskList *list, gboolean show_all_windows)

+{

+ TaskListPrivate *priv = list->priv;

+

+ priv->show_all_windows = show_all_windows;

+

+ g_debug ("Show all windows: %s", show_all_windows ? "true" : "false");

+}

+

+static void

+on_task_item_closed (TaskItem *item,

+ TaskList *list)

+{

+ gtk_container_remove (GTK_CONTAINER (list),

+ GTK_WIDGET (item));

+ gtk_widget_destroy (GTK_WIDGET (item));

+}

+

+static void

+on_window_opened (MatewnckScreen *screen,

+ MatewnckWindow *window,

+ TaskList *list)

+{

+ TaskListPrivate *priv;

+ MatewnckWindowType type;

+

+ g_return_if_fail (TASK_IS_LIST (list));

+ priv = list->priv;

+

+ type = matewnck_window_get_window_type (window);

+

+ if (type == MATEWNCK_WINDOW_DESKTOP

+ || type == MATEWNCK_WINDOW_DOCK

+ || type == MATEWNCK_WINDOW_SPLASHSCREEN

+ || type == MATEWNCK_WINDOW_MENU)

+ return;

+

+ GtkWidget *item = task_item_new (window);

+

+ if (item)

+ {

+ gtk_box_pack_start (GTK_BOX (list), item, FALSE, FALSE, 0);

+ g_signal_connect (TASK_ITEM (item), "task-item-closed",

+ G_CALLBACK (on_task_item_closed), list);

+ }

+}

+

+/* GObject stuff */

+static void

+task_list_finalize (GObject *object)

+{

+ TaskListPrivate *priv;

+

+ priv = TASK_LIST_GET_PRIVATE (object);

+

+ /* Remove the blink timer */

+ if (priv->timer) g_source_remove (priv->timer);

+

+ G_OBJECT_CLASS (task_list_parent_class)->finalize (object);

+}

+

+static void

+task_list_get_property (GObject *object,

+ guint prop_id,

+ GValue *value,

+ GParamSpec *pspec)

+{

+ TaskList *list = TASK_LIST (object);

+ TaskListPrivate *priv;

+

+ g_return_if_fail (TASK_IS_LIST (list));

+ priv = list->priv;

+

+ switch (prop_id)

+ {

+ case PROP_SHOW_ALL_WINDOWS:

+ g_value_set_boolean (value, priv->show_all_windows);

+ break;

+ default:

+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

+ }

+}

+

+static void

+task_list_set_property (GObject *object,

+ guint prop_id,

+ const GValue *value,

+ GParamSpec *pspec)

+{

+ TaskList *list = TASK_LIST (object);

+ TaskListPrivate *priv;

+

+ g_return_if_fail (TASK_IS_LIST (list));

+ priv = list->priv;

+

+ switch (prop_id)

+ {

+ case PROP_SHOW_ALL_WINDOWS:

+ task_list_set_show_all_windows (list, g_value_get_boolean (value));

+ break;

+ default:

+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

+ }

+}

+

+static void

+task_list_class_init (TaskListClass *klass)

+{

+ GObjectClass *obj_class = G_OBJECT_CLASS (klass);

+

+ obj_class->finalize = task_list_finalize;

+ obj_class->set_property = task_list_set_property;

+ obj_class->get_property = task_list_get_property;

+

+ g_object_class_install_property (obj_class,

+ PROP_SHOW_ALL_WINDOWS,

+ g_param_spec_boolean ("show_all_windows",

+ "Show All Windows",

+ "Show windows from all workspaces",

+ TRUE,

+ G_PARAM_READWRITE | G_PARAM_CONSTRUCT));

+

+ g_type_class_add_private (obj_class, sizeof (TaskListPrivate));

+}

+

+static void

+task_list_init (TaskList *list)

+{

+ TaskListPrivate *priv;

+

+ priv = list->priv = TASK_LIST_GET_PRIVATE (list);

+

+ priv->screen = matewnck_screen_get_default ();

+

+ priv->win_table = g_hash_table_new (NULL, NULL);

+

+ /* No blink timer */

+ priv->timer = 0;

+

+ gtk_container_set_border_width (GTK_CONTAINER (list), 0);

+

+ g_signal_connect (priv->screen, "window-opened",

+ G_CALLBACK (on_window_opened), list);

+}

+

+GtkWidget *

+task_list_new (void)

+

+{

+ GtkWidget *list = NULL;

+

+ list = g_object_new (TASK_TYPE_LIST,

+ "homogeneous", FALSE,

+ "spacing", 0,

+ NULL);

+

+ return list;

+}

+

+GtkWidget *

+task_list_get_default (void)

+{

+ static GtkWidget *list = NULL;

+

+ if (!list)

+ list = task_list_new ();

+

+ return list;

+}

+

+gboolean

+task_list_get_desktop_visible (TaskList *list)

+{

+ GList *windows, *w;

+ gboolean all_minimised = TRUE;

+

+ g_return_val_if_fail (TASK_IS_LIST (list), TRUE);

+

+ windows = matewnck_screen_get_windows (list->priv->screen);

+ for (w = windows; w; w = w->next)

+ {

+ MatewnckWindow *window;

+

+ window = w->data;

+

+ if (MATEWNCK_IS_WINDOW (window) && !matewnck_window_is_minimized (window))

+ all_minimised = FALSE;

+ }

+

+ return all_minimised;

+}

+

+gboolean

+task_list_get_show_all_windows (TaskList *list)

+{

+ return list->priv->show_all_windows;

+}

+

+/*

+ * Copyright (C) 2008 Canonical Ltd

+ *

+ * This program is free software: you can redistribute it and/or modify

+ * it under the terms of the GNU General Public License version 3 as

+ * published by the Free Software Foundation.

+ *

+ * This program is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

+ * GNU General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program. If not, see <http://www.gnu.org/licenses/>.

+ *

+ * Authored by Neil Jagdish Patel <[email protected]>

+ *

+ */

+

+#ifndef _TASK_LIST_H_

+#define _TASK_LIST_H_

+

+#include <glib.h>

+#include <gtk/gtk.h>

+

+#define TASK_TYPE_LIST (task_list_get_type ())

+

+#define TASK_LIST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj),\

+ TASK_TYPE_LIST, TaskList))

+

+#define TASK_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass),\

+ TASK_TYPE_LIST, TaskListClass))

+

+#define TASK_IS_LIST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj),\

+ TASK_TYPE_LIST))

+

+#define TASK_IS_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),\

+ TASK_TYPE_LIST))

+

+#define TASK_LIST_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj),\

+ TASK_TYPE_LIST, TaskListClass))

+

+typedef struct _TaskList TaskList;

+typedef struct _TaskListClass TaskListClass;

+typedef struct _TaskListPrivate TaskListPrivate;

+

+struct _TaskList

+{

+ GtkHBox parent;

+

+ TaskListPrivate *priv;

+};

+

+struct _TaskListClass

+{

+ GtkHBoxClass parent_class;

+};

+

+GType task_list_get_type (void) G_GNUC_CONST;

+

+GtkWidget * task_list_new (void);

+

+GtkWidget * task_list_get_default (void);

+

+gboolean task_list_get_desktop_visible (TaskList *list);

+

+gboolean task_list_get_show_all_windows (TaskList *list);

+

+#endif /* _TASK_LIST_H_ */

+

+/*

+ * Copyright (C) 2008 Canonical Ltd

+ *

+ * This program is free software: you can redistribute it and/or modify

+ * it under the terms of the GNU General Public License version 3 as

+ * published by the Free Software Foundation.

+ *

+ * This program is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

+ * GNU General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program. If not, see <http://www.gnu.org/licenses/>.

+ *

+ * Authored by Neil Jagdish Patel <[email protected]>

+ *

+ */

+

+#include "task-title.h"

+

+#include <libmatewnck/libmatewnck.h>

+#include <mate-panel-applet.h>

+#include <mate-panel-applet-mateconf.h>

+

+#include <mateconf/mateconf.h>

+#include <mateconf/mateconf-client.h>

+

+#include "task-list.h"

+

+G_DEFINE_TYPE (TaskTitle, task_title, GTK_TYPE_EVENT_BOX);

+

+#define TASK_TITLE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj),\

+ TASK_TYPE_TITLE, \

+ TaskTitlePrivate))

+

+#define LOGOUT "mate-session-save --kill --gui"

+#define SHOW_HOME_TITLE_KEY "/apps/window-picker-applet/show_home_title"

+

+struct _TaskTitlePrivate

+{

+ MatewnckScreen *screen;

+ MatewnckWindow *window;

+ GtkWidget *align;

+ GtkWidget *box;

+ GtkWidget *label;

+ GtkWidget *button;

+ GtkWidget *button_image;

+ GdkPixbuf *quit_icon;

+

+ gboolean show_home_title;

+ gboolean mouse_in_close_button;

+};

+

+static void disconnect_window (TaskTitle *title);

+

+static gboolean

+on_close_clicked (GtkButton *button,

+ GdkEventButton *event,

+ TaskTitle *title)

+{

+ TaskTitlePrivate *priv;

+ MatewnckWindow *window;

+

+ g_return_val_if_fail (TASK_IS_TITLE (title), FALSE);

+ priv = title->priv;

+

+ if (event->button != 1 || !priv->mouse_in_close_button)

+ return FALSE;

+

+ window = matewnck_screen_get_active_window (priv->screen);

+

+ if (!MATEWNCK_IS_WINDOW (window)

+ || matewnck_window_get_window_type (window) == MATEWNCK_WINDOW_DESKTOP)

+ {

+ gdk_spawn_command_line_on_screen (gdk_screen_get_default (),

+ LOGOUT, NULL);

+ }

+ else

+ {

+ if (priv->window == window)

+ disconnect_window (title);

+ matewnck_window_close (window, GDK_CURRENT_TIME);

+ }

+ gtk_widget_queue_draw (GTK_WIDGET (title));

+

+ return TRUE;

+}

+

+static gboolean

+on_enter_notify (GtkWidget *widget,

+ GdkEventCrossing *event,

+ TaskTitle *title)

+{

+ g_return_val_if_fail (TASK_IS_TITLE (title), FALSE);

+

+ title->priv->mouse_in_close_button = TRUE;

+ gtk_widget_queue_draw (widget);

+

+ return FALSE;

+}

+

+static gboolean

+on_leave_notify (GtkWidget *widget,

+ GdkEventCrossing *event,

+ TaskTitle *title)

+{

+ g_return_val_if_fail (TASK_IS_TITLE (title), FALSE);

+

+ title->priv->mouse_in_close_button = FALSE;

+ gtk_widget_queue_draw (widget);

+

+ return FALSE;

+}

+

+static gboolean

+on_button_expose (GtkWidget *widget,

+ GdkEventExpose *event,

+ TaskTitle *title)

+{

+ g_return_val_if_fail (TASK_IS_TITLE (title), FALSE);

+

+ TaskTitlePrivate *priv;

+ priv = title->priv;

+

+ if (priv->mouse_in_close_button)

+ {

+ GtkStyle *style = gtk_widget_get_style (widget);

+ gtk_paint_box (style,

+ event->window,

+ GTK_STATE_PRELIGHT,

+ GTK_SHADOW_NONE,

+ NULL,

+ NULL,

+ NULL,

+ event->area.x,

+ event->area.y + 2,

+ event->area.width,

+ event->area.height - 4);

+ }

+ return FALSE;

+}

+

+static void

+on_name_changed (MatewnckWindow *window, TaskTitle *title)

+{

+ TaskTitlePrivate *priv;

+

+ g_return_if_fail (TASK_IS_TITLE (title));

+ g_return_if_fail (MATEWNCK_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));

+ gtk_widget_set_tooltip_text (GTK_WIDGET (title),

+ matewnck_window_get_name (window));

+ gtk_widget_queue_draw (GTK_WIDGET (title));

+}

+

+

+static void

+on_icon_changed (MatewnckWindow *window, TaskTitle *title)

+{

+ TaskTitlePrivate *priv;

+

+ g_return_if_fail (TASK_IS_TITLE (title));

+ g_return_if_fail (MATEWNCK_IS_WINDOW (window));

+

+ priv = title->priv;

+ if (priv->window != window)

+ return;

+

+ gtk_widget_queue_draw (GTK_WIDGET (title));

+}

+

+static void

+on_state_changed (MatewnckWindow *window,

+ MatewnckWindowState changed_mask,

+ MatewnckWindowState new_state,

+ TaskTitle *title)

+{

+ TaskTitlePrivate *priv;

+

+ g_return_if_fail (TASK_IS_TITLE (title));

+ g_return_if_fail (MATEWNCK_IS_WINDOW (window));

+

+ priv = title->priv;

+ if (priv->window != window)

+ return;

+

+ if (matewnck_window_is_maximized (window))

+ {

+ gtk_widget_set_state (GTK_WIDGET (title), GTK_STATE_ACTIVE);

+ gtk_widget_show (priv->box);

+ }

+ else

+ {

+ gtk_widget_set_state (GTK_WIDGET (title), GTK_STATE_NORMAL);

+ gtk_widget_hide (priv->box);

+ }

+}

+

+static void

+disconnect_window (TaskTitle *title)

+{

+ TaskTitlePrivate *priv = title->priv;

+ if (!priv->window)

+ return;

+ g_signal_handlers_disconnect_by_func (priv->window, on_name_changed, title);

+ g_signal_handlers_disconnect_by_func (priv->window, on_icon_changed, title);

+ g_signal_handlers_disconnect_by_func (priv->window, on_state_changed, title);

+ priv->window = NULL;

+}

+

+static void

+on_active_window_changed (MatewnckScreen *screen,

+ MatewnckWindow *old_window,

+ TaskTitle *title)

+{

+ TaskTitlePrivate *priv;

+ MatewnckWindow *act_window;

+ MatewnckWindowType type = MATEWNCK_WINDOW_NORMAL;

+

+ g_return_if_fail (TASK_IS_TITLE (title));

+ priv = title->priv;

+

+ act_window = matewnck_screen_get_active_window (screen);

+ if (act_window)

+ type = matewnck_window_get_window_type (act_window);

+

+ if (MATEWNCK_IS_WINDOW (act_window)

+ && matewnck_window_is_skip_tasklist (act_window)

+ && type != MATEWNCK_WINDOW_DESKTOP)

+ return;

+

+ if (type == MATEWNCK_WINDOW_DOCK

+ || type == MATEWNCK_WINDOW_SPLASHSCREEN

+ || type == MATEWNCK_WINDOW_MENU)

+ return;

+

+ disconnect_window (title);

+

+ if (!MATEWNCK_IS_WINDOW (act_window)

+ || matewnck_window_get_window_type (act_window) == MATEWNCK_WINDOW_DESKTOP)

+ {

+ if (priv->show_home_title)

+ {

+ gtk_label_set_text (GTK_LABEL (priv->label), _("Home"));

+ gtk_image_set_from_pixbuf (GTK_IMAGE (priv->button_image),

+ priv->quit_icon);

+ gtk_widget_set_tooltip_text (priv->button,

+ _("Log off, switch user, lock screen or power "

+ "down the computer"));

+ gtk_widget_set_tooltip_text (GTK_WIDGET (title),

+ _("Home")); gtk_widget_show (priv->box);

+ }

+ else

+ {

+ gtk_widget_set_state (GTK_WIDGET (title), GTK_STATE_NORMAL);

+ gtk_widget_set_tooltip_text (priv->button, NULL);

+ gtk_widget_set_tooltip_text (GTK_WIDGET (title), NULL);

+ gtk_widget_hide (priv->box);

+ }

+ }

+ else

+ {

+ gtk_label_set_text (GTK_LABEL (priv->label),

+ matewnck_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));

+ gtk_widget_set_tooltip_text (priv->button, _("Close window"));

+

+ g_signal_connect (act_window, "name-changed",

+ G_CALLBACK (on_name_changed), title);

+ g_signal_connect (act_window, "icon-changed",

+ G_CALLBACK (on_icon_changed), title);

+ g_signal_connect_after (act_window, "state-changed",

+ G_CALLBACK (on_state_changed), title);

+ gtk_widget_show (priv->box);

+ 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))

+ {

+ gtk_widget_set_state (GTK_WIDGET (title), GTK_STATE_NORMAL);

+ gtk_widget_hide (priv->box);

+ }

+ else if (!MATEWNCK_IS_WINDOW (act_window))

+ {

+ if (task_list_get_desktop_visible (TASK_LIST (task_list_get_default ()))

+ && priv->show_home_title)

+ {

+ gtk_label_set_text (GTK_LABEL (priv->label), _("Home"));

+ gtk_image_set_from_pixbuf (GTK_IMAGE (priv->button_image),

+ priv->quit_icon);

+ gtk_widget_set_tooltip_text (priv->button,

+ _("Log off, switch user, lock screen or power "

+ "down the computer"));

+ gtk_widget_set_tooltip_text (GTK_WIDGET (title),

+ _("Home"));

+ gtk_widget_show (priv->box);

+ }

+ else

+ {

+ gtk_widget_set_state (GTK_WIDGET (title), GTK_STATE_NORMAL);

+ gtk_widget_set_tooltip_text (priv->button, NULL);

+ gtk_widget_set_tooltip_text (GTK_WIDGET (title), NULL);

+ gtk_widget_hide (priv->box);

+ }

+ }

+ else

+ gtk_widget_set_state (GTK_WIDGET (title), GTK_STATE_ACTIVE);

+

+ gtk_widget_queue_draw (GTK_WIDGET (title));

+}

+

+static gboolean

+on_button_release (GtkWidget *title, GdkEventButton *event)

+{

+ TaskTitlePrivate *priv;

+ MatewnckWindow *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);

+

+ g_return_val_if_fail (MATEWNCK_IS_WINDOW (window), FALSE);

+

+ if (event->button == 3)

+ {

+ if (matewnck_window_get_window_type (window) != MATEWNCK_WINDOW_DESKTOP)

+ {

+ menu = matewnck_action_menu_new (window);

+ gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL,

+ event->button, event->time);

+ return TRUE;

+ }

+ }

+ else if (event->button == 1)

+ {

+ if (event->type == GDK_2BUTTON_PRESS && matewnck_window_is_maximized (window))

+ {

+ matewnck_window_unmaximize (window);

+ }

+ }

+

+ return FALSE;

+}

+

+

+static gboolean

+on_expose (GtkWidget *eb, GdkEventExpose *event)

+{

+

+ if (eb->state == GTK_STATE_ACTIVE)

+ gtk_paint_box (eb->style, eb->window,

+ eb->state, GTK_SHADOW_NONE,

+ NULL, eb, "button",

+ eb->allocation.x, eb->allocation.y,

+ eb->allocation.width, eb->allocation.height);

+

+

+ gtk_container_propagate_expose (GTK_CONTAINER (eb),

+ gtk_bin_get_child (GTK_BIN (eb)),

+ event);

+ return TRUE;

+}

+

+/* GObject stuff */

+static void

+task_title_finalize (GObject *object)

+{

+ TaskTitlePrivate *priv;

+

+ priv = TASK_TITLE_GET_PRIVATE (object);

+ disconnect_window (TASK_TITLE (object));

+

+ g_object_unref (G_OBJECT (priv->quit_icon));

+

+ G_OBJECT_CLASS (task_title_parent_class)->finalize (object);

+}

+

+static void

+task_title_class_init (TaskTitleClass *klass)

+{

+ GObjectClass *obj_class = G_OBJECT_CLASS (klass);

+ GtkWidgetClass *wid_class = GTK_WIDGET_CLASS (klass);

+

+ obj_class->finalize = task_title_finalize;

+ wid_class->expose_event = on_expose;

+

+ g_type_class_add_private (obj_class, sizeof (TaskTitlePrivate));

+}

+

+static void

+task_title_init (TaskTitle *title)

+{

+ TaskTitlePrivate *priv;

+ MateConfClient *client;

+ GdkScreen *gdkscreen;

+ GtkIconTheme *theme;

+ GtkSettings *settings;

+ GdkPixbuf *pixbuf;

+ AtkObject *atk;

+ int width, height;

+

+ priv = title->priv = TASK_TITLE_GET_PRIVATE (title);

+

+ priv->screen = matewnck_screen_get_default ();

+ priv->window = NULL;

+

+ client = mateconf_client_get_default ();

+ priv->show_home_title = mateconf_client_get_bool (client,

+ SHOW_HOME_TITLE_KEY,

+ NULL);

+ g_object_unref (client);

+

+ gtk_widget_add_events (GTK_WIDGET (title), GDK_ALL_EVENTS_MASK);

+

+ priv->align = gtk_alignment_new (0.0, 0.5, 1.0, 1.0);

+ gtk_alignment_set_padding (GTK_ALIGNMENT (priv->align),

+ 0, 0, 6, 6);

+ gtk_container_add (GTK_CONTAINER (title), priv->align);

+

+ priv->box = gtk_hbox_new (FALSE, 2);

+ gtk_container_add (GTK_CONTAINER (priv->align), priv->box);

+ gtk_widget_set_no_show_all (priv->box, TRUE);

+ gtk_widget_show (priv->box);

+

+ priv->label = gtk_label_new (_("Home"));

+ gtk_label_set_ellipsize (GTK_LABEL (priv->label), PANGO_ELLIPSIZE_END);

+ gtk_misc_set_alignment (GTK_MISC (priv->label), 0.0, 0.5);

+

+ PangoAttrList *attr_list = pango_attr_list_new ();

+ PangoAttribute *attr = pango_attr_weight_new (PANGO_WEIGHT_BOLD);

+ pango_attr_list_insert (attr_list, attr);

+ gtk_label_set_attributes (GTK_LABEL (priv->label), attr_list);

+

+ gtk_box_pack_start (GTK_BOX (priv->box), priv->label, TRUE, TRUE, 0);

+ gtk_widget_show (priv->label);

+

+ priv->button = g_object_new (GTK_TYPE_EVENT_BOX,

+ "visible-window", FALSE,

+ "above-child", TRUE,

+ NULL);

+ gtk_box_pack_start (GTK_BOX (priv->box), priv->button, FALSE, FALSE, 0);

+ gtk_widget_show (priv->button);

+

+ atk = gtk_widget_get_accessible (priv->button);

+ atk_object_set_name (atk, _("Close"));

+ atk_object_set_description (atk, _("Close current window."));

+ atk_object_set_role (atk, ATK_ROLE_PUSH_BUTTON);

+

+ g_signal_connect (priv->button, "button-release-event",

+ G_CALLBACK (on_close_clicked), title);

+ g_signal_connect (priv->button, "enter-notify-event",

+ G_CALLBACK (on_enter_notify), title);

+ g_signal_connect (priv->button, "leave-notify-event",

+ G_CALLBACK (on_leave_notify), title);

+ g_signal_connect (priv->button, "expose-event",

+ G_CALLBACK (on_button_expose), title);

+

+ /* Load the quit icon. We have to do this in such a god-forsaken way

+ because of http://bugzilla.mate.org/show_bug.cgi?id=581359 and the

+ fact that we support as far back as GTK+ 2.12 (which never passes

+ FORCE_SIZE in GtkImage). The only way to guarantee icon size is to

+ load and scale it ourselves. We don't do this for all the other icons

+ in the source just because we know that this icon doesn't come in the

+ size we want. */

+ gdkscreen = gtk_widget_get_screen (GTK_WIDGET (title));

+ theme = gtk_icon_theme_get_for_screen (gdkscreen);

+ settings = gtk_settings_get_for_screen (gdkscreen);

+ if (!gtk_icon_size_lookup_for_settings (settings, GTK_ICON_SIZE_MENU,

+&width, &height))

+ width = height = 16;

+ width = MIN(width, height);

+ pixbuf = gtk_icon_theme_load_icon (theme, "mate-logout", width, 0, NULL);

+ priv->quit_icon = gdk_pixbuf_scale_simple (pixbuf, width, width,

+ GDK_INTERP_BILINEAR);

+ g_object_unref (G_OBJECT (pixbuf));

+

+ priv->button_image = gtk_image_new_from_pixbuf (priv->quit_icon);

+ gtk_container_add (GTK_CONTAINER (priv->button), priv->button_image);

+ gtk_widget_show (priv->button_image);

+

+ gtk_widget_set_tooltip_text (priv->button,

+ _("Log off, switch user, lock screen or power "

+ "down the computer"));

+ gtk_widget_set_tooltip_text (GTK_WIDGET (title), _("Home"));

+

+ if (priv->show_home_title)

+ gtk_widget_set_state (GTK_WIDGET (title), GTK_STATE_ACTIVE);

+ else

+ gtk_widget_hide (priv->box);

+

+

+ gtk_widget_add_events (GTK_WIDGET (title), GDK_ALL_EVENTS_MASK);

+

+ g_signal_connect (priv->screen, "active-window-changed",

+ G_CALLBACK (on_active_window_changed), title);

+ g_signal_connect (title, "button-press-event",

+ G_CALLBACK (on_button_release), NULL);

+}

+

+GtkWidget *

+task_title_new (void)

+

+{

+ GtkWidget *title = NULL;

+

+ title = g_object_new (TASK_TYPE_TITLE,

+ "border-width", 0,

+ "name", "tasklist-button",

+ "visible-window", FALSE,

+ NULL);

+

+ return title;

+}

+/*

+ * Copyright (C) 2008 Canonical Ltd

+ *

+ * This program is free software: you can redistribute it and/or modify

+ * it under the terms of the GNU General Public License version 3 as

+ * published by the Free Software Foundation.

+ *

+ * This program is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

+ * GNU General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program. If not, see <http://www.gnu.org/licenses/>.

+ *

+ * Authored by Neil Jagdish Patel <[email protected]>

+ *

+ */

+

+#ifndef _TASK_TITLE_H_

+#define _TASK_TITLE_H_

+

+#include <glib.h>

+#include <glib/gi18n.h>

+#include <gtk/gtk.h>

+

+#define TASK_TYPE_TITLE (task_title_get_type ())

+

+#define TASK_TITLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj),\

+ TASK_TYPE_TITLE, TaskTitle))

+

+#define TASK_TITLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass),\

+ TASK_TYPE_TITLE, TaskTitleClass))

+

+#define TASK_IS_TITLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj),\

+ TASK_TYPE_TITLE))

+

+#define TASK_IS_TITLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),\

+ TASK_TYPE_TITLE))

+

+#define TASK_TITLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj),\

+ TASK_TYPE_TITLE, TaskTitleClass))

+

+typedef struct _TaskTitle TaskTitle;

+typedef struct _TaskTitleClass TaskTitleClass;

+typedef struct _TaskTitlePrivate TaskTitlePrivate;

+

+struct _TaskTitle

+{

+ GtkEventBox parent;

+

+ TaskTitlePrivate *priv;

+};

+

+struct _TaskTitleClass

+{

+ GtkEventBoxClass parent_class;

+};

+

+GType task_title_get_type (void) G_GNUC_CONST;

+

+GtkWidget * task_title_new (void);

+

+

+#endif /* _TASK_TITLE_H_ */

+