events.c

            else if(!(c->transient_for))
            {
                clientSetWorkspace(c, ev->data.l[0], TRUE);
            }
        }
        else if((ev->message_type == net_close_window) && (ev->format == 32))
        {
            DBG("client \"%s\" (%#lx) has received a net_close_window event\n", c->name, c->window);
            clientClose(c);
        }
        else if((ev->message_type == net_wm_state) && (ev->format == 32))
        {
            DBG("client \"%s\" (%#lx) has received a net_wm_state event\n", c->name, c->window);
            clientUpdateNetState(c, ev);
        }
        else if((ev->message_type == net_wm_moveresize) && (ev->format == 32))
        {
            DBG("client \"%s\" (%#lx) has received a net_wm_moveresize event\n", c->name, c->window);
            g_message(_("%s: Operation not supported (yet)\n"), g_get_prgname());
            /* TBD */
        }
        else if((ev->message_type == net_active_window) && (ev->format == 32))
        {
            DBG("client \"%s\" (%#lx) has received a net_active_window event\n", c->name, c->window);
            workspaceSwitch(c->win_workspace, NULL);
            clientShow(c, True);
            clientRaise(c);
            clientSetFocus(c, True);
        }
    }
    else
    {
        if(((ev->message_type == win_workspace) || (ev->message_type == net_current_desktop)) && (ev->format == 32))
        {
            DBG("root has received a win_workspace or a net_current_desktop event\n");
            workspaceSwitch(ev->data.l[0], NULL);
        }
        else if(((ev->message_type == win_workspace_count) || (ev->message_type == net_number_of_desktops)) && (ev->format == 32))
        {
            DBG("root has received a win_workspace_count event\n");
            workspaceSetCount(ev->data.l[0]);
        }
	else
	{
            DBG("unidentified client message for window 0x%lx\n", ev->window);
	}
    }
}

static inline void handleShape(XShapeEvent * ev)
{
    Client *c;

    DBG("entering handleShape\n");

    c = clientGetFromWindow(ev->window, WINDOW);
    if(c)
    {
        frameDraw(c, FALSE, TRUE);
    }
}

static inline void handleColormapNotify(XColormapEvent * ev)
{
    Client *c;

    DBG("entering handleColormapNotify\n");

    c = clientGetFromWindow(ev->window, WINDOW);
    if((c) && (ev->window == c->window) && (ev->new))
    {
        if(c == clientGetFocus())
        {
            clientInstallColormaps(c);
        }
    }
}

void handleEvent(XEvent * ev)
{
    DBG("entering handleEvent\n");

    sn_process_event(ev);
    switch (ev->type)
    {
        case KeyPress:
            handleKeyPress((XKeyEvent *) ev);
            break;
        case ButtonPress:
            handleButtonPress((XButtonEvent *) ev);
            break;
        case ButtonRelease:
            handleButtonRelease((XButtonEvent *) ev);
            break;
        case DestroyNotify:
            handleDestroyNotify((XDestroyWindowEvent *) ev);
            break;
        case UnmapNotify:
            handleUnmapNotify((XUnmapEvent *) ev);
            break;
        case MapRequest:
            handleMapRequest((XMapRequestEvent *) ev);
            break;
        case ConfigureRequest:
            handleConfigureRequest((XConfigureRequestEvent *) ev);
            break;
        case EnterNotify:
            handleEnterNotify((XCrossingEvent *) ev);
            break;
        case FocusIn:
            handleFocusIn((XFocusChangeEvent *) ev);
            break;
        case FocusOut:
            handleFocusOut((XFocusChangeEvent *) ev);
            break;
        case PropertyNotify:
            handlePropertyNotify((XPropertyEvent *) ev);
            break;
        case ClientMessage:
            handleClientMessage((XClientMessageEvent *) ev);
            break;
        case ColormapNotify:
            handleColormapNotify((XColormapEvent *) ev);
            break;
        default:
            if(shape && (ev->type == shape_event))
            {
                handleShape((XShapeEvent *) ev);
            }
    }
    if(!gdk_events_pending() && !XPending(dpy))
    {
        if(reload)
        {
            reloadSettings(UPDATE_ALL);
            reload = False;
        }
        else if(quit)
        {
            gtk_main_quit();
        }
    }
}


