/**
* ww_filter_user_windows
* @windows: List of %WnckWindow<!-- -->s to filter
* @current_workspace: Only use windows on this workspace. %NULL indicates
* that all windows should be used
*
* Extract the user controlled visible windows from a %GList of
* %WnckWindows.
*
* Return value: A newly allocated list containing only windows that are
* not minimized, shaded, or wnck_window_skip_task_list() on the current
* workspace.
*/
GList*
ww_filter_user_windows (GList * windows, WnckWorkspace *current_workspace)
{
GList *next;
GList *result;
WnckWindow *win;
WnckWorkspace *win_ws;
result = NULL;
for (next = windows; next; next = next->next)
{
win = WNCK_WINDOW(next->data);
if (!wnck_window_is_skip_tasklist (win) &&
!wnck_window_is_minimized (win) &&
!wnck_window_is_maximized (win) &&
!wnck_window_is_shaded (win))
{
win_ws = wnck_window_get_workspace (win);
if (current_workspace == NULL
|| (win_ws == current_workspace
&& wnck_window_is_in_viewport(win, current_workspace))
|| win_ws == NULL)
result = g_list_append (result, win);
}
}
return result;
}
/* Returns the highest maximized window */
static WnckWindow *getUpperMaximized (WTApplet *wtapplet) {
if (!wtapplet->prefs->only_maximized)
return wtapplet->activewindow;
GList *windows = wnck_screen_get_windows_stacked(wtapplet->activescreen);
WnckWindow *returnwindow = NULL;
while (windows && windows->data) {
if (wnck_window_is_maximized(windows->data)) {
// if(wnck_window_is_on_workspace(windows->data, wtapplet->activeworkspace))
if (!wnck_window_is_minimized(windows->data))
if (wnck_window_is_in_viewport(windows->data, wtapplet->activeworkspace))
returnwindow = windows->data;
}
windows = windows->next;
}
// start tracking the new umaxed window
if (wtapplet->umaxedwindow) {
if (g_signal_handler_is_connected(G_OBJECT(wtapplet->umaxedwindow), wtapplet->umaxed_handler_state))
g_signal_handler_disconnect(G_OBJECT(wtapplet->umaxedwindow), wtapplet->umaxed_handler_state);
if (g_signal_handler_is_connected(G_OBJECT(wtapplet->umaxedwindow), wtapplet->umaxed_handler_name))
g_signal_handler_disconnect(G_OBJECT(wtapplet->umaxedwindow), wtapplet->umaxed_handler_name);
if (g_signal_handler_is_connected(G_OBJECT(wtapplet->umaxedwindow), wtapplet->umaxed_handler_icon))
g_signal_handler_disconnect(G_OBJECT(wtapplet->umaxedwindow), wtapplet->umaxed_handler_icon);
}
if (returnwindow) {
// maxed window was found
wtapplet->umaxed_handler_state = g_signal_connect(G_OBJECT(returnwindow),
"state-changed",
G_CALLBACK (umaxed_window_state_changed),
wtapplet);
wtapplet->umaxed_handler_name = g_signal_connect(G_OBJECT(returnwindow),
"name-changed",
G_CALLBACK (umaxed_window_nameicon_changed),
wtapplet);
wtapplet->umaxed_handler_icon = g_signal_connect(G_OBJECT(returnwindow),
"icon-changed",
G_CALLBACK (umaxed_window_nameicon_changed),
wtapplet);
//return returnwindow;
} else {
// maxed window was not found
returnwindow = wtapplet->rootwindow; //return wtapplet->rootwindow;
}
return returnwindow;
// WARNING: if this function returns NULL, applet won't detect clicks!
}
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));
}
}
/* Returns the highest maximized window */
static WnckWindow *get_upper_maximized (WckUtils *win)
{
WnckWindow *umaxedwindow = NULL;
GList *windows = wnck_screen_get_windows_stacked(win->activescreen);
while (windows && windows->data)
{
if (!win->activeworkspace
|| wnck_window_is_in_viewport(windows->data, win->activeworkspace))
if (wnck_window_is_maximized(windows->data)
&& !wnck_window_is_minimized(windows->data))
{
umaxedwindow = windows->data;
}
windows = windows->next;
}
/* NULL if no maximized window found */
return umaxedwindow;
}
static void wibuti_watcher_find_window(WibutiWatcher *self) {
WnckWorkspace *activeworkspace = wnck_screen_get_active_workspace(self->screen);
WnckWindow *new_active = wnck_screen_get_active_window(self->screen);
WnckWindow *new_tracked = NULL;
// stop tracking the old active window
if (G_IS_OBJECT(self->active)) {
if (g_signal_handler_is_connected(G_OBJECT(self->active), self->handler_active_state_changed)) {
g_signal_handler_disconnect(G_OBJECT(self->active), self->handler_active_state_changed);
}
}
if (self->only_maximized) {
// find upper maximized window
GList *windows = wnck_screen_get_windows_stacked(self->screen);
while (windows && windows->data) {
if (!self->only_maximized || wnck_window_is_maximized(windows->data))
if (!wnck_window_is_minimized(windows->data) && !wnck_window_is_skip_pager(windows->data))
if (wnck_window_is_in_viewport(windows->data, activeworkspace))
new_tracked = windows->data;
windows = windows->next;
}
// start tracking the new active window
if (new_active) {
self->handler_active_state_changed = g_signal_connect(G_OBJECT(new_active), "state-changed",
G_CALLBACK(wibuti_watcher_window_state_changed_cb), self);
}
} else {
new_tracked = new_active;
}
// stop tracking the old window
if (G_IS_OBJECT(self->tracked)) {
#ifdef WIBUTI_WITH_TITLE
if (g_signal_handler_is_connected(G_OBJECT(self->tracked), self->handler_name_changed)) {
g_signal_handler_disconnect(G_OBJECT(self->tracked), self->handler_name_changed);
}
if (g_signal_handler_is_connected(G_OBJECT(self->tracked), self->handler_icon_changed)) {
g_signal_handler_disconnect(G_OBJECT(self->tracked), self->handler_icon_changed);
}
#endif // WIBUTI_WITH_TITLE
if (g_signal_handler_is_connected(G_OBJECT(self->tracked), self->handler_tracked_state_changed)) {
g_signal_handler_disconnect(G_OBJECT(self->tracked), self->handler_tracked_state_changed);
}
}
// start tracking the new window
if (new_tracked) {
#ifdef WIBUTI_WITH_TITLE
self->handler_name_changed = g_signal_connect(G_OBJECT(new_tracked), "name-changed",
G_CALLBACK(wibuti_watcher_name_changed_cb), self);
self->handler_icon_changed = g_signal_connect(G_OBJECT(new_tracked), "icon-changed",
G_CALLBACK(wibuti_watcher_icon_changed_cb), self);
#endif // WIBUTI_WITH_TITLE
self->handler_tracked_state_changed = g_signal_connect(G_OBJECT(new_tracked), "state-changed",
G_CALLBACK(wibuti_watcher_window_state_changed_cb), self);
}
self->tracked = new_tracked;
self->active = new_active;
}
/* track the new controled window according to preferences */
static void track_controled_window (WckUtils *win)
{
WnckWindow *previous_umax = NULL;
WnckWindow *previous_control = NULL;
previous_control = win->controlwindow;
if (win->only_maximized)
{
previous_umax = win->umaxwindow;
win->umaxwindow = get_upper_maximized(win);
win->controlwindow = win->umaxwindow;
}
else if (win->activewindow
&& (!win->activeworkspace
|| wnck_window_is_in_viewport(win->activewindow, win->activeworkspace))
&& !wnck_window_is_minimized(win->activewindow)
&& !wnck_window_is_sticky(win->activewindow))
{
win->controlwindow = win->activewindow;
}
if (!win->umaxwindow || (win->umaxwindow != previous_umax))
{
wck_signal_handler_disconnect (G_OBJECT(previous_umax), win->msh);
wck_signal_handler_disconnect (G_OBJECT(previous_umax), win->mwh);
}
if (win->only_maximized)
{
if (win->umaxwindow && (win->umaxwindow != previous_umax))
{
/* track the new upper maximized window state */
win->msh = g_signal_connect(G_OBJECT(win->umaxwindow),
"state-changed",
G_CALLBACK (on_umaxed_window_state_changed),
win);
win->mwh = g_signal_connect(G_OBJECT (win->umaxwindow),
"workspace-changed",
G_CALLBACK (umax_window_workspace_changed),
win);
}
else if (win->controlwindow == previous_control)
{
/* track previous upper maximized window state on desktop */
win->umaxwindow = previous_umax;
if (win->umaxwindow) {
win->msh = g_signal_connect(G_OBJECT(win->umaxwindow),
"state-changed",
G_CALLBACK (track_changed_max_state),
win);
}
}
}
if (!win->controlwindow)
win->controlwindow = get_root_window(win->activescreen);
if (win->controlwindow != previous_control)
on_control_window_changed(win->controlwindow, previous_control, win->data);
else
on_wck_state_changed(win->controlwindow, win->data);
}
