xwindow.c

Go to the documentation of this file.

/*
 * File Name: xwindow.c
 */

/*
 * This file is part of sysd.
 *
 * sysd is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * sysd 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/>.
 */

/**
 * Copyright (C) 2008 iRex Technologies B.V.
 * All rights reserved.
 */

//----------------------------------------------------------------------------
// Include Files
//----------------------------------------------------------------------------

// system include files, between < >
#include <glib.h>
#include <string.h>
#include <sys/time.h>
#include <hal/libhal.h>
#include <gdk/gdkx.h>
#include <gtk/gtk.h>
#include <X11/Xlib.h>
#include <X11/Xatom.h>
#include <X11/extensions/scrnsaver.h>

// ereader include files, between < >

// local include files, between " "
#include "log.h"
#include "xwindow.h"


//----------------------------------------------------------------------------
// Type Declarations
//----------------------------------------------------------------------------


//----------------------------------------------------------------------------
// Constants
//----------------------------------------------------------------------------


//----------------------------------------------------------------------------
// Static Variables
//----------------------------------------------------------------------------

static Atom atom_client_list;
static Atom atom_active_window;
static Atom atom_wm_user_time;
static Display *g_display = NULL;


//============================================================================
// Local Function Definitions
//============================================================================

static GList *get_window_list       (void);
static int   on_x_error             (Display *display, XErrorEvent *event);


//============================================================================
// Functions Implementation
//============================================================================

void window_set_services()
{
    // make Xlib thread safe
    XInitThreads();
    
    LOGPRINTF("XinitThreads returned");
    
    // install custom error handler to avoid X's default fatal errors
    XSetErrorHandler(on_x_error);
    
    // set display globally
    g_display = gdk_x11_get_default_xdisplay();

    // set atoms globally
    atom_client_list   = XInternAtom(g_display, "_NET_CLIENT_LIST", False);
    atom_active_window = XInternAtom(g_display, "_NET_ACTIVE_WINDOW", False);
    atom_wm_user_time  = XInternAtom(g_display, "_NET_WM_USER_TIME", False);
}


Window get_application_window(const char *app_name)
{
    LOGPRINTF("entry: %s", app_name);
    
    Atom type;
    int format;
    unsigned char *data = NULL;
    unsigned long n_items, bytes_after;
    int result;
    int i;

    g_return_val_if_fail(app_name != NULL, 0);
    
    // get list of available windows
    //
    result = XGetWindowProperty(g_display, RootWindow(g_display, DefaultScreen(g_display)), 
                                atom_client_list,
                                0, 10000L,
                                False, XA_WINDOW,
                                &type, &format, &n_items,
                                &bytes_after, (unsigned char **)&data);

    if (result != Success || data == NULL || n_items == 0)
    {
        if (data) XFree(data);
        WARNPRINTF("failed to get client list, %d (items=%ld)", result, n_items);
        return None;
    }

    // check backwards as new application is likely last in line
    for (i = n_items-1; i >= 0; i--)
    {
        XClassHint hint;
        Window wnd = ((Window*)data)[i];
        
        // get name of application of the window
        //
        if (XGetClassHint(g_display, wnd, &hint))
        {
            LOGPRINTF("Window [%d] %d, %s", i, (guint) wnd, hint.res_name);
            
            if (strcmp(hint.res_name, app_name) == 0)
            {
                // found our application
                if (data) XFree(data);
                return wnd;
            }
        }
    }
    
    if (data) XFree(data);
    return None;
}


gboolean window_register_destroy(Window new_window, void *callback_destroy, void  *user_data)
{
    LOGPRINTF("entry");
    
    GList *l;
    l = get_window_list();
    
    while (l)
    {
        Window window = (Window) l->data;
        
        if (window == new_window)
        {
            LOGPRINTF("window found, register destroy handler");
            
            g_signal_connect(G_OBJECT(window),
                             "destroy",
                             G_CALLBACK(callback_destroy),
                             user_data);
            return TRUE;
        }
        l = l->next;
    }
    
    WARNPRINTF("window not found: %d", (guint) new_window);
    g_list_free(l);
    return FALSE;
}


