Logo Search packages:      
Sourcecode: larswm version File versions  Download package

event.c

/* Copyright (c) 1994-1996 David Hogan, see README for licence details */
#include <stdio.h>
#include <stdlib.h>

#include <X11/X.h>
#include <X11/Xos.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xatom.h>
#include <X11/extensions/shape.h>

#include "dat.h"
#include "fns.h"


void
mainloop (int shape_event)
{
  Client *c = 0;
  ScreenInfo *s = 0;
  XEvent ev;

  for (;;)
    {
      XNextEvent (dpy, &ev);

      switch (ev.type)
      {
      case KeyPress:
        keyevent (&ev.xkey);
        break;
      case KeyRelease:
        break;
      case ButtonPress:
        button (&ev.xbutton);
        XAllowEvents (dpy, SyncPointer, ev.xbutton.time);
        break;
      case ButtonRelease:
        break;
      case MapRequest:
        mapreq (&ev.xmaprequest);

        if ((c = getclient (ev.xmaprequest.window, 0)) != 0)
          {
            if (normal (c) && ((s = c->screen) != 0))
            {
              if (c == current)
                {
                  if (c->isnotile)
                  {
                    raise_notile (s);
                  }
                  else
                  {
                    raise_tile (s, 0);
                  }
                }

              if (!c->isnotile || c->istool)
                {
                  tile_all (s);
                }
            }
          }
        break;
      case ConfigureRequest:
        configurereq (&ev.xconfigurerequest);
        break;
      case UnmapNotify:
        unmap (&ev.xunmap);

        if ((c = getclient (ev.xunmap.window, 0)) != 0)
          {
            if ((s = c->screen) != 0)
            {
              if (!c->isnotile || c->istool)
                {
                  tile_all (s);
                }

              if (!current)
                {
                  revert_window (s);
                }
            }
          }
        break;
      case PropertyNotify:
        property (&ev.xproperty);
        break;
      case Expose:
        expose (&ev.xexpose);
        break;
      case CreateNotify:
        newwindow (&ev.xcreatewindow);
        break;
      case DestroyNotify:
        destroy (ev.xdestroywindow.window);
        break;
      case ClientMessage:
        clientmesg (&ev.xclient);
        break;
      case ColormapNotify:
        cmap (&ev.xcolormap);
        break;
      case ReparentNotify:
        reparent (&ev.xreparent);
        break;
      case SelectionNotify:
        break;
      case EnterNotify:
        enter (&ev.xcrossing);
        break;
      case FocusIn:
        focusin (&ev.xfocus);
        break;
      default:
        if (shape && ev.type == shape_event)
          {
            shapenotify ((XShapeEvent *) & ev);
          }
        break;
      }
    }
}

void
expose (XExposeEvent * e)
{
  Client *c;
  ScreenInfo *s;

  if ((c = getclient (e->window, 0)))
    draw_border (c, c == current ? 1 : 0);
  else if ((s = getbarscreen (e->window)))
    draw_tbar (s);
}

void
configurereq (XConfigureRequestEvent * e)
{
  XWindowChanges wc;
  Client *c;

  c = getclient (e->window, 0);
  e->value_mask &= ~CWSibling;

  if (c)
    {
      gravitate (c, 1);

      if (e->value_mask & CWX)
      c->x = e->x;

      if (e->value_mask & CWY)
      c->y = e->y;

      if (e->value_mask & CWWidth)
      c->dx = e->width;

      if (e->value_mask & CWHeight)
      c->dy = e->height;

      if (e->value_mask & CWBorderWidth)
      c->border = e->border_width;

      gravitate (c, 0);

      if (e->value_mask & CWStackMode)
      {
        if (wc.stack_mode == Above)
          top (c);
        else
          e->value_mask &= ~CWStackMode;
      }

      if (c->parent != c->screen->root && c->window == e->window)
      {
        wc.x = c->x - BORDER;
        wc.y = c->y - BORDER;
        wc.width = c->dx + 2 * BORDER;
        wc.height = c->dy + 2 * BORDER;
        wc.border_width = 1;
        wc.sibling = None;
        wc.stack_mode = e->detail;
        XConfigureWindow (dpy, c->parent, e->value_mask, &wc);
        sendconfig (c);
      }
    }

  if (c && c->init)
    {
      wc.x = BORDER;
      wc.y = BORDER;
    }
  else
    {
      wc.x = e->x;
      wc.y = e->y;
    }

  wc.width = e->width;
  wc.height = e->height;
  wc.border_width = 0;
  wc.sibling = None;
  wc.stack_mode = Above;
  e->value_mask &= ~CWStackMode;
  e->value_mask |= CWBorderWidth;

  XConfigureWindow (dpy, e->window, e->value_mask, &wc);
}

