/* 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;
}
/**
* gva_wnck_listen_for_new_window:
* @process: a #GvaProcess
* @game: the game that @process is running
*
* Implements spatial MAME windows.
*
* This function gets called immediately after a game is started. It uses
* libwnck to listen for a new window, and does its best to verify whether
* it's a MAME window. If it identifies the window, it restores the size,
* position and maximize state of that particular game from the previous
* session and records any further window geometry changes. The game
* database is used as the storage medium for window geometries.
**/
void
gva_wnck_listen_for_new_window (GvaProcess *process,
const gchar *game)
{
#ifdef HAVE_WNCK
g_return_if_fail (GVA_IS_PROCESS (process));
g_return_if_fail (game != NULL);
if (window_opened_handler_id > 0)
{
g_warning ("GVA can only listen for one new window at a time");
return;
}
g_object_set_data_full (
G_OBJECT (process), "game",
g_strdup (game), (GDestroyNotify) g_free);
/* Keep a weak reference on the process until we can match it
* to a newly opened window, at which time we'll add a real
* reference and bind it to the corresponding WnckWindow.
* If the process exits early we'll know to stop listening. */
g_object_weak_ref (
G_OBJECT (process),
(GWeakNotify) wnck_weak_notify_cb,
wnck_screen_get_default ());
window_opened_handler_id = g_signal_connect (
wnck_screen_get_default (), "window-opened",
G_CALLBACK (wnck_window_opened_cb), process);
gva_main_cursor_busy ();
#endif /* HAVE_WNCK */
}
int main(int argc, char **argv) {
WnckScreen *screen;
WnckWindow *active_window;
GList *window_l;
gdk_init(&argc, &argv);
screen = wnck_screen_get_default();
sleep(5);
wnck_screen_force_update(screen);
active_window = wnck_screen_get_active_window(screen);
for (window_l = wnck_screen_get_windows(screen); window_l != NULL;
window_l = window_l->next) {
WnckWindow *window = WNCK_WINDOW(window_l->data);
if (strcmp(wnck_window_get_name(window), "Terminal") == 0) {
wnck_window_activate(window, (guint32)time(NULL));
break;
}
// g_print("Name: '%s', PID: %d(%lu)%s\n", wnck_window_get_name(window),
// wnck_window_get_pid(window), wnck_window_get_xid(window),
// window == active_window ? " (active)" : "");
}
return 0;
}
int main (int argc, char *argv[])
{
if(argc > 1)
for (int i = 1; i < argc; ++i)
{
std::string ar(argv[i]);
if( ar == "-d")
ad_debug = true;
else if( ar == "-s")
simulate = true;
}
readfiles();
GMainLoop *loop;
WnckScreen *screen;
gdk_init (&argc, &argv);
loop = g_main_loop_new (NULL, FALSE);
screen = wnck_screen_get_default ();
g_signal_connect (screen, "window-opened", G_CALLBACK (on_window_opened), NULL);
g_main_loop_run (loop);
g_main_loop_unref (loop);
return 0;
}
void Application::init() {
b2Vec2 gravity(0.0f, 10.0f);
mWorld = QSharedPointer<b2World>(new b2World(gravity));
mWorld->SetAllowSleeping(false);
// Get windowing system
WnckScreen *screen;
WnckWindow *active_window;
WnckWorkspace *active_workspace;
GList *window_l;
screen = wnck_screen_get_default ();
wnck_screen_force_update (screen);
active_window = wnck_screen_get_active_window (screen);
active_workspace = wnck_screen_get_active_workspace (screen);
for(window_l = wnck_screen_get_windows (screen); window_l != NULL; window_l = window_l->next) {
WnckWindow *window = WNCK_WINDOW (window_l->data);
if(wnck_window_is_on_workspace(window, active_workspace) &&
!wnck_window_is_minimized(window) &&
wnck_window_get_window_type(window) == WNCK_WINDOW_NORMAL) {
mPhysicalWindows.append(QSharedPointer<PhysicalWindow>(new PhysicalWindow(window, mWorld)));
}
}
mPhysicalWindows.append(QSharedPointer<PhysicalWindow>(new PhysicalWindow(100, 100, 100, 100, mWorld)));
}
void init_wnck (WckUtils *win, gboolean only_maximized, gpointer data)
{
/* save data */
win->data = data;
/* get window proprieties */
win->activescreen = wnck_screen_get_default();
win->activeworkspace = wnck_screen_get_active_workspace(win->activescreen);
if (!win->activeworkspace)
win->activeworkspace = wnck_screen_get_workspace(win->activescreen, 0);
win->activewindow = wnck_screen_get_active_window(win->activescreen);
win->umaxwindow = NULL;
win->controlwindow = NULL;
win->only_maximized = only_maximized;
/* Global window tracking */
g_signal_connect(win->activescreen, "active-window-changed", G_CALLBACK (active_window_changed), win);
if (win->only_maximized)
{
win->sch = g_signal_connect(win->activescreen, "window-closed", G_CALLBACK (on_window_closed), win);
win->soh = g_signal_connect(win->activescreen, "window-opened", G_CALLBACK (on_window_opened), win);
}
win->svh = g_signal_connect(win->activescreen, "viewports-changed", G_CALLBACK (on_viewports_changed), win);
win->swh = g_signal_connect(win->activescreen, "active-workspace-changed", G_CALLBACK (active_workspace_changed), win);
/* Get controled window */
track_controled_window (win);
if (!win->controlwindow)
on_control_window_changed (NULL, NULL, win->data);
}
// -----------------------------------------------------------------------------
int g_workspace_count()
{
DEBUGLOGB;
#if _USEGTK
#if _USEWKSPACE
int ret = wnck_screen_get_workspace_count(wnck_screen_get_default());
#else // _USEWKSPACE
#if GTK_CHECK_VERSION(3,0,0)
Screen* xscreen = gdk_x11_screen_get_xscreen(gdk_screen_get_default());
#else
Screen* xscreen = GDK_SCREEN_XSCREEN(gdk_screen_get_default());
#endif
int ret = _wncki_screen_get_workspace_count(xscreen);
#endif // _USEWKSPACE
#else // _USEGTK
int ret = 1;
#endif // _USEGTK
DEBUGLOGE;
return ret;
}
void sux_init(SuxModule *sm, gchar *args)
{
GtkWidget *button, *image;
WnckScreen *screen;
ShowDesktop *sd;
sd = g_new0(ShowDesktop, 1);
button = gtk_toggle_button_new();
gtk_widget_show(button);
image = gtk_image_new_from_file_scaled(IMG_PREFIX "showdesktop.png", 24, 24);
gtk_widget_show(image);
gtk_container_add(GTK_CONTAINER(button), image);
screen = wnck_screen_get_default();
g_object_set_data(G_OBJECT(screen), "sd", sd);
sd->tips = gtk_tooltips_new();
sd->screen = screen;
sd->is_showing_desktop = wnck_screen_get_showing_desktop(sd->screen);
sd->button = button;
update_tooltip(sd);
g_signal_connect(G_OBJECT(button), "toggled",
G_CALLBACK(toggle_show_desktop), sd);
g_signal_connect(G_OBJECT(screen), "showing_desktop_changed",
G_CALLBACK(show_desktop_changed), sd);
sm->widget = sd->button;
}
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);
}
}
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);
}
int main (int argc, char *argv[])
{
/* Make sure we exit cleanly (needed for profiling among other things) */
g_shell_parse_argv(sphinx_command,&argc,&argv,NULL);
gtk_init(&argc, &argv);
scr = wnck_screen_get_default();
while(gtk_events_pending()) gtk_main_iteration();
win = wnck_screen_get_active_window(scr);
tmp=wnck_screen_get_windows(wnck_window_get_screen(win));
signal(SIGINT, &sighandler);
fbs_init (argc, argv);
if ((ad = ad_open_sps (SAMPLE_RATE)) == NULL)
E_FATAL("ad_open_sps failed\n");
// E_INFO("%s COMPILED ON: %s, AT: %s\n\n", argv[0], __DATE__, __TIME__);
if (setjmp(jbuf) == 0) {
utterance_loop (argc,argv);
}
fbs_end ();
ad_close (ad);
return 0;
}
int main(int argc, char **argv) {
gtk_init (&argc, &argv);
client = gconf_client_get_default ();
/* which confs to monitor */
gconf_client_add_dir (client, DEFAULT_BACKGROUND_GCONF_PATH,
GCONF_CLIENT_PRELOAD_NONE, NULL);
gconf_client_add_dir (client, MULTI_BACKGROUND_GCONF_PATH,
GCONF_CLIENT_PRELOAD_NONE, NULL);
#define GET_DEFAULT_BACKGROUND(client, type, entry) \
default_ ## entry = gconf_client_get_ ## type(client, \
DEFAULT_BACKGROUND_GCONF_PATH "/" # entry, \
NULL)
GET_DEFAULT_BACKGROUND(client, string, color_shading_type);
GET_DEFAULT_BACKGROUND(client, bool, draw_background);
GET_DEFAULT_BACKGROUND(client, string, picture_filename);
GET_DEFAULT_BACKGROUND(client, int, picture_opacity);
GET_DEFAULT_BACKGROUND(client, string, picture_options);
GET_DEFAULT_BACKGROUND(client, string, primary_color);
GET_DEFAULT_BACKGROUND(client, string, secondary_color);
screen = wnck_screen_get_default ();
wnck_screen_force_update (screen);
g_signal_connect(G_OBJECT (screen), "active_workspace_changed",
G_CALLBACK (workspace_changed_cb),
NULL);
add_monitors();
gtk_main ();
return 0;
}
// -----------------------------------------------------------------------------
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;
}
static void
workspace_browser_init (WorkspaceBrowser* self)
{
WnckScreen* screen = wnck_screen_get_default ();
g_signal_connect (screen, "workspace-created",
G_CALLBACK (workspace_created_cb), self);
g_signal_connect (screen, "workspace-destroyed",
G_CALLBACK (workspace_destroyed_cb), self);
}
static void
task_title_setup (TaskTitle *title)
{
TaskTitlePrivate *priv = title->priv;
priv->screen = wnck_screen_get_default ();
priv->window = NULL;
gtk_widget_add_events (GTK_WIDGET (title), GDK_ALL_EVENTS_MASK);
priv->align = gtk_alignment_new (0.0, 0.0, 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->grid = gtk_grid_new();
gtk_grid_set_row_spacing (GTK_GRID(priv->grid), 2);
gtk_container_add (GTK_CONTAINER (priv->align), priv->grid);
gtk_widget_set_no_show_all (priv->grid, TRUE);
gtk_widget_show (priv->grid);
//Prepare and show the title label
priv->label = getTitleLabel();
gtk_grid_attach (GTK_GRID(priv->grid), priv->label, 0, 0, 1, 1);
gtk_widget_show (priv->label);
//Create the close button
priv->button = getCloseButton (title);
gtk_grid_attach (GTK_GRID(priv->grid), priv->button, 1, 0, 1, 1);
gtk_widget_show (priv->button);
g_signal_connect (GTK_WIDGET(title), "draw",
G_CALLBACK (on_draw), title);
// Prepare and add the logoff icon to the title
GdkScreen *gdkscreen = gtk_widget_get_screen (GTK_WIDGET (title));
GtkIconTheme *theme = gtk_icon_theme_get_for_screen (gdkscreen);
//this shows a little green exit icon, like the ones on emergency exits
priv->quit_icon = gtk_icon_theme_load_icon (
theme, "gnome-logout", 16, 0, NULL
);
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"));
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_press), NULL);
}
gboolean
dnd_has_one_fullscreen_window (void)
{
gboolean result;
WnckScreen *screen = wnck_screen_get_default ();
wnck_screen_force_update (screen);
WnckWorkspace *workspace = wnck_screen_get_active_workspace (screen);
GList *list = wnck_screen_get_windows (screen);
GList *item = g_list_find_custom (list, workspace, (GCompareFunc) is_fullscreen_cb);
result = item != NULL;
#ifdef HAVE_WNCK_SHUTDOWN
wnck_shutdown ();
#endif
return result;
}
/* FIXME: this will not work with wm using large desktops and viewports
to implement their workspaces.*/
bool WorkspacesInfo::changeCurrent(int newWorkspace)
{
WnckScreen *screen = wnck_screen_get_default();
WnckWorkspace *workspace = wnck_screen_get_workspace(screen, newWorkspace);
if (workspace == NULL) {
UQ_WARNING << "Requested activation workspace" << newWorkspace << " but it does not exist.";
return false;
}
if (newWorkspace == current()) {
return true;
}
/* This function will ask the WM to change workspace. However we have no way to know
if it succeeds or fails. To know that we can only wait to be notified of the workspace
to actually change, or decide we waited too much and proceed anyway */
wnck_workspace_activate(workspace, CurrentTime);
return SignalWaiter().waitForSignal(this, SIGNAL(currentChanged(int)), 50);
}
static void
task_manager_dialog_dispose (GObject *object)
{
TaskManagerDialogPrivate * priv = GET_PRIVATE (object);
if (priv->client)
{
desktop_agnostic_config_client_unbind_all_for_object (priv->client,
object,
NULL);
priv->client=NULL;
}
if ( priv->wm_change_id )
{
g_signal_handler_disconnect (wnck_screen_get_default(),priv->wm_change_id);
priv->wm_change_id = 0;
}
G_OBJECT_CLASS (task_manager_dialog_parent_class)->dispose (object);
}
/**
* ww_apply_layout_by_name
* @layout_name: The name of the layout to apply
*
* Apply a given layout to the default screen by looking up the relevant
* #WwLayout based on its name.
*/
void
ww_apply_layout_by_name (const gchar * layout_name)
{
WnckScreen *screen;
WnckWorkspace *current_ws;
GList *windows, *struts;
WnckWindow *active;
const WwLayout *layout;
GError *error;
screen = wnck_screen_get_default ();
wnck_screen_force_update (screen);
current_ws = wnck_screen_get_active_workspace (screen);
windows = wnck_screen_get_windows (screen);
struts = ww_filter_strut_windows (windows, current_ws);
windows = ww_filter_user_windows (windows, current_ws);
active = wnck_screen_get_active_window (screen);
/* Check that we know the requested layout */
layout = ww_get_layout (layout_name);
if (!layout)
{
g_printerr ("No such layout: '%s'. Try running with --layouts to "
"list possible layouts\n", layout_name);
return;
}
/* Apply the layout */
error = NULL;
layout->handler (screen, windows, struts, active, &error);
g_list_free (windows);
g_list_free (struts);
if (error)
{
g_printerr ("Failed to apply layout '%s'. Error was:\n%s",
layout_name, error->message);
g_error_free (error);
return;
}
}
t_xkb_settings *
xkb_new( void )
{
t_xkb_settings *xkb;
WnckScreen *wnck_screen;
wnck_screen = wnck_screen_get_default();
xkb = g_new0( t_xkb_settings, 1 );
g_signal_connect( G_OBJECT( wnck_screen ), "active-window-changed",
G_CALLBACK (xkb_active_window_changed ), xkb );
g_signal_connect( G_OBJECT( wnck_screen ), "window-closed",
G_CALLBACK (xkb_window_closed ), xkb );
g_signal_connect( G_OBJECT( wnck_screen ), "application-closed",
G_CALLBACK (xkb_application_closed ), xkb );
return xkb;
}
static void
style_updated (GtkWidget *widget,
void *user_data)
{
GdkDisplay *gdkdisplay;
GdkScreen *gdkscreen;
WnckScreen *screen;
PangoContext *context = (PangoContext *) user_data;
gdkdisplay = gdk_display_get_default ();
gdkscreen = gdk_display_get_default_screen (gdkdisplay);
screen = wnck_screen_get_default ();
update_style (widget);
pango_cairo_context_set_resolution (context, gdk_screen_get_resolution (gdkscreen));
decorations_changed (screen);
}
int main (int argc, char **argv)
{
gdk_init (&argc, &argv);
loop = g_main_loop_new (NULL, FALSE);
screen = wnck_screen_get_default ();
signal(SIGINT, INThandler);
g_signal_connect(screen, "active-window-changed",
G_CALLBACK(on_active_window_changed), NULL);
g_main_loop_run (loop);
stop_application();
return 0;
}
static void
task_manager_dialog_constructed (GObject *object)
{
TaskManagerDialogPrivate * priv = GET_PRIVATE (object);
GError *error=NULL;
G_OBJECT_CLASS (task_manager_dialog_parent_class)->constructed (object);
priv->client = awn_config_get_default_for_applet (priv->applet, &error);
if (error)
{
g_debug ("%s: %s",__func__,error->message);
g_error_free (error);
error=NULL;
}
desktop_agnostic_config_client_bind (priv->client,
DESKTOP_AGNOSTIC_CONFIG_GROUP_DEFAULT,
"dialog_mode",
object, "dialog mode", TRUE,
DESKTOP_AGNOSTIC_CONFIG_BIND_METHOD_FALLBACK,
NULL);
desktop_agnostic_config_client_bind (priv->client,
DESKTOP_AGNOSTIC_CONFIG_GROUP_DEFAULT,
"dialog_scale",
object, "dialog scale", TRUE,
DESKTOP_AGNOSTIC_CONFIG_BIND_METHOD_FALLBACK,
NULL);
priv->children = NULL;
priv->main_box = gtk_vbox_new (FALSE,3);
priv->items_box = gtk_hbox_new (FALSE,3);
priv->current_dialog_mode = priv->dialog_mode;
gtk_container_add (GTK_CONTAINER (priv->main_box),priv->items_box);
gtk_container_add (GTK_CONTAINER (object),priv->main_box);
gtk_widget_show_all (priv->main_box);
task_manager_dialog_analyze_wm (TASK_MANAGER_DIALOG(object));
priv->wm_change_id = g_signal_connect_swapped (wnck_screen_get_default(),"window-manager-changed",
G_CALLBACK(task_manager_dialog_analyze_wm),object);
}
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);
}
}
static void wibuti_watcher_init(WibutiWatcher *self) {
self->only_maximized = FALSE;
self->tracked = NULL;
self->screen = wnck_screen_get_default();
wnck_screen_force_update(self->screen);
wibuti_watcher_find_window(self);
g_signal_connect(G_OBJECT(self->screen), "active-workspace-changed",
G_CALLBACK(wibuti_watcher_active_workspace_changed_cb), self);
g_signal_connect(G_OBJECT(self->screen), "active-window-changed",
G_CALLBACK(wibuti_watcher_active_window_changed_cb), self);
g_signal_connect(G_OBJECT(self->screen), "viewports-changed",
G_CALLBACK(wibuti_watcher_viewports_changed_cb), self);
g_signal_connect(G_OBJECT(self->screen), "window-closed",
G_CALLBACK(wibuti_watcher_window_closed_cb), self);
g_signal_connect(G_OBJECT(self->screen), "window-opened",
G_CALLBACK(wibuti_watcher_window_opened_cb), self);
g_signal_emit_by_name(self, WIBUTI_SIGNAL_WINDOW_CHANGED);
}
void
Application::connectWindowSignals()
{
if (m_application == NULL || m_application->running() == false) {
return;
}
QScopedPointer<BamfWindowList> windows(m_application->windows());
const int size = windows->size();
if (size < 1) {
return;
}
WnckScreen* screen = wnck_screen_get_default();
wnck_screen_force_update(screen);
for (int i = 0; i < size; ++i) {
BamfWindow *window = windows->at(i);
onWindowAdded(window);
}
}
int
main (int argc,
char **argv)
{
GMainLoop *loop;
WnckScreen *screen;
gdk_init (&argc, &argv);
loop = g_main_loop_new (NULL, FALSE);
screen = wnck_screen_get_default ();
g_signal_connect (screen, "window-opened",
G_CALLBACK (on_window_opened), NULL);
g_signal_connect (screen, "active-window-changed",
G_CALLBACK (on_active_window_changed), NULL);
g_main_loop_run (loop);
g_main_loop_unref (loop);
return 0;
}
int
main (int argc, char **argv)
{
static const GOptionEntry options[] = {
{ "also-trigger-on-caps-lock", 'c', 0, G_OPTION_ARG_NONE,
&also_trigger_on_caps_lock,
"Make the Caps Lock key also switch windows (as well as the Super key)",
NULL },
{ "only-trigger-on-caps-lock", 'C', 0, G_OPTION_ARG_NONE,
&only_trigger_on_caps_lock,
"Make only the Caps Lock key switch windows (instead of the Super key)",
NULL },
{ "version", 'v', 0, G_OPTION_ARG_NONE, &show_version_and_exit,
"Show the version number and exit", NULL },
#ifdef HAVE_XCOMPOSITE
{ "show-window-thumbnails", 't', 0, G_OPTION_ARG_NONE,
&show_window_thumbnails,
"EXPERIMENTAL - Show window thumbnails (instead of icons)", NULL },
#endif
{ NULL }
};
GdkWindow *root;
GOptionContext *context;
GError *error;
gtk_init (&argc, &argv);
context = g_option_context_new ("");
error = NULL;
g_option_context_add_main_entries (context, options, NULL);
g_option_context_parse (context, &argc, &argv, &error);
if (error) {
g_printerr ("%s\n", error->message);
g_error_free (error);
exit (ABNORMAL_EXIT_CODE_UNKNOWN_COMMAND_LINE_OPTION);
}
if (show_version_and_exit) {
// VERSION comes from the Makefile generated by autogen.sh and configure.in.
printf ("SuperSwitcher version %s\n", VERSION);
return 0;
}
#ifdef HAVE_DBUS_GLIB
// Note that this may exit(...) if another instance is already running.
init_superswitcher_dbus ();
#endif
#ifdef HAVE_XCOMPOSITE
if (show_window_thumbnails) {
show_window_thumbnails = init_composite ();
}
#endif
root = gdk_get_default_root_window ();
x_root_window = GDK_WINDOW_XWINDOW (root);
gdk_window_add_filter (root, filter_func, NULL);
if (!only_trigger_on_caps_lock) {
grab (XK_Super_L);
grab (XK_Super_R);
}
if (also_trigger_on_caps_lock || only_trigger_on_caps_lock) {
disable_caps_lock_default_behavior ();
grab (XK_Caps_Lock);
}
screen = ss_screen_new (wnck_screen_get_default (),
GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
x_root_window);
gtk_main ();
#ifdef HAVE_XCOMPOSITE
if (show_window_thumbnails) {
uninit_composite ();
}
#endif
return 0;
}
/* Do the actual applet initialization */
static void init_wtapplet (PanelApplet *applet) {
WTApplet *wtapplet = g_new0 (WTApplet, 1);
wtapplet->applet = applet;
wtapplet->prefs = loadPreferences(wtapplet);
wtapplet->activescreen = wnck_screen_get_default();
wnck_screen_force_update(wtapplet->activescreen);
wtapplet->activeworkspace = wnck_screen_get_active_workspace(wtapplet->activescreen);
wtapplet->activewindow = wnck_screen_get_active_window(wtapplet->activescreen);
wtapplet->umaxedwindow = getUpperMaximized(wtapplet);
wtapplet->rootwindow = getRootWindow(wtapplet->activescreen);
wtapplet->prefbuilder = gtk_builder_new();
wtapplet->box = GTK_BOX(gtk_hbox_new(FALSE, 0));
wtapplet->icon = GTK_IMAGE(gtk_image_new());
wtapplet->title = GTK_LABEL(gtk_label_new(NULL));
wtapplet->eb_icon = GTK_EVENT_BOX(gtk_event_box_new());
wtapplet->eb_title = GTK_EVENT_BOX(gtk_event_box_new());
wtapplet->orient = panel_applet_get_orient(wtapplet->applet);
wtapplet->size_hints = g_new(gint,2);
// Widgets to eventboxes, eventboxes to box
gtk_widget_set_can_focus(GTK_WIDGET(wtapplet->icon), TRUE);
gtk_widget_set_can_focus(GTK_WIDGET(wtapplet->title), TRUE);
gtk_container_add (GTK_CONTAINER (wtapplet->eb_icon), GTK_WIDGET(wtapplet->icon));
gtk_container_add (GTK_CONTAINER (wtapplet->eb_title), GTK_WIDGET(wtapplet->title));
gtk_event_box_set_visible_window (wtapplet->eb_icon, FALSE);
gtk_event_box_set_visible_window (wtapplet->eb_title, FALSE);
// Rotate & place elements
setAlignment(wtapplet, (gfloat)wtapplet->prefs->alignment);
placeWidgets(wtapplet);
// Add box to applet
gtk_container_add (GTK_CONTAINER(wtapplet->applet), GTK_WIDGET(wtapplet->box));
// Set event handling (icon & title clicks)
g_signal_connect(G_OBJECT (wtapplet->eb_icon), "button-press-event", G_CALLBACK (icon_clicked), wtapplet);
g_signal_connect(G_OBJECT (wtapplet->eb_title), "button-press-event", G_CALLBACK (title_clicked), wtapplet);
// Global window tracking
g_signal_connect(wtapplet->activescreen, "active-window-changed", G_CALLBACK (active_window_changed), wtapplet); // <-- this thing is crashing with compiz !!!
g_signal_connect(wtapplet->activescreen, "viewports-changed", G_CALLBACK (viewports_changed), wtapplet);
g_signal_connect(wtapplet->activescreen, "active-workspace-changed", G_CALLBACK (active_workspace_changed), wtapplet);
g_signal_connect(wtapplet->activescreen, "window-closed", G_CALLBACK (window_closed), wtapplet);
g_signal_connect(wtapplet->activescreen, "window-opened", G_CALLBACK (window_opened), wtapplet);
// g_signal_connect(G_OBJECT (wtapplet->title), "size-request", G_CALLBACK (applet_title_size_request), wtapplet);
g_signal_connect(G_OBJECT (wtapplet->applet), "size-allocate", G_CALLBACK (applet_size_allocate), wtapplet);
g_signal_connect(G_OBJECT (wtapplet->applet), "change-background", G_CALLBACK (applet_change_background), wtapplet);
g_signal_connect(G_OBJECT (wtapplet->applet), "change-orient", G_CALLBACK (applet_change_orient), wtapplet);
g_signal_connect(G_OBJECT (wtapplet->applet), "change-size", G_CALLBACK (applet_change_pixel_size), wtapplet);
// Track active window changes
wtapplet->active_handler_state =
g_signal_connect(G_OBJECT (wtapplet->activewindow), "state-changed", G_CALLBACK (active_window_state_changed), wtapplet);
wtapplet->active_handler_name =
g_signal_connect(G_OBJECT (wtapplet->activewindow), "name-changed", G_CALLBACK (active_window_nameicon_changed), wtapplet);
wtapplet->active_handler_icon =
g_signal_connect(G_OBJECT (wtapplet->activewindow), "icon-changed", G_CALLBACK (active_window_nameicon_changed), wtapplet);
// Setup applet right-click menu
GtkActionGroup *action_group = gtk_action_group_new ("WindowButtons Applet Actions");
gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
gtk_action_group_add_actions (action_group, windowtitle_menu_actions, G_N_ELEMENTS (windowtitle_menu_actions), wtapplet);
panel_applet_setup_menu (applet, windowtitle_menu_items, action_group);
panel_applet_set_background_widget (wtapplet->applet, GTK_WIDGET (wtapplet->applet)); // Automatic background update
toggleExpand (wtapplet);
toggleHidden (wtapplet); // Properly hide or show stuff
updateTitle (wtapplet);
}
int main (int argc, char **argv)
{
GdkWindow *rootwindow; /* RootWindow of X11*/
GMainLoop *loop; /* the event loop */
char *pw_dir;
char *xml_file;
uid_t uid;
struct passwd *pass;
/* inits some gdk stuff */
gdk_init(&argc, &argv);
#ifdef ENABLE_LIBWNCK
screen = wnck_screen_get_default ();
wnck_screen_force_update (screen);
#endif
parse_options(&argc, &argv);
uid = getuid();
pass = getpwuid (uid);
pw_dir = pass->pw_dir;
xml_file = (char*) malloc (sizeof (char) * (strlen (XML_FILE) + strlen (pw_dir) + 1));
sprintf (xml_file, "%s%s", pw_dir, XML_FILE);
eventlist = parseDoc (xml_file);
if (eventlist == NULL)
{
g_print ("xml error or no elements in list\n");
exit (1);
}
free (xml_file);
rootwindow = gdk_window_foreign_new (gdk_x11_get_default_root_xwindow());
/*rootwindow = gdk_window_foreign_new (0x1200002); */
if (rootwindow == NULL)
{
g_print ("rootwindow == NULL\n");
exit (1);
}
/* check if GDK_BUTTON_PRESS_MASK is available */
gdk_error_trap_push ();
/* ... Call the X function which may cause an error here ... */
gdk_window_set_events (rootwindow, GDK_BUTTON_PRESS_MASK);
gdk_window_set_events (rootwindow, GDK_SCROLL_MASK);
/* Flush the X queue to catch errors now. */
gdk_flush ();
if (gdk_error_trap_pop ())
{
char error[] = "grootevent: an error occured while querying the X server.\n"
"A window manager or an application is already grapping\n"
"the buttons from the root window.\n\n"
"Please read the documentation to get more help about this.\n";
g_print (error);
exit (1);
}
gdk_event_handler_set (event_func, NULL, NULL);
loop = g_main_loop_new (NULL, FALSE);
g_main_loop_run (loop);
return 0;
}