void window_activate(Window win)
{
    LOGPRINTF("entry");

    guint32 timestamp = gtk_get_current_event_time();

    // update user time for window
    XChangeProperty(g_display, win, atom_wm_user_time, XA_CARDINAL, 32, PropModeReplace, (guchar *) &timestamp, 1);
    
    XEvent ev;
    memset(&ev, 0, sizeof ev);
    ev.xclient.type = ClientMessage;
    ev.xclient.window = win;
    ev.xclient.message_type = atom_active_window;
    ev.xclient.format = 32;
    ev.xclient.data.l[0] = 1;
    ev.xclient.data.l[1] = 0;
    ev.xclient.data.l[2] = 0;
    ev.xclient.data.l[3] = 0;
    ev.xclient.data.l[4] = 0;
    
    // activate/raise window
    //
    XSendEvent(g_display,
               RootWindow(g_display, DefaultScreen(g_display)), 
               False,
               SubstructureRedirectMask, 
               &ev);
}


/* result should be freed when no longer used */
char *get_application_of_window(Window wnd)
{
    gchar *app_name = NULL;
    XClassHint hint;
    
    LOGPRINTF("entry: %d", (int) wnd);

    if (XGetClassHint(g_display, wnd, &hint))
    {
        LOGPRINTF("Window %s, %s", hint.res_name, hint.res_class);
        app_name = g_strdup(hint.res_name);
        if (hint.res_name) XFree(hint.res_name);
        if (hint.res_class) XFree(hint.res_class);
        return app_name;
    }
    
    return NULL;
}


gint window_get_idle_time() 
{
    gint idle_time = -1;
    static XScreenSaverInfo *info;

    LOGPRINTF("entry");
    
    info = XScreenSaverAllocInfo();
    if (info != NULL)
    {
        XScreenSaverQueryInfo(g_display, RootWindow(g_display, DefaultScreen(g_display)), info);
        idle_time = (info->idle) / 1000;
        XFree(info);
    }
    return idle_time;
}


//============================================================================
// Local Functions Implementation
//============================================================================

#if (TESTING_ON)
void print_window_list()
{
    Atom type;
    int format;
    unsigned char *data = NULL;
    unsigned long n_items, bytes_after;
    int result;

    // get list of available windows
    //
    result = XGetWindowProperty(g_display, RootWindow(g_display, DefaultScreen(g_display)), 
                                atom_client_list,
                                0, 10000L,
                                False, XA_WINDOW,
                                &type, &format, &n_items,
                                &bytes_after, (unsigned char **)&data);

    if (result != Success || data == NULL || n_items == 0)
    {
        if (data) XFree(data);
        WARNPRINTF("failed to get client list, %d (items=%ld)", result, n_items);
        return;
    }

    printf("%s() WINDOWS (%lu)\n", __func__, n_items);
    
    unsigned int i;
    for (i = 0; i < n_items; i++)
    {
        XClassHint hint;
        Window wnd = ((Window*)data)[i];
        
        // get name of application of the window
        //
        if (XGetClassHint(g_display, wnd, &hint))
        {
            printf("  Window [%d] %d, %s\n", i, (guint) wnd, hint.res_name);
        }
    }
    if (data) XFree(data);
}
#endif


static GList *get_window_list()
{
    LOGPRINTF("entry");
    
    Atom type;
    int format;
    unsigned char *data = NULL;
    unsigned long n_items, bytes_after;
    int result;
    GList *l = NULL; 
        
    // get list of available windows
    //
    result = XGetWindowProperty(g_display, RootWindow(g_display, DefaultScreen(g_display)), 
                                atom_client_list,
                                0, 10000L,
                                False, XA_WINDOW,
                                &type, &format, &n_items,
                                &bytes_after, (unsigned char **)&data);

    unsigned int i;
    for (i = 0; i <n_items; i++)
    {
//        LOGPRINTF("-- window %s");
        l = g_list_prepend(l, (gpointer) ((Window*)data)[i]);
    }
    
    if (data) XFree(data);
    return l;    
}


static int on_x_error(Display *display, XErrorEvent *event)
{
    char buf[100];

    XGetErrorText(display, event->error_code, buf, sizeof(buf));
    ERRORPRINTF("X error: %s", buf);

    return 0;
}