void
mapreq (XMapRequestEvent * e)
{
  Client *c;

  c = getclient (e->window, 0);

  if (c == 0 || c->window != e->window)
    {
      return;
    }

  switch (c->state)
    {
    case WithdrawnState:
      if (c->parent == c->screen->root)
      {
        if (!manage (c, 0))
          return;
        break;
      }
      XReparentWindow (dpy, c->window, c->parent, BORDER, BORDER);
      XAddToSaveSet (dpy, c->window);
      /* fall through... */

    case NormalState:
      if (c->trans != None)
      {
        Client *p = getclient (c->trans, 0);

        if (p)
          {
            c->desktop = p->desktop;
          }
      }

      raise_tbar (c->screen);
      XMapWindow (dpy, c->window);
      XMapRaised (dpy, c->parent);
      top (c);
      wmsetstate (c, NormalState);

      if ((mouse_on_screen () == c->screen)
        || (current && (current->screen == c->screen)))
      {
        active (c);
      }
      break;

    case IconicState:
      unhidec (c, 1);
      break;
    }
}

void
unmap (XUnmapEvent * e)
{
  Client *c;

  c = getclient (e->window, 0);

  if (c)
    {
      switch (c->state)
      {
      case IconicState:
        if (e->send_event)
          {
            unhidec (c, 0);
            withdraw (c);
          }
        break;

      case NormalState:
        if (c == current)
          current = 0;

        if (!c->reparenting)
          withdraw (c);
        break;
      }

      c->reparenting = 0;
    }
}

void
newwindow (XCreateWindowEvent * e)
{
  Client *c;
  ScreenInfo *s;

  if (e->override_redirect)
    return;
  c = getclient (e->window, 1);

  /* Crashing bug patch by MG has been applied here. */
  if (c && c->window == e->window)
    {
      c->x = e->x;
      c->y = e->y;
      c->dx = e->width;
      c->dy = e->height;
      c->border = e->border_width;

      if (0 != (s = getscreen (e->parent)))
      c->screen = s;
      else
      c->screen = &screens[0];

      if (c->parent == None)
      c->parent = c->screen->root;
    }
}

void
destroy (Window w)
{
  Client *c;

  if (!(c = getclient (w, 0)))
    return;

  rmclient (c);

  ignore_badwindow = 1;
  XSync (dpy, False);
  ignore_badwindow = 0;
}

void
clientmesg (XClientMessageEvent * e)
{
  Client *c;

  if (e->message_type == exit_larswm)
    {
      cleanup ();
      exit (0);
    }
  else if (e->message_type == restart_larswm)
    {
      cleanup ();
      execvp (myargv[0], myargv);
      perror ("larswm: exec failed");
      exit (1);
    }
  else if (e->message_type == wm_change_state)
    {
      c = getclient (e->window, 0);

      if (e->format == 32 && e->data.l[0] == IconicState && c != 0)
      {
        if (normal (c))
          hide (c);
      }
    }
}

void
cmap (XColormapEvent * e)
{
  Client *c;
  int i;

  if (e->new)
    {
      c = getclient (e->window, 0);
      if (c)
      {
        c->cmap = e->colormap;
        if (c == current)
          cmapfocus (c);
      }
      else
      for (c = clients; c; c = c->next)
        {
          for (i = 0; i < c->ncmapwins; i++)
            if (c->cmapwins[i] == e->window)
            {
              c->wmcmaps[i] = e->colormap;
              if (c == current)
                cmapfocus (c);
              return;
            }
        }
    }
}

