xutil.cpp

一个3D桌面的实现源码

                                harea,
                                varea,
                                CurrentTime);
    XSync(display, 0);
    return;
}


void VDesktops::gnome_get_area_info(struct gnome_area_info *info)
{
    Atom area_atom;
    Atom area_count_atom;
    char *val;
    long length;
    Atom type;
    int size;
   
    area_atom = XInternAtom(display, "_WIN_AREA", False);
    area_count_atom = XInternAtom(display, "_WIN_AREA_COUNT", False);

    if (Get_Window_Property(display, root_win, area_atom, &length, 
                            &type, &size, &val)) 
    {
        // use DEBUG instead of ERROR so that we don't get an error
        // message when it fails but workspaces are found
        msgout(DEBUG, "get property WIN_AREA failed - setting one\n");
        info->harea = 0;
        info->varea = 0;
    } else {
        info->harea = ((long *) val)[0];
        info->varea = ((long *) val)[1];
        XFree(val);
    }

    if (Get_Window_Property(display, root_win, area_count_atom,
                            &length, &type, &size, &val)) 
    {
        // use DEBUG instead of ERROR so that we don't get an error
        // message when it fails but workspaces are found
        msgout(DEBUG, "get property WIN_AREA_COUNT failed - setting one\n");
        info->harea_count = 1;
        info->varea_count = 1;
    } else {
        info->harea_count = ((long *) val)[0];
        info->varea_count = ((long *) val)[1];
        XFree(val);
    }

    return;
}

//===========================
// gnome - workspaces
//===========================

void VDesktops::gnome_set_current_workspace (int workspace)
{
    int rc;
    Atom workspace_atom;
    
    workspace_atom = XInternAtom(display, "_WIN_WORKSPACE", False);

    rc = send_client_message_32(display,
                                root_win, root_win,
                                workspace_atom,
                                SubstructureNotifyMask,
                                2,
                                workspace,
                                CurrentTime);
    XSync(display, 0);
    return;
}

void VDesktops::gnome_get_workspace_info(struct gnome_workspace_info *info)
{
    Atom workspace_atom;
    Atom workspace_count_atom;
    char *val;
    long length;
    Atom type;
    int size;
   
    workspace_atom = XInternAtom(display, "_WIN_WORKSPACE", False);
    workspace_count_atom = XInternAtom(display, "_WIN_WORKSPACE_COUNT", False);

    if (Get_Window_Property(display, root_win, workspace_atom, &length, 
                            &type, &size, &val)) 
    {
        msgout(DEBUG, "get property WIN_WORKSPACE failed - setting one\n");
        info->workspace = 0;
    } else {
        info->workspace = (long) * (long *)val;
        XFree(val);
    }

    if (Get_Window_Property(display, root_win, workspace_count_atom,
                            &length, &type, &size, &val)) 
    {
        msgout(DEBUG, "get property WIN_WORKSPACE_COUNT failed - setting one\n");
        info->workspace_count = 1;
    } else {
        info->workspace_count = (long) * (long *)val;
        XFree(val);
    }

    return;
}


//===========================
// EWMH - desktops (GNOME 2, KDE 3 etc)
//===========================

void VDesktops::ewmh_set_current_desktop (int workspace)
{
    int rc;
    Atom workspace_atom;
    
    workspace_atom = XInternAtom(display, "_NET_CURRENT_DESKTOP", False);

    rc = send_client_message_32(display,
                                root_win, root_win,
                                workspace_atom,
                               (SubstructureNotifyMask |
                                SubstructureRedirectMask),
                                2,
                                workspace,
                                CurrentTime);
    XSync(display, 0);
    return;
}

void VDesktops::ewmh_get_desktop_info(struct gnome_workspace_info *info)
{
    Atom desktop_atom;
    Atom desktop_count_atom;
    char *val;
    long length;
    Atom type;
    int size;
   
    desktop_atom = XInternAtom(display, "_NET_CURRENT_DESKTOP", False);
    desktop_count_atom = XInternAtom(display, "_NET_NUMBER_OF_DESKTOPS", False);

    if (Get_Window_Property(display, root_win, desktop_atom, &length, 
                            &type, &size, &val)) 
    {
        msgout(DEBUG, "get property _NET_CURRENT_DESKTOP failed - setting one\n");
        info->workspace = 0;
    } else {
        info->workspace = (long) * (long *)val;
        XFree(val);
    }

    if (Get_Window_Property(display, root_win, desktop_count_atom,
                            &length, &type, &size, &val)) 
    {
        msgout(DEBUG, "get property _NET_NUMBER_OF_DESKTOPS failed - setting one\n");
        info->workspace_count = 1;
    } else {
        info->workspace_count = (long) * (long *)val;
        XFree(val);
    }

    return;
}

