Jabber WindowGram Client (JWGC) Introduction Screenshots Installation Downloads Documentation Browse Source Resources Project Site

Stable Version -none- Latest Version beta5

xcut.c

Go to the documentation of this file.

/*
 *      Copyright (c) 1989 by the Massachusetts Institute of Technology.
 *      For copying and distribution information, see the file
 *      "mit-copyright.h".
 *
 *      Modified for jwgc by Daniel Henninger.
 */

#include "mit-copyright.h"

/****************************************************************************/
/* */
/* Code to deal with handling X events:                  */
/* */
/****************************************************************************/

#ifndef X_DISPLAY_MISSING

#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include "new_string.h"
#include "X_gram.h"
#include "main.h"
#include "xselect.h"
#include "xmark.h"
#include "error.h"
#include "xrevstack.h"

/*
 *
 */

extern char *xmarkGetText();

extern long ttl;

static char *selected_text = NULL;
static Window selecting_in = 0;

char *
getSelectedText()
{
        return (selected_text);
}

/*
 *
 */

/* ARGSUSED */
Bool 
isShiftButton1(dpy, event, arg)
        Display *dpy;
        XEvent *event;
        char *arg;
{
        return (event->xbutton.state & (ShiftMask | Button1Mask));
}

/* ARGSUSED */
Bool 
isShiftButton3(dpy, event, arg)
        Display *dpy;
        XEvent *event;
        char *arg;
{
        return (event->xbutton.state & (ShiftMask | Button3Mask));
}

void 
getLastEvent(dpy, state, event)
        Display *dpy;
        unsigned int state;
        XEvent *event;
{
        XEvent xev;

        if (state & Button1Mask) {
                while (XCheckIfEvent(dpy, &xev, isShiftButton1, NULL))
                        *event = xev;
        }
        else if (state & Button3Mask) {
                while (XCheckIfEvent(dpy, &xev, isShiftButton3, NULL))
                        *event = xev;
        }
}

void 
xunmark(dpy, w, gram, desc_context)
        Display *dpy;
        Window w;
        x_gram *gram;
        XContext desc_context;
{
        if (gram == NULL)
                if (XFindContext(dpy, w, desc_context, (caddr_t *) & gram))
                        return;

        xmarkClear();
        xmarkRedraw(dpy, w, gram, XMARK_REDRAW_OLD);
}

/* This is out here so xdestroygram can get at it */

#define PRESSOP_NONE 0          /* nothing */
#define PRESSOP_KILL 1          /* normal click */
#define PRESSOP_SEL  2          /* shift left */
#define PRESSOP_EXT  3          /* shift right */
#define PRESSOP_NUKE 4          /* ctrl */
#define PRESSOP_STOP 5          /* pressop cancelled by moving out of window */

static int current_pressop = PRESSOP_NONE;

void 
xdestroygram(dpy, w, desc_context, gram)
        Display *dpy;
        Window w;
        XContext desc_context;
        x_gram *gram;
{
        struct timeval now;

        gettimeofday(&now, NULL);
        if ((gram->can_die.tv_sec == 0) ||
            (gram->can_die.tv_sec > now.tv_sec) ||
            ((gram->can_die.tv_sec == now.tv_sec) &&
             (gram->can_die.tv_usec > now.tv_usec)))
                return;

        if (w == selecting_in) {
                selecting_in = 0;
                xmarkClear();
        }
        current_pressop = PRESSOP_NONE;
        XDeleteContext(dpy, w, desc_context);
        XDestroyWindow(dpy, w);
        delete_gram(gram);
        free(gram->text);
        free(gram->blocks);
        free(gram);

        if (bottom_gram == NULL && unlinked == NULL) {
                /* flush colormap here */
        }
}