void
property (XPropertyEvent * e)
{
  Client *c;
  long msize;

  /* check if text to be displayed on status bar was just changed */
  if ((e->atom == bartext_larswm) && (e->window == DefaultRootWindow (dpy)))
    {
      update_cmd_output ();
      return;
    }

  if (!(c = getclient (e->window, 0)))
    return;

  switch (e->atom)
    {
    case XA_WM_ICON_NAME:
      if (c->iconname != 0)
      XFree ((char *) c->iconname);
      c->iconname =
      (e->state == PropertyDelete) ? 0 : getprop (c->window, e->atom);
      setlabel (c);
      renamec (c, c->label);
      break;

    case XA_WM_NAME:
      if (c->name != 0)
      XFree ((char *) c->name);
      c->name =
      (e->state == PropertyDelete) ? 0 : getprop (c->window, e->atom);
      setlabel (c);
      renamec (c, c->label);
      break;

    case XA_WM_TRANSIENT_FOR:
      gettrans (c);
      break;

    case XA_WM_NORMAL_HINTS:
      if (XGetWMNormalHints (dpy, c->window, &c->size, &msize) == 0
        || c->size.flags == 0)
      {
        c->size.flags = PSize;
      }

      if (c->size.flags & PBaseSize)
      {
        c->min_dx = c->size.base_width;
        c->min_dy = c->size.base_height;
      }
      else if (c->size.flags & PMinSize)
      {
        c->min_dx = c->size.min_width;
        c->min_dy = c->size.min_height;
      }
      else
      {
        c->min_dx = c->min_dy = 1;
      }
      break;

    default:
      if (e->atom == wm_colormaps)
      {
        getcmaps (c);

        if (c == current)
          {
            cmapfocus (c);
          }
      }
      break;
    }
}

void
reparent (XReparentEvent * e)
{
  Client *c;
  XWindowAttributes attr;
  ScreenInfo *s;

  if (!getscreen (e->event) || e->override_redirect)
    return;
  if ((s = getscreen (e->parent)) != 0)
    {
      c = getclient (e->window, 1);
      if (c != 0 && (c->dx == 0 || c->dy == 0))
      {
        XGetWindowAttributes (dpy, c->window, &attr);
        c->x = attr.x;
        c->y = attr.y;
        c->dx = attr.width;
        c->dy = attr.height;
        c->border = attr.border_width;
        c->screen = s;
        if (c->parent == None)
          c->parent = c->screen->root;
      }
    }
  else
    {
      c = getclient (e->window, 0);
      if (c != 0 && (c->parent == c->screen->root || withdrawn (c)))
      rmclient (c);
    }
}

void
shapenotify (XShapeEvent * e)
{
  Client *c;

  c = getclient (e->window, 0);
  if (c == 0)
    return;

  setshape (c);
}

void
enter (XCrossingEvent * e)
{
  Client *c;

  if (e->mode != NotifyGrab || e->detail != NotifyNonlinearVirtual)
    return;

  c = getclient (e->window, 0);

  if (c && c->parent && (c != current))
    {
      XMapRaised (dpy, c->parent);
      active (c);
    }
  else
    {
      XSetInputFocus (dpy, e->window, RevertToPointerRoot, e->time);
    }
}

void
focusin (XFocusChangeEvent * e)
{
  Client *c;

  if (e->detail != NotifyNonlinearVirtual)
    return;

  c = getclient (e->window, 0);

  if (c && c->window && c->parent && (c->window == e->window)
      && (c != current))
    {
      XMapRaised (dpy, c->parent);
      active (c);
    }
  else
    {
      XSetInputFocus (dpy, e->window, RevertToPointerRoot, CurrentTime);
    }
}

Generated by  Doxygen 1.6.0   Back to index