//===========================
// sawfish - w/o gnome
//===========================

// quick and dirty sawfish only workspace management 
// from Thomas Clausen
int VDesktops::sawfish_get_current_workspace(void)
{
    char cmd[500];
    FILE *pipe;
    int current_workspace;

    sprintf (cmd, "sawfish-client -e current-workspace");
    pipe = popen(cmd,"r");
    fscanf(pipe,"%i",&current_workspace);
    fclose(pipe);

    // msgout(DEBUG,"Current workspace: %i\n",current_workspace);
  
    return current_workspace;
}

// quick and dirty sawfish only workspace management 
// from Thomas Clausen
int VDesktops::sawfish_get_workspace_count(void)
{
    char cmd[500];
    FILE *pipe;
    int workspace_count;

    sprintf (cmd, "sawfish-client -e \"(+ 1 (cdr (workspace-limits)) (- (car (workspace-limits))))\"");
    pipe = popen(cmd,"r");
    fscanf(pipe,"%i",&workspace_count);
    fclose(pipe);

    // printf("Workspace count: %i\n",workspace_count);
  
    return workspace_count;
}

// quick and dirty sawfish only workspace management 
// from Thomas Clausen
void VDesktops::sawfish_set_current_workspace(int workspace)
{
    char cmd[500];
    sprintf (cmd, "sawfish-client -c \"(select-workspace %i)\"", workspace);
    system(cmd);
}


/* un-unashamedly ripped from stph.c, thanks Rob :) */
/* unashamedly ripped and adapted from gwmh.c, thanks Tim :) */
int VDesktops::send_client_message_32 (Display *display,
                                       Window recipient,
                                       Window event_window,
                                       Atom message_type,
                                       long event_mask,
                                       int n_longs,
                                       ...)
{
    XEvent xevent = { 0, };
    int i = 0;
    va_list var_args;

    if (n_longs > 5)
        return 1;
  
    va_start (var_args, n_longs);

    xevent.type = ClientMessage;
    xevent.xclient.window = event_window;
    xevent.xclient.message_type = message_type;
    xevent.xclient.format = 32;
    while (n_longs--)
        xevent.xclient.data.l[i++] = va_arg (var_args, long);

    va_end (var_args);

    if (!(XSendEvent (display, recipient, False, event_mask, &xevent)))
        return 1;
    if (error_handler_hit) {
        error_handler_hit = 0;
        return 1;
    }
  
    return 0;
}


#ifndef min
#define min(a,b)  ((a) < (b) ? (a) : (b))
#endif

int 
VDesktops::Get_Window_Property(Display *display,
                               Window target_win, 
                               Atom atom, 
                               long *length, 
                               Atom *type, 
                               int *size,
                               char **data)
{
    Atom actual_type;
    int actual_format;
    unsigned long nitems;
    unsigned long nbytes;
    unsigned long bytes_after;
    unsigned char *prop;
    int status;

    unsigned int max_len = 100;

    /* 
             Display *display;
             Window w;
             Atom property;
             long long_offset, long_length;
             Bool delete;
             Atom req_type;
             Atom *actual_type_return;
             int *actual_format_return;
             unsigned long *nitems_return;
             unsigned long *bytes_after_return;
             unsigned char **prop_return;
    */
    status = XGetWindowProperty(display, 
                                target_win, 
                                atom, 
                                0, 
                                (max_len+3)/4,
                                False, 
                                AnyPropertyType, 
                                &actual_type,
                                &actual_format, 
                                &nitems, 
                                &bytes_after,
                                &prop);

  
    if (error_handler_hit) {
        error_handler_hit = 0;
        return 1;
    }

    if (status != Success) /* some other problem... */
        return 1;

    if (actual_format == 32)
        nbytes = sizeof(long);
    else if (actual_format == 16)
        nbytes = sizeof(short);
    else
        nbytes = 1;
    *length = min(nitems * nbytes, max_len);
    *type = actual_type;
    *size = actual_format;
    *data = (char *)prop;

    if (prop == NULL)
        return 1;

    return 0;
}


static int
ignore_all_errors_ehandler (Display *display, XErrorEvent *error)
{
    error_handler_hit = True;
    msgout (ERROR, "X error\n");
    return 0;
}