mirror of
https://github.com/0intro/wmii
synced 2024-12-05 03:33:07 +03:00
820 lines
22 KiB
C
820 lines
22 KiB
C
/*
|
|
* (C)opyright MMIV-MMVI Anselm R. Garbe <garbeam at gmail dot com>
|
|
* See LICENSE file for license details.
|
|
*/
|
|
|
|
#include <fcntl.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/wait.h>
|
|
#include <X11/cursorfont.h>
|
|
#include <X11/Xproto.h>
|
|
#include <X11/keysym.h>
|
|
#include <X11/Xatom.h>
|
|
#include <X11/Xproto.h>
|
|
|
|
#include "wm.h"
|
|
|
|
static XRectangle initial_rect;
|
|
static int other_wm_running;
|
|
static int (*x_error_handler) (Display *, XErrorEvent *);
|
|
|
|
static void new_page(void *obj, char *arg);
|
|
static void xselect_page(void *obj, char *arg);
|
|
static void xdestroy_page(void *obj, char *arg);
|
|
static void quit(void *obj, char *arg);
|
|
static void xattach_client(void *obj, char *arg);
|
|
static void xdetach_client(void *obj, char *arg);
|
|
static void xclose_client(void *obj, char *arg);
|
|
static void pager(void *obj, char *arg);
|
|
static void detached_client(void *obj, char *arg);
|
|
|
|
/* action table for /ctl namespace */
|
|
Action wm_acttbl[] = {
|
|
{"new", new_page},
|
|
{"destroy", xdestroy_page},
|
|
{"select", xselect_page},
|
|
{"attach", xattach_client},
|
|
{"detach", xdetach_client},
|
|
{"close", xclose_client},
|
|
{"quit", quit},
|
|
{"pager", pager},
|
|
{"detclient", detached_client},
|
|
{0, 0}
|
|
};
|
|
|
|
char *version[] = {
|
|
"wmiiwm - window manager improved 2 - " VERSION "\n"
|
|
" (C)opyright MMIV-MMVI Anselm R. Garbe\n", 0
|
|
};
|
|
|
|
static void
|
|
usage()
|
|
{
|
|
fprintf(stderr, "%s",
|
|
"usage: wmiiwm -s <socket file> [-c] [-v]\n"
|
|
" -s socket file\n"
|
|
" -c checks if another WM is already running\n"
|
|
" -v version info\n");
|
|
exit(1);
|
|
}
|
|
|
|
void
|
|
run_action(File * f, void *obj, Action * acttbl)
|
|
{
|
|
int i;
|
|
size_t len;
|
|
|
|
if(!f->content)
|
|
return;
|
|
for(i = 0; acttbl[i].name; i++) {
|
|
len = strlen(acttbl[i].name);
|
|
if(!strncmp(acttbl[i].name, (char *) f->content, len)) {
|
|
if(f->size > len)
|
|
acttbl[i].func(obj, &((char *) f->content)[len + 1]);
|
|
else
|
|
acttbl[i].func(obj, 0);
|
|
return;
|
|
break;
|
|
}
|
|
}
|
|
fprintf(stderr, "wmiiwm: unknown action '%s'\n"
|
|
" or invalid ctl device\n", (char *) f->content);
|
|
}
|
|
|
|
static void
|
|
quit(void *obj, char *arg)
|
|
{
|
|
ixps->runlevel = SHUTDOWN;
|
|
}
|
|
|
|
void
|
|
invoke_wm_event(File * f)
|
|
{
|
|
if(!f->content)
|
|
return;
|
|
wmii_spawn(dpy, f->content);
|
|
}
|
|
|
|
static void
|
|
scale_rect(XRectangle * from_dim, XRectangle * to_dim,
|
|
XRectangle * src, XRectangle * tgt)
|
|
{
|
|
double wfact = (double) to_dim->width / (double) from_dim->width;
|
|
double hfact = (double) to_dim->height / (double) from_dim->height;
|
|
|
|
tgt->x = to_dim->x + (src->x * wfact);
|
|
tgt->y = to_dim->y + (src->y * hfact);
|
|
tgt->width = (src->width * wfact);
|
|
tgt->height = (src->height * hfact);
|
|
|
|
if(tgt->width < 1)
|
|
tgt->width = 1;
|
|
if(tgt->height < 1)
|
|
tgt->height = 1;
|
|
}
|
|
|
|
static void
|
|
draw_pager_client(Client *c, Draw *d)
|
|
{
|
|
if(c == sel_client()) {
|
|
d->bg = blitz_loadcolor(dpy, screen, def[WM_SEL_BG_COLOR]->content);
|
|
d->fg = blitz_loadcolor(dpy, screen, def[WM_SEL_FG_COLOR]->content);
|
|
d->border = blitz_loadcolor(dpy, screen, def[WM_SEL_BORDER_COLOR]->content);
|
|
} else {
|
|
d->bg = blitz_loadcolor(dpy, screen, def[WM_NORM_BG_COLOR]->content);
|
|
d->fg = blitz_loadcolor(dpy, screen, def[WM_NORM_FG_COLOR]->content);
|
|
d->border = blitz_loadcolor(dpy, screen, def[WM_NORM_BORDER_COLOR]->content);
|
|
}
|
|
d->data = c->name;
|
|
scale_rect(&rect, &initial_rect, &c->frame.rect, &d->rect);
|
|
blitz_drawlabel(dpy, d);
|
|
XSync(dpy, False); /* do not clear upwards */
|
|
}
|
|
|
|
static void
|
|
draw_pager_page(size_t idx, Draw *d)
|
|
{
|
|
size_t i, j;
|
|
char name[4];
|
|
initial_rect = d->rect;
|
|
|
|
if(idx == sel_page) {
|
|
d->bg = blitz_loadcolor(dpy, screen, def[WM_SEL_BG_COLOR]->content);
|
|
d->fg = blitz_loadcolor(dpy, screen, def[WM_SEL_FG_COLOR]->content);
|
|
d->border = blitz_loadcolor(dpy, screen, def[WM_SEL_BORDER_COLOR]->content);
|
|
} else {
|
|
d->bg = blitz_loadcolor(dpy, screen, def[WM_NORM_BG_COLOR]->content);
|
|
d->fg = blitz_loadcolor(dpy, screen, def[WM_NORM_FG_COLOR]->content);
|
|
d->border = blitz_loadcolor(dpy, screen, def[WM_NORM_BORDER_COLOR]->content);
|
|
}
|
|
snprintf(name, sizeof(name), "%d", idx + 1);
|
|
d->data = name;
|
|
blitz_drawlabel(dpy, d);
|
|
XSync(dpy, False);
|
|
|
|
for(i = 0; (i < page[idx]->columnsz) && page[idx]->column[i]; i++) {
|
|
Column *col = page[idx]->column[i];
|
|
for(j = 0; (i < col->clientsz) && col->client[j]; j++)
|
|
draw_pager_client(col->client[j], d);
|
|
}
|
|
for(i = 0; (i < page[idx]->floatingsz) && page[idx]->floating[i]; i++)
|
|
draw_pager_client(page[idx]->floating[i], d);
|
|
}
|
|
|
|
static void
|
|
draw_pager()
|
|
{
|
|
Draw d = { 0 };
|
|
unsigned int i, ic, ir, tw, th, rows, cols;
|
|
int dx;
|
|
|
|
for(i = 0; (i < pagesz) && page[i]; i++);
|
|
blitz_getbasegeometry(i, &cols, &rows);
|
|
dx = (cols - 1) * GAP; /* GAPpx space */
|
|
tw = (rect.width - dx) / cols;
|
|
th = ((double) tw / rect.width) * rect.height;
|
|
d.drawable = transient;
|
|
d.gc = gc_transient;
|
|
d.font = font;
|
|
i = 0;
|
|
for(ir = 0; ir < rows; ir++) {
|
|
for(ic = 0; ic < cols; ic++) {
|
|
d.rect.x = ic * tw + (ic * GAP);
|
|
d.rect.width = tw;
|
|
if(rows == 1)
|
|
d.rect.y = 0;
|
|
else
|
|
d.rect.y = ir * (rect.height - th) / (rows - 1);
|
|
d.rect.height = th;
|
|
draw_pager_page(i++, &d);
|
|
if(!page[i])
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
static int
|
|
xy_to_pager_page(int x, int y)
|
|
{
|
|
unsigned int i, ic, ir, tw, th, rows, cols;
|
|
int dx;
|
|
XRectangle r;
|
|
|
|
for(i = 0; (i < pagesz) && page[i]; i++);
|
|
blitz_getbasegeometry(i, &cols, &rows);
|
|
dx = (cols - 1) * GAP; /* GAPpx space */
|
|
tw = (rect.width - dx) / cols;
|
|
th = ((double) tw / rect.width) * rect.height;
|
|
|
|
i = 0;
|
|
for(ir = 0; ir < rows; ir++) {
|
|
for(ic = 0; ic < cols; ic++) {
|
|
r.x = ic * tw + (ic * GAP);
|
|
r.width = tw;
|
|
if(rows == 1)
|
|
r.y = 0;
|
|
else
|
|
r.y = ir * (rect.height - th) / (rows - 1);
|
|
r.height = th;
|
|
if(blitz_ispointinrect(x, y, &r))
|
|
return i;
|
|
i++;
|
|
if(!page[i])
|
|
return -1;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
static int
|
|
handle_kpress(XKeyEvent * e)
|
|
{
|
|
KeySym ksym = XKeycodeToKeysym(dpy, e->keycode, 0);
|
|
|
|
if(ksym >= XK_1 && ksym <= XK_9)
|
|
return ksym - XK_1;
|
|
else if(ksym == XK_0)
|
|
return 9;
|
|
else if(ksym >= XK_a && ksym <= XK_z)
|
|
return 10 + ksym - XK_a;
|
|
|
|
return -1;
|
|
}
|
|
|
|
static void
|
|
pager(void *obj, char *arg)
|
|
{
|
|
XEvent ev;
|
|
int i;
|
|
size_t j;
|
|
|
|
if(!page)
|
|
return;
|
|
|
|
for(j = 0; (j < pagesz) && page[j]; j++);
|
|
|
|
XClearWindow(dpy, transient);
|
|
XMapRaised(dpy, transient);
|
|
draw_pager();
|
|
|
|
while(XGrabKeyboard
|
|
(dpy, transient, True, GrabModeAsync, GrabModeAsync,
|
|
CurrentTime) != GrabSuccess)
|
|
usleep(20000);
|
|
|
|
while(XGrabPointer
|
|
(dpy, transient, False, ButtonPressMask, GrabModeAsync,
|
|
GrabModeAsync, None, normal_cursor, CurrentTime) != GrabSuccess)
|
|
usleep(20000);
|
|
|
|
for(;;) {
|
|
while(!XCheckWindowEvent
|
|
(dpy, transient, ButtonPressMask | KeyPressMask, &ev)) {
|
|
usleep(20000);
|
|
continue;
|
|
}
|
|
|
|
switch (ev.type) {
|
|
case KeyPress:
|
|
XUnmapWindow(dpy, transient);
|
|
if((i = handle_kpress(&ev.xkey)) != -1)
|
|
if(i < j)
|
|
focus_page(page[i]);
|
|
XUngrabKeyboard(dpy, CurrentTime);
|
|
XUngrabPointer(dpy, CurrentTime /* ev.xbutton.time */ );
|
|
return;
|
|
break;
|
|
case ButtonPress:
|
|
XUnmapWindow(dpy, transient);
|
|
if(ev.xbutton.button == Button1)
|
|
focus_page(page[xy_to_pager_page(ev.xbutton.x, ev.xbutton.y)]);
|
|
XUngrabKeyboard(dpy, CurrentTime);
|
|
XUngrabPointer(dpy, CurrentTime /* ev.xbutton.time */ );
|
|
return;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
map_detached_client()
|
|
{
|
|
unsigned int i, ic, ir, tw, th, rows, cols;
|
|
int dx, dy;
|
|
XRectangle cr;
|
|
|
|
for(i = 0; detached && detached[i]; i++);
|
|
blitz_getbasegeometry(i, &cols, &rows);
|
|
if(!cols)
|
|
cols = 1;
|
|
if(!rows)
|
|
rows = 1;
|
|
dx = (cols - 1) * GAP; /* GAPpx space */
|
|
dy = (rows - 1) * GAP; /* GAPpx space */
|
|
tw = (rect.width - dx) / cols;
|
|
th = (rect.height - dy) / rows;
|
|
|
|
i = 0;
|
|
for(ir = 0; ir < rows; ir++) {
|
|
for(ic = 0; ic < cols; ic++) {
|
|
if(!detached[i++])
|
|
return;
|
|
cr.x = ic * tw + (ic * GAP);
|
|
cr.y = ir * th + (ir * GAP);
|
|
cr.width = tw;
|
|
cr.height = th;
|
|
XMoveResizeWindow(dpy, detached[i]->win, cr.x, cr.y, cr.width, cr.height);
|
|
configure_client(detached[i]);
|
|
map_client(detached[i]);
|
|
grab_client(detached[i], AnyModifier, Button1);
|
|
XRaiseWindow(dpy, detached[i]->win);
|
|
XSync(dpy, False);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
detached_client(void *obj, char *arg)
|
|
{
|
|
XEvent ev;
|
|
int n;
|
|
size_t i, nc;
|
|
Client *c;
|
|
|
|
for(nc = 0; detached && detached[nc]; nc++);
|
|
if(!nc)
|
|
return;
|
|
XClearWindow(dpy, transient);
|
|
XMapRaised(dpy, transient);
|
|
map_detached_client();
|
|
while(XGrabKeyboard
|
|
(dpy, transient, True, GrabModeAsync, GrabModeAsync,
|
|
CurrentTime) != GrabSuccess)
|
|
usleep(20000);
|
|
|
|
for(;;) {
|
|
while(!XCheckMaskEvent(dpy, ButtonPressMask | KeyPressMask, &ev)) {
|
|
usleep(20000);
|
|
continue;
|
|
}
|
|
switch (ev.type) {
|
|
case KeyPress:
|
|
XUnmapWindow(dpy, transient);
|
|
for(i = 0; detached[i]; i++)
|
|
unmap_client(detached[i]);
|
|
if((n = handle_kpress(&ev.xkey)) != -1) {
|
|
if(n < nc) {
|
|
c = detached[n];
|
|
detach_client_from_array(c, detached);
|
|
attach_client(c);
|
|
}
|
|
}
|
|
XUngrabKeyboard(dpy, CurrentTime);
|
|
return;
|
|
break;
|
|
case ButtonPress:
|
|
XUnmapWindow(dpy, transient);
|
|
for(i = 0; detached[i]; i++)
|
|
unmap_client(detached[i]);
|
|
if((ev.xbutton.button == Button1)
|
|
&& (c = win_to_client(ev.xbutton.window))) {
|
|
detach_client_from_array(c, detached);
|
|
attach_client(c);
|
|
}
|
|
XUngrabKeyboard(dpy, CurrentTime);
|
|
return;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
xclose_client(void *obj, char *arg)
|
|
{
|
|
Client *c = sel_client();
|
|
if(c)
|
|
close_client(c);
|
|
}
|
|
|
|
static void
|
|
xattach_client(void *obj, char *arg)
|
|
{
|
|
Client *c = detached ? detached[0] : nil;
|
|
if(c) {
|
|
detach_client_from_array(c, detached);
|
|
attach_client(c);
|
|
}
|
|
}
|
|
|
|
static void
|
|
xdetach_client(void *obj, char *arg)
|
|
{
|
|
Client *c = sel_client();
|
|
if(c)
|
|
detach_client(c, False);
|
|
}
|
|
|
|
static void
|
|
xselect_page(void *obj, char *arg)
|
|
{
|
|
size_t np, new = sel_page;
|
|
|
|
for(np = 0; (np < pagesz) && page[np]; np++);
|
|
if(!np || !arg)
|
|
return;
|
|
if(!strncmp(arg, "prev", 5)) {
|
|
if(new > 0)
|
|
for(new = 0; page[new]; new++);
|
|
new--;
|
|
} else if(!strncmp(arg, "next", 5)) {
|
|
if(page[new + 1])
|
|
new++;
|
|
else
|
|
new = 0;
|
|
} else {
|
|
int idx = blitz_strtonum(arg, 0, np);
|
|
if(idx < np)
|
|
new = idx;
|
|
}
|
|
focus_page(page[new]);
|
|
}
|
|
|
|
static void
|
|
xdestroy_page(void *obj, char *arg)
|
|
{
|
|
destroy_page(page[sel_page]);
|
|
}
|
|
|
|
static void
|
|
new_page(void *obj, char *arg)
|
|
{
|
|
alloc_page();
|
|
}
|
|
|
|
Client *
|
|
win_to_client(Window w)
|
|
{
|
|
size_t i;
|
|
|
|
for(i = 0; (i < clientsz) && client[i]; i++)
|
|
if(client[i]->win == w)
|
|
return client[i];
|
|
return nil;
|
|
}
|
|
|
|
void
|
|
scan_wins()
|
|
{
|
|
int i;
|
|
unsigned int num;
|
|
Window *wins;
|
|
XWindowAttributes wa;
|
|
Window d1, d2;
|
|
Client *c;
|
|
|
|
if(XQueryTree(dpy, root, &d1, &d2, &wins, &num)) {
|
|
for(i = 0; i < num; i++) {
|
|
if(!XGetWindowAttributes(dpy, wins[i], &wa))
|
|
continue;
|
|
if(wa.override_redirect
|
|
|| XGetTransientForHint(dpy, wins[i], &d1))
|
|
continue;
|
|
if(wa.map_state == IsViewable) {
|
|
c = alloc_client(wins[i], &wa);
|
|
attach_client(c);
|
|
c->ignore_unmap++; /* was viewable already */
|
|
}
|
|
}
|
|
}
|
|
if(wins)
|
|
XFree(wins);
|
|
}
|
|
|
|
void *
|
|
get_func(void *acttbl[][2], int rows, char *fname)
|
|
{
|
|
int i;
|
|
for(i = 0; i < rows; i++) {
|
|
if(!strncmp((char *) acttbl[i][0], fname, MAX_BUF)) {
|
|
return acttbl[i][1];
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
win_proto(Window w)
|
|
{
|
|
Atom *protocols;
|
|
long res;
|
|
int protos = 0;
|
|
int i;
|
|
|
|
res =
|
|
wmii_property(dpy, w, wm_protocols, XA_ATOM, 20L,
|
|
((unsigned char **) &protocols));
|
|
if(res <= 0) {
|
|
return protos;
|
|
}
|
|
for(i = 0; i < res; i++) {
|
|
if(protocols[i] == wm_delete) {
|
|
protos |= PROTO_DEL;
|
|
}
|
|
}
|
|
free((char *) protocols);
|
|
return protos;
|
|
}
|
|
|
|
int
|
|
win_state(Window w)
|
|
{
|
|
/* state hints */
|
|
XWMHints *hints = XGetWMHints(dpy, w);
|
|
int res;
|
|
|
|
long *prop = 0;
|
|
if(wmii_property
|
|
(dpy, w, wm_state, wm_state, 2L, ((unsigned char **) &prop)) > 0) {
|
|
res = (int) *prop;
|
|
free((long *) prop);
|
|
} else {
|
|
res = hints ? hints->initial_state : NormalState;
|
|
}
|
|
|
|
if(hints) {
|
|
free(hints);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
void
|
|
handle_after_write(IXPServer * s, File * f)
|
|
{
|
|
if(f == def[WM_CTL])
|
|
run_action(f, 0, wm_acttbl);
|
|
else if(f == def[WM_TRANS_COLOR]) {
|
|
unsigned long col[1];
|
|
col[0] = color_xor.pixel;
|
|
XFreeColors(dpy, DefaultColormap(dpy, screen), col, 1, 0);
|
|
XAllocNamedColor(dpy, DefaultColormap(dpy, screen),
|
|
def[WM_TRANS_COLOR]->content,
|
|
&color_xor, &color_xor);
|
|
XSetForeground(dpy, gc_xor, color_xor.pixel);
|
|
} else if(f == def[WM_FONT]) {
|
|
XFreeFont(dpy, font);
|
|
font = blitz_getfont(dpy, def[WM_FONT]->content);
|
|
}
|
|
check_event(0);
|
|
}
|
|
|
|
static void
|
|
init_atoms()
|
|
{
|
|
wm_state = XInternAtom(dpy, "WM_STATE", False);
|
|
wm_change_state = XInternAtom(dpy, "WM_CHANGE_STATE", False);
|
|
wm_protocols = XInternAtom(dpy, "WM_PROTOCOLS", False);
|
|
wm_delete = XInternAtom(dpy, "WM_DELETE_WINDOW", False);
|
|
motif_wm_hints = XInternAtom(dpy, "_MOTIF_WM_HINTS", False);
|
|
net_atoms[NET_NUMBER_OF_DESKTOPS] = XInternAtom(dpy, "_NET_NUMBER_OF_DESKTOPS", False);
|
|
net_atoms[NET_CURRENT_DESKTOP] = XInternAtom(dpy, "_NET_CURRENT_DESKTOP", False);
|
|
net_atoms[NET_WM_DESKTOP] = XInternAtom(dpy, "_NET_WM_DESKTOP", False);
|
|
XChangeProperty(dpy, root, XInternAtom(dpy, "_NET_SUPPORTED", False), XA_ATOM, 32, PropModeReplace, (unsigned char *) net_atoms, NET_ATOM_COUNT);
|
|
}
|
|
|
|
static void
|
|
init_cursors()
|
|
{
|
|
normal_cursor = XCreateFontCursor(dpy, XC_left_ptr);
|
|
resize_cursor = XCreateFontCursor(dpy, XC_sizing);
|
|
move_cursor = XCreateFontCursor(dpy, XC_fleur);
|
|
drag_cursor = XCreateFontCursor(dpy, XC_cross);
|
|
w_cursor = XCreateFontCursor(dpy, XC_left_side);
|
|
e_cursor = XCreateFontCursor(dpy, XC_right_side);
|
|
n_cursor = XCreateFontCursor(dpy, XC_top_side);
|
|
s_cursor = XCreateFontCursor(dpy, XC_bottom_side);
|
|
nw_cursor = XCreateFontCursor(dpy, XC_top_left_corner);
|
|
ne_cursor = XCreateFontCursor(dpy, XC_top_right_corner);
|
|
sw_cursor = XCreateFontCursor(dpy, XC_bottom_left_corner);
|
|
se_cursor = XCreateFontCursor(dpy, XC_bottom_right_corner);
|
|
}
|
|
|
|
static void
|
|
init_default()
|
|
{
|
|
def[WM_TRANS_COLOR] =
|
|
wmii_create_ixpfile(ixps, "/default/transcolor",
|
|
BLITZ_SEL_FG_COLOR);
|
|
def[WM_TRANS_COLOR]->after_write = handle_after_write;
|
|
def[WM_COLUMN_GEOMETRY] = wmii_create_ixpfile(ixps, "/default/geometry", BLITZ_SEL_FG_COLOR);
|
|
def[WM_SEL_BG_COLOR] =
|
|
wmii_create_ixpfile(ixps, "/default/sstyle/bgcolor",
|
|
BLITZ_SEL_BG_COLOR);
|
|
def[WM_SEL_FG_COLOR] =
|
|
wmii_create_ixpfile(ixps, "/default/sstyle/fgcolor",
|
|
BLITZ_SEL_FG_COLOR);
|
|
def[WM_SEL_BORDER_COLOR] =
|
|
wmii_create_ixpfile(ixps, "/default/sstyle/bordercolor",
|
|
BLITZ_SEL_BORDER_COLOR);
|
|
def[WM_NORM_BG_COLOR] =
|
|
wmii_create_ixpfile(ixps, "/default/nstyle/bgcolor",
|
|
BLITZ_NORM_BG_COLOR);
|
|
def[WM_NORM_FG_COLOR] =
|
|
wmii_create_ixpfile(ixps, "/default/nstyle/fgcolor",
|
|
BLITZ_NORM_FG_COLOR);
|
|
def[WM_NORM_BORDER_COLOR] = wmii_create_ixpfile(ixps, "/default/nstyle/bordercolor",
|
|
BLITZ_NORM_BORDER_COLOR);
|
|
def[WM_FONT] = wmii_create_ixpfile(ixps, "/default/font", BLITZ_FONT);
|
|
def[WM_FONT]->after_write = handle_after_write;
|
|
def[WM_SNAP_VALUE] = wmii_create_ixpfile(ixps, "/default/snapvalue", "20"); /* 0..1000 */
|
|
def[WM_BORDER] = wmii_create_ixpfile(ixps, "/default/border", "1");
|
|
def[WM_TAB] = wmii_create_ixpfile(ixps, "/default/tab", "1");
|
|
def[WM_HANDLE_INC] = wmii_create_ixpfile(ixps, "/default/handleinc", "1");
|
|
def[WM_SEL_PAGE] = ixp_create(ixps, "/sel");
|
|
def[WM_EVENT_PAGE_UPDATE] = ixp_create(ixps, "/event/pageupdate");
|
|
def[WM_EVENT_CLIENT_UPDATE] = ixp_create(ixps, "/event/clientupdate");
|
|
def[WM_EVENT_B1PRESS] = ixp_create(ixps, "/default/event/b1press");
|
|
def[WM_EVENT_B2PRESS] = ixp_create(ixps, "/default/event/b2press");
|
|
def[WM_EVENT_B3PRESS] = ixp_create(ixps, "/default/event/b3press");
|
|
def[WM_EVENT_B4PRESS] = ixp_create(ixps, "/default/event/b4press");
|
|
def[WM_EVENT_B5PRESS] = ixp_create(ixps, "/default/event/b5press");
|
|
def[WM_DETACHED_PREFIX] = ixp_create(ixps, "/detached");
|
|
}
|
|
|
|
static void
|
|
init_screen()
|
|
{
|
|
XGCValues gcv;
|
|
XSetWindowAttributes wa;
|
|
|
|
XAllocNamedColor(dpy, DefaultColormap(dpy, screen),
|
|
def[WM_TRANS_COLOR]->content, &color_xor, &color_xor);
|
|
gcv.subwindow_mode = IncludeInferiors;
|
|
gcv.function = GXxor;
|
|
gcv.foreground = color_xor.pixel;
|
|
gcv.line_width = 4;
|
|
gcv.plane_mask = AllPlanes;
|
|
gcv.graphics_exposures = False;
|
|
gc_xor = XCreateGC(dpy, root, GCForeground | GCGraphicsExposures
|
|
| GCFunction | GCSubwindowMode | GCLineWidth
|
|
| GCPlaneMask, &gcv);
|
|
rect.x = rect.y = 0;
|
|
rect.width = DisplayWidth(dpy, screen);
|
|
rect.height = DisplayHeight(dpy, screen);
|
|
|
|
wa.override_redirect = 1;
|
|
wa.background_pixmap = ParentRelative;
|
|
wa.event_mask = ExposureMask | ButtonPressMask;
|
|
transient =
|
|
XCreateWindow(dpy, root, 0, 0, rect.width, rect.height, 0,
|
|
DefaultDepth(dpy, screen), CopyFromParent,
|
|
DefaultVisual(dpy, screen),
|
|
CWOverrideRedirect | CWBackPixmap | CWEventMask,
|
|
&wa);
|
|
|
|
XSync(dpy, False);
|
|
gc_transient = XCreateGC(dpy, transient, 0, 0);
|
|
XDefineCursor(dpy, transient, normal_cursor);
|
|
XDefineCursor(dpy, root, normal_cursor);
|
|
}
|
|
|
|
/*
|
|
* There's no way to check accesses to destroyed windows, thus
|
|
* those cases are ignored (especially on UnmapNotify's).
|
|
* Other types of errors call Xlib's default error handler, which
|
|
* calls exit().
|
|
*/
|
|
static int
|
|
wmii_error_handler(Display * dpy, XErrorEvent * error)
|
|
{
|
|
if(error->error_code == BadWindow
|
|
|| (error->request_code == X_SetInputFocus
|
|
&& error->error_code == BadMatch)
|
|
|| (error->request_code == X_PolyText8
|
|
&& error->error_code == BadDrawable)
|
|
|| (error->request_code == X_PolyFillRectangle
|
|
&& error->error_code == BadDrawable)
|
|
|| (error->request_code == X_PolySegment
|
|
&& error->error_code == BadDrawable)
|
|
|| (error->request_code == X_ConfigureWindow
|
|
&& error->error_code == BadMatch))
|
|
return 0;
|
|
fprintf(stderr, "%s", "wmiiwm: fatal error");
|
|
return x_error_handler(dpy, error); /* calls exit() */
|
|
}
|
|
|
|
/*
|
|
* Startup Error handler to check if another window manager
|
|
* is already running.
|
|
*/
|
|
static int
|
|
startup_error_handler(Display * dpy, XErrorEvent * error)
|
|
{
|
|
other_wm_running = 1;
|
|
return -1;
|
|
}
|
|
|
|
static void
|
|
cleanup()
|
|
{
|
|
size_t i;
|
|
Client *c;
|
|
for(i = 0; client && client[i]; i++) {
|
|
c = client[i];
|
|
reparent_client(c, root, c->frame.rect.x + c->rect.x, c->frame.rect.y + c->rect.y);
|
|
}
|
|
XSetInputFocus(dpy, PointerRoot, RevertToPointerRoot, CurrentTime);
|
|
XSync(dpy, False);
|
|
}
|
|
|
|
int
|
|
main(int argc, char *argv[])
|
|
{
|
|
int i;
|
|
int checkwm = 0;
|
|
char *sockfile = 0;
|
|
|
|
/* command line args */
|
|
if(argc > 1) {
|
|
for(i = 1; (i < argc) && (argv[i][0] == '-'); i++) {
|
|
switch (argv[i][1]) {
|
|
case 'v':
|
|
fprintf(stdout, "%s", version[0]);
|
|
exit(0);
|
|
break;
|
|
case 'c':
|
|
checkwm = 1;
|
|
break;
|
|
case 's':
|
|
if(i + 1 < argc)
|
|
sockfile = argv[++i];
|
|
else
|
|
usage();
|
|
break;
|
|
default:
|
|
usage();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
dpy = XOpenDisplay(0);
|
|
if(!dpy) {
|
|
fprintf(stderr, "%s", "wmiiwm: cannot open display\n");
|
|
exit(1);
|
|
}
|
|
screen = DefaultScreen(dpy);
|
|
root = RootWindow(dpy, screen);
|
|
|
|
/* check if another WM is already running */
|
|
other_wm_running = 0;
|
|
XSetErrorHandler(startup_error_handler);
|
|
/* this causes an error if some other WM is running */
|
|
XSelectInput(dpy, root, ROOT_MASK);
|
|
XSync(dpy, False);
|
|
|
|
if(other_wm_running) {
|
|
fprintf(stderr,
|
|
"wmiiwm: another window manager is already running\n");
|
|
exit(1);
|
|
}
|
|
if(checkwm) {
|
|
XCloseDisplay(dpy);
|
|
exit(0);
|
|
}
|
|
XSetErrorHandler(0);
|
|
x_error_handler = XSetErrorHandler(wmii_error_handler);
|
|
|
|
ixps = wmii_setup_server(sockfile);
|
|
|
|
init_event_hander();
|
|
|
|
if(!(def[WM_CTL] = ixp_create(ixps, "/ctl"))) {
|
|
perror("wmiiwm: cannot connect IXP server");
|
|
exit(1);
|
|
}
|
|
def[WM_CTL]->after_write = handle_after_write;
|
|
|
|
aqueuesz = detachedsz = pagesz = clientsz = sel_page = 0;
|
|
page = nil;
|
|
client = detached = nil;
|
|
aqueue = nil;
|
|
|
|
init_atoms();
|
|
init_cursors();
|
|
init_default();
|
|
font = blitz_getfont(dpy, def[WM_FONT]->content);
|
|
wmii_init_lock_modifiers(dpy, &valid_mask, &num_lock_mask);
|
|
init_screen();
|
|
scan_wins();
|
|
|
|
/* main event loop */
|
|
run_server_with_fd_support(ixps, ConnectionNumber(dpy), check_event,
|
|
0);
|
|
cleanup();
|
|
/* deinit_server(ixps);*/
|
|
XCloseDisplay(dpy);
|
|
|
|
return 0;
|
|
}
|