GtkToXEventFilterStatus xfwm4_event_filter(XEvent * xevent, gpointer data)
{
    DBG("entering xfwm4_event_filter\n");
    handleEvent(xevent);
    DBG("leaving xfwm4_event_filter\n");
    return XEV_FILTER_STOP;
}

/* GTK stuff (menu, etc...) */

static void menu_callback(Menu * menu, MenuOp op, Window client_xwindow, gpointer menu_data, gpointer item_data)
{
    Client *c = NULL;

    DBG("entering menu_callback\n");

    if(menu_event_window)
    {
        removeTmpEventWin(menu_event_window);
        menu_event_window = None;
    }

    if(menu_data)
    {
        c = (Client *) menu_data;
        c = clientGetFromWindow(c->window, WINDOW);
        if(c)
        {
            c->button_pressed[MENU_BUTTON] = False;
        }
    }

    switch (op)
    {
        case MENU_OP_QUIT:
            gtk_main_quit();
            break;
        case MENU_OP_MAXIMIZE:
        case MENU_OP_UNMAXIMIZE:
            if((c) && CLIENT_CAN_MAXIMIZE_WINDOW(c))
            {
                clientToggleMaximized(c, WIN_STATE_MAXIMIZED);
            }
            break;
        case MENU_OP_MINIMIZE:
            if((c) && CLIENT_CAN_HIDE_WINDOW(c))
            {
                clientHide(c, True);
            }
            break;
        case MENU_OP_MINIMIZE_ALL:
            clientHideAll(c);
            break;
        case MENU_OP_UNMINIMIZE:
            if(c)
            {
                clientShow(c, True);
            }
            break;
        case MENU_OP_SHADE:
        case MENU_OP_UNSHADE:
            if(c)
            {
                clientToggleShaded(c);
            }
            break;
        case MENU_OP_STICK:
        case MENU_OP_UNSTICK:
            if(c)
            {
                frameDraw(c, FALSE, FALSE);
                clientToggleSticky(c, TRUE);
            }
            break;
        case MENU_OP_DELETE:
            if(c)
            {
                frameDraw(c, FALSE, FALSE);
                clientClose(c);
            }
            break;
        default:
            if(c)
            {
                frameDraw(c, FALSE, FALSE);
            }
            break;
    }
    menu_free(menu);
}

