/* Returns the number of window for this application that reside on the
current workspace */
int
LauncherApplication::windowCountOnCurrentWorkspace()
{
int windowCount = 0;
WnckWorkspace *current = wnck_screen_get_active_workspace(wnck_screen_get_default());
for (int i = 0; i < m_application->windows()->size(); i++) {
BamfWindow *window = m_application->windows()->at(i);
if (window == NULL) {
continue;
}
/* When geting the wnck window, it's possible we get a NULL
return value because wnck hasn't updated its internal list yet,
so we need to force it once to be sure */
WnckWindow *wnck_window = wnck_window_get(window->xid());
if (wnck_window == NULL) {
wnck_screen_force_update(wnck_screen_get_default());
wnck_window = wnck_window_get(window->xid());
if (wnck_window == NULL) {
continue;
}
}
WnckWorkspace *workspace = wnck_window_get_workspace(wnck_window);
if (workspace == current) {
windowCount++;
}
}
return windowCount;
}
void
LauncherApplication::show()
{
if (m_application == NULL) {
return;
}
QScopedPointer<BamfWindowList> windows(m_application->windows());
int size = windows->size();
if (size < 1) {
return;
}
/* Pick the most important window.
The primary criterion to determine the most important window is urgency.
The secondary criterion is the last_active timestamp (the last time the
window was activated). */
BamfWindow* important = windows->at(0);
for (int i = 0; i < size; ++i) {
BamfWindow* current = windows->at(i);
if (current->urgent() && !important->urgent()) {
important = current;
} else if (current->urgent() || !important->urgent()) {
if (current->last_active() > important->last_active()) {
important = current;
}
}
}
WnckScreen* screen = wnck_screen_get_default();
wnck_screen_force_update(screen);
WnckWindow* window = wnck_window_get(important->xid());
LauncherUtility::showWindow(window);
}
void
LauncherApplication::setIconGeometry(int x, int y, int width, int height, uint xid)
{
if (m_application == NULL) {
return;
}
QScopedPointer<BamfUintList> xids;
if (xid == 0) {
xids.reset(m_application->xids());
} else {
QList<uint> list;
list.append(xid);
xids.reset(new BamfUintList(list));
}
int size = xids->size();
if (size < 1) {
return;
}
WnckScreen* screen = wnck_screen_get_default();
wnck_screen_force_update(screen);
for (int i = 0; i < size; ++i) {
WnckWindow* window = wnck_window_get(xids->at(i));
wnck_window_set_icon_geometry(window, x, y, width, height);
}
}
QList<WnckWindow*>
Trash::trashWindows() const
{
QList<WnckWindow*> trashWindows;
BamfMatcher& matcher = BamfMatcher::get_default();
QScopedPointer<BamfApplicationList> running_applications(matcher.running_applications());
BamfApplication* bamfApplication;
for(int i=0; i<running_applications->size(); i++) {
bamfApplication = running_applications->at(i);
QScopedPointer<BamfWindowList> windowApplications(bamfApplication->windows());
for (int j=0; j < windowApplications->size(); j++) {
BamfWindow *bamfWindow = windowApplications->at(j);
WnckWindow* wnckWindow = wnck_window_get(bamfWindow->xid());
if (wnckWindow != NULL && isTrashWindow(wnckWindow)) {
trashWindows.append(wnckWindow);
}
}
}
return trashWindows;
}
// -----------------------------------------------------------------------------
void g_window_workspace(GtkWidget* pWidget, int space)
{
DEBUGLOGB;
#if !_USEWKSPACE
#if GTK_CHECK_VERSION(3,0,0)
Screen* xscreen = gdk_x11_screen_get_xscreen(gdk_screen_get_default());
Window xwindow = gdk_x11_window_get_xid(gtk_widget_get_window(pWidget));
#else
Screen* xscreen = GDK_SCREEN_XSCREEN(gdk_screen_get_default());
Window xwindow = GDK_WINDOW_XWINDOW(gtk_widget_get_window(pWidget));
#endif
_wncki_change_workspace(xscreen, xwindow, space);
#else // !_USEWKSPACE
WnckScreen* screen = wnck_screen_get_default();
if( screen )
{
DEBUGLOGS("got default screen");
wnck_screen_force_update(screen);
DEBUGLOGP("sticky is off and workspace is %d\n", space);
WnckWindow* window = wnck_window_get(gdk_x11_drawable_get_xid(gtk_widget_get_window(pWidget)));
if( window && !wnck_window_is_pinned(window) )
{
DEBUGLOGS("got non-pinned window");
WnckWorkspace* trgtWrk = wnck_screen_get_workspace (screen, space);
WnckWorkspace* actvWrk = wnck_screen_get_active_workspace(screen);
if( trgtWrk && actvWrk && trgtWrk != actvWrk )
{
DEBUGLOGS("got target workspace is diff from current so moving window to target");
wnck_window_move_to_workspace(window, trgtWrk);
}
}
#ifdef _DEBUGLOG
else
{
DEBUGLOGP("WnckWindow for clock window is%svalid\n", window ? " " : " NOT ");
guint xw1 = GDK_WINDOW_XWINDOW (gtk_widget_get_window(pWidget));
guint xw2 = gdk_x11_drawable_get_xid(gtk_widget_get_window(pWidget));
DEBUGLOGP("X11 XID1 for clock window is %d\n", (int)xw1);
DEBUGLOGP("X11 XID2 for clock window is %d\n", (int)xw2);
}
#endif
}
#endif // !_USEWKSPACE
DEBUGLOGE;
}
void
Application::onWindowAdded(BamfWindow* window)
{
if (window != NULL) {
windowAdded(window->xid());
WnckWindow* wnck_window = wnck_window_get(window->xid());
m_gConnector.connect(G_OBJECT(wnck_window), "workspace-changed",
G_CALLBACK(Application::onWindowWorkspaceChanged), this);
m_gConnector.connect(G_OBJECT(wnck_window), "geometry-changed", G_CALLBACK(geometryChangedCB), this);
connect(window, SIGNAL(ActiveChanged(bool)), this, SLOT(announceActiveScreenChangedIfNeeded()));
}
void
LauncherApplication::close()
{
if (m_application == NULL) {
return;
}
QScopedPointer<BamfUintList> xids(m_application->xids());
int size = xids->size();
if (size < 1) {
return;
}
WnckScreen* screen = wnck_screen_get_default();
wnck_screen_force_update(screen);
for (int i = 0; i < size; ++i) {
WnckWindow* window = wnck_window_get(xids->at(i));
wnck_window_close(window, CurrentTime);
}
}
GdkFilterReturn
event_filter_func (GdkXEvent *gdkxevent,
GdkEvent *event,
gpointer data)
{
GdkDisplay *gdkdisplay;
XEvent *xevent = gdkxevent;
gulong xid = 0;
Window select = 0;
gdkdisplay = gdk_display_get_default ();
switch (xevent->type) {
case CreateNotify:
{
if (!wnck_window_get (xevent->xcreatewindow.window))
{
GdkWindow *toplevel = create_foreign_window (xevent->xcreatewindow.window);
if (toplevel)
{
gdk_window_set_events (toplevel,
gdk_window_get_events (toplevel) |
GDK_PROPERTY_CHANGE_MASK);
/* check if the window is a switcher and update accordingly */
if (get_window_prop (xevent->xcreatewindow.window, select_window_atom, &select))
update_switcher_window (xevent->xcreatewindow.window, select);
}
}
}
break;
case ButtonPress:
case ButtonRelease:
xid = (gulong)
g_hash_table_lookup (frame_table,
GINT_TO_POINTER (xevent->xbutton.window));
break;
case EnterNotify:
case LeaveNotify:
xid = (gulong)
g_hash_table_lookup (frame_table,
GINT_TO_POINTER (xevent->xcrossing.window));
break;
case MotionNotify:
xid = (gulong)
g_hash_table_lookup (frame_table,
GINT_TO_POINTER (xevent->xmotion.window));
break;
case PropertyNotify:
if (xevent->xproperty.atom == frame_input_window_atom)
{
WnckWindow *win;
xid = xevent->xproperty.window;
win = wnck_window_get (xid);
if (win)
{
Window frame;
if (!get_window_prop (xid, select_window_atom, &select))
{
if (get_window_prop (xid, frame_input_window_atom, &frame))
add_frame_window (win, frame, FALSE);
else
remove_frame_window (win);
}
}
}
if (xevent->xproperty.atom == frame_output_window_atom)
{
WnckWindow *win;
xid = xevent->xproperty.window;
win = wnck_window_get (xid);
if (win)
{
Window frame;
if (!get_window_prop (xid, select_window_atom, &select))
{
if (get_window_prop (xid, frame_output_window_atom, &frame))
add_frame_window (win, frame, TRUE);
else
remove_frame_window (win);
}
}
}
else if (xevent->xproperty.atom == compiz_shadow_info_atom ||
xevent->xproperty.atom == compiz_shadow_color_atom)
{
GdkScreen *g_screen = gdk_display_get_default_screen (gdkdisplay);
Window root = GDK_WINDOW_XWINDOW (gdk_screen_get_root_window (g_screen));
WnckScreen *screen;
screen = wnck_screen_get_for_root (root);
if (screen)
{
if (gwd_process_decor_shadow_property_update ())
decorations_changed (screen);
}
}
else if (xevent->xproperty.atom == mwm_hints_atom)
{
WnckWindow *win;
xid = xevent->xproperty.window;
win = wnck_window_get (xid);
if (win)
{
decor_t *d = g_object_get_data (G_OBJECT (win), "decor");
gboolean decorated = FALSE;
/* Only decorations that are actually bound to windows can be decorated
* ignore cases where a broken application which shouldn't be decorated
* sets the decoration hint */
if (get_mwm_prop (xid) & (MWM_DECOR_ALL | MWM_DECOR_TITLE) && d->win)
decorated = TRUE;
if (decorated != d->decorated)
{
d->decorated = decorated;
if (decorated)
{
d->context = NULL;
d->width = d->height = 0;
d->frame = gwd_get_decor_frame (get_frame_type (win));
update_window_decoration_state (win);
update_window_decoration_actions (win);
update_window_decoration_icon (win);
request_update_window_decoration_size (win);
update_event_windows (win);
}
else
{
remove_frame_window (win);
}
}
}
}
else if (xevent->xproperty.atom == select_window_atom)
{
Window select;
if (get_window_prop (xevent->xproperty.window, select_window_atom, &select))
update_switcher_window (xevent->xproperty.window, select);
}
break;
case DestroyNotify:
g_hash_table_remove (frame_table,
GINT_TO_POINTER (xevent->xproperty.window));
break;
case ClientMessage:
if (xevent->xclient.message_type == toolkit_action_atom)
{
long action;
action = xevent->xclient.data.l[0];
if (action == toolkit_action_window_menu_atom)
{
WnckWindow *win;
win = wnck_window_get (xevent->xclient.window);
if (win)
{
action_menu_map (win,
xevent->xclient.data.l[2],
xevent->xclient.data.l[1]);
}
}
else if (action == toolkit_action_force_quit_dialog_atom)
{
WnckWindow *win;
win = wnck_window_get (xevent->xclient.window);
if (win)
{
if (xevent->xclient.data.l[2])
show_force_quit_dialog (win,
xevent->xclient.data.l[1]);
else
hide_force_quit_dialog (win);
}
}
}
else if (xevent->xclient.message_type == decor_request_atom)
{
WnckWindow *win = wnck_window_get (xevent->xclient.window);
if (win)
update_window_decoration_size (win);
}
default:
break;
}
if (xid)
{
WnckWindow *win;
win = wnck_window_get (xid);
if (win)
{
decor_t *d = g_object_get_data (G_OBJECT (win), "decor");
if (d->decorated)
{
gint i, j;
event_callback cb = NULL;
Window w = xevent->xany.window;
for (i = 0; i < 3; ++i)
for (j = 0; j < 3; ++j)
if (d->event_windows[i][j].window == w)
cb = d->event_windows[i][j].callback;
if (!cb)
{
for (i = 0; i < BUTTON_NUM; ++i)
if (d->button_windows[i].window == w)
cb = d->button_windows[i].callback;
}
if (cb)
{
decor_event gtkwd_event;
decor_event_type gtkwd_type;
gtkwd_event.window = w;
switch (xevent->type)
{
case ButtonPress:
case ButtonRelease:
if (xevent->type == ButtonPress)
gtkwd_type = GButtonPress;
else
gtkwd_type = GButtonRelease;
gtkwd_event.button = xevent->xbutton.button;
gtkwd_event.x = xevent->xbutton.x;
gtkwd_event.y = xevent->xbutton.y;
gtkwd_event.x_root = xevent->xbutton.x_root;
gtkwd_event.y_root = xevent->xbutton.y_root;
gtkwd_event.time = xevent->xbutton.time;
break;
case EnterNotify:
case LeaveNotify:
if (xevent->type == EnterNotify)
gtkwd_type = GEnterNotify;
else
gtkwd_type = GLeaveNotify;
gtkwd_event.x = xevent->xcrossing.x;
gtkwd_event.y = xevent->xcrossing.y;
gtkwd_event.x_root = xevent->xcrossing.x_root;
gtkwd_event.y_root = xevent->xcrossing.y_root;
gtkwd_event.time = xevent->xcrossing.time;
break;
default:
cb = NULL;
break;
}
if (cb)
(*cb) (win, >kwd_event, gtkwd_type);
}
}
}
}
return GDK_FILTER_CONTINUE;
}
