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 (WNCK_IS_WINDOW (priv->window), FALSE);
active = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget), "drag-true"));
if (active)
{
WnckWindow *window;
window = priv->window;
if (WNCK_IS_WINDOW (window))
wnck_window_activate (window, time (NULL));
}
g_object_set_data (G_OBJECT (widget), "drag-true", GINT_TO_POINTER (0));
return FALSE;
}
void window_activate(WnckWindow *window)
{
XEvent xev;
Window xwindow;
g_return_if_fail (WNCK_IS_WINDOW (window));
if (wnck_window_is_minimized(window)) {
return;
}
xwindow = wnck_window_get_xid(window);
xev.xclient.type = ClientMessage;
xev.xclient.serial = 0;
xev.xclient.send_event = TRUE;
xev.xclient.display = main_dpy;
xev.xclient.window = xwindow;
xev.xclient.message_type = XInternAtom(main_dpy, "_NET_ACTIVE_WINDOW",FALSE);
xev.xclient.format = 32;
xev.xclient.data.l[0] = 2; /* WNCK_CLIENT_TYPE_PAGER */
xev.xclient.data.l[1] = 0;
xev.xclient.data.l[2] = 0;
xev.xclient.data.l[3] = 0;
xev.xclient.data.l[4] = 0;
XSendEvent (main_dpy,
DefaultRootWindow(main_dpy),
FALSE,
SubstructureRedirectMask | SubstructureNotifyMask,
&xev);
}
GdkPixbuf *wibuti_watcher_get_icon(WibutiWatcher *self) {
if (WNCK_IS_WINDOW(self->tracked)) {
return wnck_window_get_icon(self->tracked);
} else {
return NULL;
}
}
gboolean wibuti_watcher_is_maximized(WibutiWatcher *self) {
if (WNCK_IS_WINDOW(self->tracked)) {
return wnck_window_is_maximized(self->tracked);
} else {
return FALSE;
}
}
static void
wnck_action_menu_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
WnckActionMenu *menu;
g_return_if_fail (WNCK_IS_ACTION_MENU (object));
menu = WNCK_ACTION_MENU (object);
switch (prop_id)
{
case PROP_WINDOW:
g_return_if_fail (WNCK_IS_WINDOW (g_value_get_pointer (value)));
menu->priv->window = g_value_get_pointer (value);
g_object_notify (G_OBJECT (menu), "window");
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
wnck_action_menu_dispose (GObject *object)
{
WnckActionMenu *menu;
menu = WNCK_ACTION_MENU (object);
if (menu->priv->idle_handler)
{
g_source_remove (menu->priv->idle_handler);
menu->priv->idle_handler = 0;
}
if (WNCK_IS_WINDOW (menu->priv->window))
{
g_object_weak_unref (G_OBJECT (menu->priv->window), window_weak_notify, menu);
g_signal_handlers_disconnect_by_data (menu->priv->window, menu);
WnckScreen *screen = wnck_window_get_screen (menu->priv->window);
g_signal_handlers_disconnect_by_data (screen, menu);
menu->priv->window = NULL;
}
G_OBJECT_CLASS (wnck_action_menu_parent_class)->dispose (object);
}
void window_handle(WnckWindow *window, gboolean want_tiled)
{
if (!WNCK_IS_WINDOW (window)) {
fprintf(stderr, "[bonnye] Trying to rehandle something that is not a window\n");
return;
}
int spaceid = workspace_get_from_window(window);
gboolean is_tiled = workspace_has_tiled_window(spaceid, window);
if (want_tiled) {
if (is_tiled) {
fprintf(stderr, "[bonnye] Trying to tile a tiled window. Doing nothing\n");
return;
}
workspace_add_window(spaceid, window);
window_init(spaceid, window);
} else {
if (!is_tiled) {
fprintf(stderr, "[bonnye] Trying to untile an untiled window. Doing nothing\n");
return;
}
workspace_remove_window(spaceid, window);
window_clear(window);
}
tile(spaceid);
}
const gchar *wibuti_watcher_get_title(WibutiWatcher *self) {
if (WNCK_IS_WINDOW(self->tracked)) {
return wnck_window_get_name(self->tracked);
} else {
return "Desktop";
}
}
void wibuti_watcher_maximize_restore(WibutiWatcher *self) {
if (WNCK_IS_WINDOW(self->tracked)) {
if (wnck_window_is_maximized(self->tracked)) {
wnck_window_unmaximize(self->tracked);
} else {
wnck_window_maximize(self->tracked);
}
}
}
/**
* wnck_action_menu_new:
* @window: the #WnckWindow for which a menu will be created.
*
* Creates a new #WnckActionMenu. The #WnckActionMenu will be filled with menu
* items for window operations on @window.
*
* Return value: a newly created #WnckActionMenu.
*
* Since: 2.22
**/
GtkWidget*
wnck_action_menu_new (WnckWindow *window)
{
g_return_val_if_fail (WNCK_IS_WINDOW (window), NULL);
return g_object_new (WNCK_TYPE_ACTION_MENU,
"window", window,
NULL);
}
static void on_name_changed (WnckWindow *window, TaskTitle *title) {
g_return_if_fail (TASK_IS_TITLE (title));
g_return_if_fail (WNCK_IS_WINDOW (window));
gtk_label_set_text (GTK_LABEL (title->priv->label),
wnck_window_get_name (window));
gtk_widget_set_tooltip_text (GTK_WIDGET (title),
wnck_window_get_name (window));
gtk_widget_queue_draw (GTK_WIDGET (title));
}
static void
on_screen_active_window_changed (WnckScreen *screen,
WnckWindow *old_window,
TaskItem *item)
{
WnckWindow *window;
TaskItemPrivate *priv;
g_return_if_fail (TASK_IS_ITEM (item));
priv = item->priv;
window = priv->window;
g_return_if_fail (WNCK_IS_WINDOW (window));
if ((WNCK_IS_WINDOW (old_window) && window == old_window) ||
window == wnck_screen_get_active_window (screen))
{
/* queue a draw to reflect that we are [no longer] the active window */
gtk_widget_queue_draw (GTK_WIDGET (item));
}
}
static void
update_hints (TaskItem *item)
{
GtkWidget *parent;
GtkWidget *widget;
GtkAllocation *allocation;
WnckWindow *window;
GdkWindow *gdkwindow;
gint x, y, x1, y1;
widget = GTK_WIDGET (item);
window = item->priv->window;
/* Skip problems */
if (!WNCK_IS_WINDOW (window)) return;
if (!GTK_IS_WIDGET (widget)) return;
/* Skip invisible windows */
if (!gtk_widget_get_visible (widget)) return;
x = y = 0;
/* Recursively compute the button's coordinates */
for (parent = widget; parent; parent = gtk_widget_get_parent (parent))
{
if (gtk_widget_get_parent (parent))
{
gtk_widget_get_allocation (parent, allocation);
x += allocation->x;
y += allocation->y;
}
else
{
x1 = y1 = 0;
gdkwindow = gtk_widget_get_window (parent);
#if !GTK_CHECK_VERSION (3, 0, 0)
if (GDK_IS_WINDOW (gdkwindow))
#endif
gdk_window_get_origin (gdkwindow, &x1, &y1);
x += x1; y += y1;
break;
}
}
/* Set the minimize hint for the window */
gtk_widget_get_allocation (widget, allocation);
if (allocation) {
wnck_window_set_icon_geometry (window, x, y,
allocation->width,
allocation->height);
}
}
static gboolean
on_query_tooltip (GtkWidget *widget,
gint x, gint y,
gboolean keyboard_mode,
GtkTooltip *tooltip,
TaskItem *item)
{
WnckWindow *window = item->priv->window;
g_return_val_if_fail (WNCK_IS_WINDOW (window), FALSE);
gtk_tooltip_set_text (tooltip, wnck_window_get_name(window));
gtk_tooltip_set_icon (tooltip, wnck_window_get_icon (window));
return TRUE;
}
static void
task_item_set_visibility (TaskItem *item)
{
WnckScreen *screen;
WnckWindow *window;
WnckWorkspace *workspace;
g_return_if_fail (TASK_IS_ITEM (item));
TaskItemPrivate *priv = item->priv;
if (!WNCK_IS_WINDOW (priv->window))
{
gtk_widget_hide (GTK_WIDGET (item));
return;
}
window = priv->window;
screen = priv->screen;
workspace = wnck_screen_get_active_workspace (screen);
gboolean show_all = task_list_get_show_all_windows (TASK_LIST (task_list_get_default ()));
gboolean show_window = FALSE;
if (!wnck_window_is_skip_tasklist (window))
{
if (wnck_workspace_is_virtual (workspace))
{
show_window = wnck_window_is_in_viewport (window, workspace);
}
else
{
show_window = wnck_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 GdkPixbuf *
task_item_sized_pixbuf_for_window (TaskItem *item,
WnckWindow *window,
gint size)
{
GdkPixbuf *pbuf = NULL;
g_return_val_if_fail (WNCK_IS_WINDOW (window), NULL);
if (wnck_window_has_icon_name (window))
{
const gchar *icon_name = wnck_window_get_icon_name (window);
GtkIconTheme *icon_theme = gtk_icon_theme_get_default ();
if (gtk_icon_theme_has_icon (icon_theme, icon_name))
{
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 (wnck_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;
}
/**
* Depending on whether the window is maximized the task title is shown
* or hidden.
*/
static void on_state_changed (WnckWindow *window,
WnckWindowState changed_mask,
WnckWindowState new_state,
TaskTitle *title)
{
TaskTitlePrivate *priv = title->priv;
g_return_if_fail (TASK_IS_TITLE (title));
g_return_if_fail (WNCK_IS_WINDOW (window));
if (priv->window != window)
return;
if (wnck_window_is_maximized (window)) {
gtk_widget_set_state_flags (GTK_WIDGET (title), GTK_STATE_FLAG_ACTIVE, TRUE);
gtk_widget_show (priv->grid);
} else {
gtk_widget_set_state_flags (GTK_WIDGET (title), GTK_STATE_FLAG_NORMAL, TRUE);
gtk_widget_hide (priv->grid);
}
}
static void
on_window_state_changed (WnckWindow *window,
WnckWindowState changed_mask,
WnckWindowState new_state,
TaskItem *item)
{
g_return_if_fail (WNCK_IS_WINDOW (window));
g_return_if_fail (TASK_IS_ITEM (item));
TaskItemPrivate *priv = item->priv;
if (new_state & WNCK_WINDOW_STATE_URGENT && !priv->timer)
{
priv->timer = g_timeout_add (30, (GSourceFunc)on_blink, item);
g_get_current_time (&priv->urgent_time);
}
task_item_set_visibility (item);
}
static gboolean
on_button_pressed (GtkWidget *button,
GdkEventButton *event,
TaskItem *item)
{
WnckWindow *window;
g_return_val_if_fail (TASK_IS_ITEM (item), FALSE);
window = item->priv->window;
g_return_val_if_fail (WNCK_IS_WINDOW (window), FALSE);
if (event->button == 3)
{
GtkWidget *menu = wnck_action_menu_new (window);
gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL,
event->button, event->time);
return TRUE;
}
return FALSE;
}
GtkWidget*
window_menu_item_new (WnckWindow* window)
{
WnckApplication* application;
GdkPixbuf* pixbuf;
GtkWidget* item;
GtkWidget* label;
gchar * markup;
g_return_val_if_fail (WNCK_IS_WINDOW (window), NULL);
item = gtk_image_menu_item_new ();
application = wnck_window_get_application (window);
/* FIXME: track icon changes */
pixbuf = wnck_application_get_icon (application);
if (pixbuf)
{
GtkWidget* image = gtk_image_new_from_pixbuf (pixbuf);
gtk_widget_show (image);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
}
g_signal_connect (item, "activate",
G_CALLBACK (window_item_activated), window);
/* FIXME: track name changes */
label = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
markup = g_strdup_printf ("<b>%s</b>\n<small>%s</small>",
wnck_application_get_name (application),
wnck_window_get_name (window));
gtk_label_set_markup (GTK_LABEL (label), markup);
g_free (markup);
gtk_widget_show (label);
gtk_container_add (GTK_CONTAINER (item), label);
return item;
}
static void
task_item_setup_atk (TaskItem *item)
{
TaskItemPrivate *priv;
GtkWidget *widget;
AtkObject *atk;
WnckWindow *window;
g_return_if_fail (TASK_IS_ITEM (item));
widget = GTK_WIDGET (item);
priv = item->priv;
window = priv->window;
g_return_if_fail (WNCK_IS_WINDOW (window));
atk = gtk_widget_get_accessible (widget);
atk_object_set_name (atk, _("Window Task Button"));
atk_object_set_description (atk, wnck_window_get_name (window));
atk_object_set_role (atk, ATK_ROLE_PUSH_BUTTON);
}
/**
* Event handler for clicking on the title (not the close button)
* On double click unmaximized the window
* On right click it shows the context menu for the current window
*/
static gboolean on_button_press (GtkWidget *title, GdkEventButton *event) {
g_return_val_if_fail (TASK_IS_TITLE (title), FALSE);
TaskTitlePrivate *priv = TASK_TITLE (title)->priv;
WnckWindow *window = wnck_screen_get_active_window (priv->screen);
g_return_val_if_fail (WNCK_IS_WINDOW (window), FALSE);
if (event->button == 3) { //right click
if (wnck_window_get_window_type (window) != WNCK_WINDOW_DESKTOP) {
GtkWidget *menu = wnck_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) { //left button double click
if (event->type == GDK_2BUTTON_PRESS
&& wnck_window_is_maximized (window)) {
wnck_window_unmaximize (window);
}
}
return FALSE;
}
/**
* The event handler for the close icon. This closes the window and terminates
* the program.
*/
static gboolean on_close_clicked (GtkButton *button,
GdkEventButton *event,
TaskTitle *title)
{
g_return_val_if_fail (TASK_IS_TITLE (title), FALSE);
TaskTitlePrivate *priv = title->priv;
if (event->button != 1 || !priv->mouse_in_close_button)
return FALSE;
WnckWindow *window = wnck_screen_get_active_window (priv->screen);
if (!WNCK_IS_WINDOW (window)
|| wnck_window_get_window_type (window) == WNCK_WINDOW_DESKTOP)
{
fprintf(stdout, "Error\n");
fflush(stdout);
} else {
if (priv->window == window)
disconnect_window (title);
wnck_window_close (window, event->time);
}
gtk_widget_queue_draw (GTK_WIDGET (title));
return TRUE;
}
static gboolean
on_task_item_button_released (GtkWidget *widget,
GdkEventButton *event,
TaskItem *item)
{
WnckWindow *window;
WnckScreen *screen;
WnckWorkspace *workspace;
TaskItemPrivate *priv;
g_return_val_if_fail (TASK_IS_ITEM (item), TRUE);
priv = item->priv;
window = priv->window;
g_return_val_if_fail (WNCK_IS_WINDOW (window), TRUE);
screen = priv->screen;
workspace = wnck_window_get_workspace (window);
if (event->button == 1)
{
if (WNCK_IS_WORKSPACE (workspace) && workspace != wnck_screen_get_active_workspace (screen))
{
wnck_workspace_activate (workspace, GDK_CURRENT_TIME);
}
if (wnck_window_is_active (window))
{
wnck_window_minimize (window);
}
else
{
wnck_window_activate (window, GDK_CURRENT_TIME);
}
}
return TRUE;
}
static void
on_screen_window_closed (WnckScreen *screen,
WnckWindow *window,
TaskItem *item)
{
TaskItemPrivate *priv;
g_return_if_fail (TASK_IS_ITEM (item));
priv = item->priv;
g_return_if_fail (WNCK_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);
}
}
void
_wnck_application_add_window (WnckApplication *app,
WnckWindow *window)
{
g_return_if_fail (WNCK_IS_APPLICATION (app));
g_return_if_fail (WNCK_IS_WINDOW (window));
g_return_if_fail (wnck_window_get_application (window) == NULL);
app->priv->windows = g_list_prepend (app->priv->windows, window);
_wnck_window_set_application (window, app);
g_signal_connect (G_OBJECT (window), "name_changed",
G_CALLBACK (window_name_changed), app);
/* emits signals, so do it last */
reset_name (app);
update_name (app);
/* see if we're using icon from a window */
if (app->priv->icon == NULL ||
app->priv->mini_icon == NULL)
emit_icon_changed (app);
}
void
_wnck_application_remove_window (WnckApplication *app,
WnckWindow *window)
{
g_return_if_fail (WNCK_IS_APPLICATION (app));
g_return_if_fail (WNCK_IS_WINDOW (window));
g_return_if_fail (wnck_window_get_application (window) == app);
app->priv->windows = g_list_remove (app->priv->windows, window);
_wnck_window_set_application (window, NULL);
g_signal_handlers_disconnect_by_func (G_OBJECT (window),
window_name_changed, app);
/* emits signals, so do it last */
reset_name (app);
update_name (app);
/* see if we're using icon from a window */
if (app->priv->icon == NULL ||
app->priv->mini_icon == NULL)
emit_icon_changed (app);
}
static void
on_active_window_changed (WnckScreen *screen,
WnckWindow *old_window,
TaskTitle *title)
{
g_return_if_fail (TASK_IS_TITLE (title));
WnckWindow *act_window = wnck_screen_get_active_window (screen);
WnckWindowType type = WNCK_WINDOW_NORMAL;
TaskTitlePrivate *priv = title->priv;
if (act_window)
type = wnck_window_get_window_type (act_window);
disconnect_window (title);
// Depending on the type and state of the window we adjust the title
if(WNCK_IS_WINDOW(act_window)) {
if(type == WNCK_WINDOW_DESKTOP) {
/* The current window is the desktop so we show the home title if
* the user has configured this, otherwise we hide the title */
if (window_picker_applet_get_show_home_title (priv->windowPickerApplet)) {
show_home_title(title);
} else {
hide_title (title);
}
} else if(wnck_window_is_skip_tasklist (act_window)
&& type != WNCK_WINDOW_DESKTOP)
{
/* The current window is not in the task list, we dont change the
* current title. */
return;
} else if(type == WNCK_WINDOW_DOCK
|| type == WNCK_WINDOW_SPLASHSCREEN
|| type == WNCK_WINDOW_MENU)
{
return;
} else { //for all other types
if(wnck_window_is_maximized (act_window) && window_picker_applet_get_show_application_title (priv->windowPickerApplet)) {
//show normal title of window
gtk_label_set_text (GTK_LABEL (priv->label),
wnck_window_get_name (act_window));
gtk_image_set_from_icon_name (GTK_IMAGE (priv->button_image),
"window-close", GTK_ICON_SIZE_MENU);
gtk_widget_set_tooltip_text (GTK_WIDGET (title),
wnck_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_after (act_window, "state-changed",
G_CALLBACK (on_state_changed), title);
gtk_widget_show (priv->grid);
priv->window = act_window;
} else {
hide_title (title); //only show the title for maximized windows
}
}
} else { //its not a window
if (task_list_get_desktop_visible (TASK_LIST (window_picker_applet_get_tasks (priv->windowPickerApplet)))
&& window_picker_applet_get_show_home_title (priv->windowPickerApplet))
{
show_home_title(title);
} else { //reset the task title and hide it
hide_title (title);
}
}
gtk_widget_queue_draw (GTK_WIDGET (title));
}
void wibuti_watcher_close(WibutiWatcher *self) {
if (WNCK_IS_WINDOW(self->tracked)) {
wnck_window_close(self->tracked, GDK_CURRENT_TIME);
}
}
void wibuti_watcher_minimize(WibutiWatcher *self) {
if (WNCK_IS_WINDOW(self->tracked)) {
wnck_window_minimize(self->tracked);
}
}