static gboolean show_popup_cb(GtkWidget * widget, GdkEventButton * ev, gpointer data)
{
    Menu *menu;
    MenuOp ops;
    MenuOp insensitive;
    Client *c = NULL;
    gint x = ev->x_root;
    gint y = ev->y_root;

    DBG("entering show_popup_cb\n");

    if(((ev->button == 1) || (ev->button == 3)) && (c = (Client *) data))
    {
        c->button_pressed[MENU_BUTTON] = True;
        frameDraw(c, FALSE, FALSE);
        y = c->y;
        ops = MENU_OP_DELETE | MENU_OP_MINIMIZE_ALL;
        insensitive = 0;

        if(!CLIENT_FLAG_TEST(c, CLIENT_FLAG_HAS_CLOSE))
        {
            insensitive |= MENU_OP_DELETE;
        }

        if(CLIENT_FLAG_TEST(c, CLIENT_FLAG_MAXIMIZED))
        {
            ops |= MENU_OP_UNMAXIMIZE;
            if(!CLIENT_CAN_MAXIMIZE_WINDOW(c))
            {
                insensitive |= MENU_OP_UNMAXIMIZE;
            }
        }
        else
        {
            ops |= MENU_OP_MAXIMIZE;
            if(!CLIENT_CAN_MAXIMIZE_WINDOW(c))
            {
                insensitive |= MENU_OP_MAXIMIZE;
            }
        }

        if(CLIENT_FLAG_TEST(c, CLIENT_FLAG_HIDDEN))
        {
            ops |= MENU_OP_UNMINIMIZE;
            if(!CLIENT_CAN_HIDE_WINDOW(c))
            {
                insensitive |= MENU_OP_UNMINIMIZE;
            }
        }
        else
        {
            ops |= MENU_OP_MINIMIZE;
            if(!CLIENT_CAN_HIDE_WINDOW(c))
            {
                insensitive |= MENU_OP_MINIMIZE;
            }
        }

        if(CLIENT_FLAG_TEST(c, CLIENT_FLAG_SHADED))
        {
            ops |= MENU_OP_UNSHADE;
        }
        else
        {
            ops |= MENU_OP_SHADE;
        }

        if(CLIENT_FLAG_TEST(c, CLIENT_FLAG_STICKY))
        {
            ops |= MENU_OP_UNSTICK;
            if(!CLIENT_FLAG_TEST(c, CLIENT_FLAG_HAS_STICK))
            {
                insensitive |= MENU_OP_UNSTICK;
            }
        }
        else
        {
            ops |= MENU_OP_STICK;
            if(!CLIENT_FLAG_TEST(c, CLIENT_FLAG_HAS_STICK))
            {
                insensitive |= MENU_OP_STICK;
            }
        }
    }
    else
    {
        return (TRUE);
    }

    if(button_handler_id)
    {
        g_signal_handler_disconnect(GTK_OBJECT(getDefaultGtkWidget()), button_handler_id);
    }
    button_handler_id = g_signal_connect(GTK_OBJECT(getDefaultGtkWidget()), "button_press_event", GTK_SIGNAL_FUNC(show_popup_cb), (gpointer) NULL);

    if(menu_event_window)
    {
        removeTmpEventWin(menu_event_window);
        menu_event_window = None;
    }
    /* 
       Since all button press/release events are catched by the windows frames, there is some 
       side effect with GTK menu. When a menu is opened, any click on the window frame is not
       detected as a click outside the menu, and the menu doesn't close.
       To avoid this (painless but annoying) behaviour, we just setup a no event window that 
       "hides" the events to regular windows. 
       That might look tricky, but it's very efficient and save plenty of lines of complicated 
       code.
       Don't forget to delete that window once the menu is closed, though, or we'll get in 
       trouble.
     */
    menu_event_window = setTmpEventWin(NoEventMask);
    menu = menu_default(ops, insensitive, menu_callback, c);
    if(!menu_popup(menu, x, y, ev->button, ev->time))
    {
        DBG("Cannot open menu\n");
        gdk_beep();
        c->button_pressed[MENU_BUTTON] = False;
        frameDraw(c, FALSE, FALSE);
        removeTmpEventWin(menu_event_window);
        menu_event_window = None;
        menu_free(menu);
    }
    return (TRUE);
}

static gboolean set_reload(void)
{
    DBG("setting reload flag so all prefs will be reread at next event loop\n");
    reload = True;
    return (TRUE);
}

static gboolean dbl_click_time(void)
{
    GValue tmp_val = { 0, };

    DBG("setting dbl_click_time\n");

    g_value_init(&tmp_val, G_TYPE_INT);
    if(gdk_setting_get("gtk-double-click-time", &tmp_val))
    {
        params.dbl_click_time = abs(g_value_get_int(&tmp_val));
    }

    return (TRUE);
}

static gboolean client_event_cb(GtkWidget * widget, GdkEventClient * ev)
{
    DBG("entering client_event_cb\n");

    if(!atom_rcfiles)
    {
        atom_rcfiles = gdk_atom_intern("_GTK_READ_RCFILES", FALSE);
    }

    if(ev->message_type == atom_rcfiles)
    {
        set_reload();
    }

    return (FALSE);
}

void initGtkCallbacks(void)
{
    GtkSettings *settings;

    button_handler_id = g_signal_connect(GTK_OBJECT(getDefaultGtkWidget()), "button_press_event", GTK_SIGNAL_FUNC(show_popup_cb), (gpointer) NULL);
    g_signal_connect(GTK_OBJECT(getDefaultGtkWidget()), "client_event", GTK_SIGNAL_FUNC(client_event_cb), (gpointer) NULL);

    settings = gtk_settings_get_default();
    if(settings)
    {
        g_signal_connect(settings, "notify::gtk-theme-name", G_CALLBACK(set_reload), NULL);
        g_signal_connect(settings, "notify::gtk-font-name", G_CALLBACK(set_reload), NULL);
        g_signal_connect(settings, "notify::gtk-double-click-time", G_CALLBACK(dbl_click_time), NULL);
    }
}