void 
xcut(dpy, event, desc_context)
        Display *dpy;
        XEvent *event;
        XContext desc_context;
{
        x_gram *gram;
        Window w = event->xany.window;
        int changedbound;

        /*
         * If event is for a window that's not ours anymore (say we're
         * in the process of deleting it...), ignore it:
         */
        if (XFindContext(dpy, w, desc_context, (caddr_t *) & gram))
                return;

        /*
         * Dispatch on the event type:
         */
        switch (event->type) {
                case ClientMessage:
                        if ((event->xclient.message_type == XA_WM_PROTOCOLS) &&
                            (event->xclient.format == 32) &&
                          (event->xclient.data.l[0] == XA_WM_DELETE_WINDOW))
                                xdestroygram(dpy, w, desc_context, gram);
                        break;

                case MapNotify:
                        /*
                         * I don't like using the local time, but MapNotify
                         * events don't come with a timestamp, and there's no
                         * way to query the server
                         */

                        if (gram->can_die.tv_sec == 0) {
                                gettimeofday(&(gram->can_die), NULL);
                                gram->can_die.tv_sec += (int) (ttl / 1000);
                                gram->can_die.tv_usec += (ttl % 1000) * 1000;
                        }
                        break;

                case UnmapNotify:
                        unlink_gram(gram);
                        break;

                case LeaveNotify:
                        if (current_pressop == PRESSOP_KILL ||
                            current_pressop == PRESSOP_NUKE)
                                current_pressop = PRESSOP_STOP;
                        break;

                case MotionNotify:
                        if (current_pressop == PRESSOP_SEL) {
                                /* getLastEvent(dpy,Button1Mask,event); */
                                changedbound = xmarkExtendFromFirst(gram, event->xmotion.x,
                                                          event->xmotion.y);
                                xmarkRedraw(dpy, w, gram, changedbound);
                        }
                        else if (current_pressop == PRESSOP_EXT) {
                                /* getLastEvent(dpy,Button3Mask,event); */
                                changedbound = xmarkExtendFromNearest(gram, event->xmotion.x,
                                                          event->xmotion.y);
                                xmarkRedraw(dpy, w, gram, changedbound);
                        }
                        break;

                case ButtonPress:
                        if (current_pressop != PRESSOP_NONE) {
                                current_pressop = PRESSOP_STOP;
                        }
                        else if ((event->xbutton.state) & ShiftMask) {
                                if (event->xbutton.button == Button1) {
                                        if (selecting_in)
                                                xunmark(dpy, selecting_in, NULL, desc_context);
                                        if (selected_text)
                                                free(selected_text);
                                        selected_text = NULL;
                                        if (!xselGetOwnership(dpy, w, event->xbutton.time)) {
                                                XBell(dpy, 0);
                                                ERROR("Unable to get ownership of PRIMARY selection.\n");
                                                selecting_in = 0;
                                                current_pressop = PRESSOP_STOP;
                                        }
                                        else {
                                                selecting_in = w;
                                                xmarkStart(gram, event->xbutton.x, event->xbutton.y);
                                                current_pressop = PRESSOP_SEL;
                                        }
                                }
                                else if ((event->xbutton.button == Button3) &&
                                         (w == selecting_in)) {
                                        if (selected_text)
                                                free(selected_text);
                                        selected_text = NULL;
                                        changedbound = xmarkExtendFromNearest(gram, event->xbutton.x,
                                                          event->xbutton.y);
                                        xmarkRedraw(dpy, w, gram, changedbound);
                                        selected_text = xmarkGetText();
                                        /*
                                         * this is ok, since to get here, the
                                         * selection must be owned
                                         */
                                        current_pressop = PRESSOP_EXT;
                                }
                        }
                        else if ((event->xbutton.state) & ControlMask) {
                                current_pressop = PRESSOP_NUKE;
                        }
                        else {
                                current_pressop = PRESSOP_KILL;
                        }
                        break;

                case ButtonRelease:
                        if (current_pressop == PRESSOP_KILL) {
                                xdestroygram(dpy, w, desc_context, gram);
                        }
                        else if (current_pressop == PRESSOP_SEL ||
                                 current_pressop == PRESSOP_EXT) {
                                if (selected_text)
                                        free(selected_text);
                                selected_text = xmarkGetText();
                        }
                        else if (current_pressop == PRESSOP_NUKE) {
                                XWindowAttributes wa;
                                int gx, gy;
                                Window temp;
                                x_gram *next;

                                for (gram = bottom_gram; gram; gram = next) {
                                        XGetWindowAttributes(dpy, gram->w, &wa);
                                        XTranslateCoordinates(dpy, gram->w, wa.root, 0, 0, &gx, &gy,
                                                              &temp);

                                        next = gram->above;

                                        if ((wa.map_state == IsViewable) &&
                                            (gx <= event->xbutton.x_root) &&
                                            (event->xbutton.x_root < gx + wa.width) &&
                                            (gy <= event->xbutton.y_root) &&
                                            (event->xbutton.y_root < gy + wa.height)) {
                                                xdestroygram(dpy, gram->w, desc_context, gram);
                                        }
                                }
                                for (gram = unlinked; gram; gram = next) {
                                        XGetWindowAttributes(dpy, gram->w, &wa);
                                        XTranslateCoordinates(dpy, gram->w, wa.root, 0, 0, &gx, &gy,
                                                              &temp);

                                        next = gram->above;

                                        if ((wa.map_state == IsViewable) &&
                                            (gx <= event->xbutton.x_root) &&
                                            (event->xbutton.x_root < gx + wa.width) &&
                                            (gy <= event->xbutton.y_root) &&
                                            (event->xbutton.y_root < gy + wa.height)) {
                                                xdestroygram(dpy, gram->w, desc_context, gram);
                                        }
                                }
                        }
                        current_pressop = PRESSOP_NONE;
                        break;

                case SelectionRequest:
                        xselProcessSelection(dpy, w, event);
                        break;

                case SelectionClear:
                        xselOwnershipLost(event->xselectionclear.time);
                        if (w == selecting_in) {
                                selecting_in = 0;
                                xunmark(dpy, w, gram, desc_context);
                                if (selected_text)
                                        free(selected_text);
                                selected_text = NULL;
                        }
                        break;

                default:
                        break;
        }

        XFlush(dpy);
}

#endif

Last updated at Tue Dec 18 21:07:42 PST 2007.

This site and project hosted by...