Branch for wmfs2
This commit is contained in:
Martin Duquesnoy
parent
4418cf6bbb
commit
4eca4bdcfa
2
.gitignore
vendored
Normal file
2
.gitignore
vendored
Normal file
@ -0,0 +1,2 @@
|
||||
Makefile
|
||||
wmfs
|
||||
124
src/barwin.c
Normal file
124
src/barwin.c
Normal file
@ -0,0 +1,124 @@
|
||||
/*
|
||||
* wmfs2 by Martin Duquesnoy <xorg62@gmail.com> { for(i = 2011; i < 2111; ++i) ©(i); }
|
||||
* For license, see COPYING.
|
||||
*/
|
||||
|
||||
#include "wmfs.h"
|
||||
#include "barwin.h"
|
||||
#include "util.h"
|
||||
|
||||
/** Create a barwin
|
||||
* \param parent Parent window of the BarWindow
|
||||
* \param x X position
|
||||
* \param y Y position
|
||||
* \param w barwin Width
|
||||
* \param h barwin Height
|
||||
* \param color barwin color
|
||||
* \param entermask bool for know if the EnterMask mask is needed
|
||||
* \return The BarWindow pointer
|
||||
*/
|
||||
struct barwin*
|
||||
barwin_new(Window parent, int x, int y, int w, int h, Color fg, Color bg, bool entermask)
|
||||
{
|
||||
struct barwin *b = (struct barwin*)xcalloc(1, sizeof(struct barwin));
|
||||
XSetWindowAttributes at =
|
||||
{
|
||||
.override_redirect = True,
|
||||
.background_pixmap = ParentRelative,
|
||||
.event_mask = BARWIN_MASK
|
||||
};
|
||||
|
||||
if(entermask)
|
||||
at.event_mask |= BARWIN_ENTERMASK;
|
||||
|
||||
/* Create window */
|
||||
b->win = XCreateWindow(W->dpy, parent,
|
||||
x, y, w, h,
|
||||
0, W->xdepth,
|
||||
CopyFromParent,
|
||||
DefaultVisual(W->dpy, W->xscreen),
|
||||
BARWIN_WINCW,
|
||||
&at);
|
||||
|
||||
b->dr = XCreatePixmap(W->dpy, parent, w, h, W->xdepth);
|
||||
|
||||
/* Property */
|
||||
b->geo.x = x;
|
||||
b->geo.y = y;
|
||||
b->geo.w = w;
|
||||
b->geo.h = h;
|
||||
b->bg = bg;
|
||||
b->fg = fg;
|
||||
|
||||
SLIST_INIT(&b->mousebinds);
|
||||
|
||||
/* Attach */
|
||||
SLIST_INSERT_HEAD(&W->h.barwin, b, next);
|
||||
|
||||
return b;
|
||||
}
|
||||
|
||||
/** Delete a barwin
|
||||
* \param bw barwin pointer
|
||||
*/
|
||||
void
|
||||
barwin_remove(struct barwin *b)
|
||||
{
|
||||
SLIST_REMOVE(&W->h.barwin, b, barwin, next);
|
||||
|
||||
XSelectInput(W->dpy, b->win, NoEventMask);
|
||||
XDestroyWindow(W->dpy, b->win);
|
||||
XFreePixmap(W->dpy, b->dr);
|
||||
|
||||
/* Free mousebinds */
|
||||
FREE_LIST(mousebind, b->mousebinds);
|
||||
|
||||
free(b);
|
||||
}
|
||||
|
||||
/** Resize a barwin
|
||||
* \param bw barwin pointer
|
||||
* \param w Width
|
||||
* \param h Height
|
||||
*/
|
||||
void
|
||||
barwin_resize(struct barwin *b, int w, int h)
|
||||
{
|
||||
/* Frame */
|
||||
XFreePixmap(W->dpy, b->dr);
|
||||
|
||||
b->dr = XCreatePixmap(W->dpy, W->root, w, h, W->xdepth);
|
||||
|
||||
b->geo.w = w;
|
||||
b->geo.h = h;
|
||||
|
||||
XResizeWindow(W->dpy, b->win, w, h);
|
||||
}
|
||||
|
||||
void
|
||||
barwin_mousebind_new(struct barwin *b, unsigned int button, bool u, struct geo a, void (*func)(Uicb), Uicb cmd)
|
||||
{
|
||||
struct mousebind *m = (struct mousebind*)xcalloc(1, sizeof(struct mousebind));
|
||||
|
||||
m->button = button;
|
||||
m->use_area = u;
|
||||
m->area = a;
|
||||
m->func = func;
|
||||
|
||||
m->cmd = (cmd ? xstrdup(cmd) : NULL);
|
||||
|
||||
SLIST_INSERT_HEAD(&b->mousebinds, m, next);
|
||||
}
|
||||
|
||||
/** Refresh the barwin Color
|
||||
* \param bw barwin pointer
|
||||
*/
|
||||
void
|
||||
barwin_refresh_color(struct barwin *b)
|
||||
{
|
||||
XSetForeground(W->dpy, W->gc, b->bg);
|
||||
XFillRectangle(W->dpy, b->dr, W->gc, 0, 0, b->geo.w, b->geo.h);
|
||||
}
|
||||
|
||||
|
||||
|
||||
32
src/barwin.h
Normal file
32
src/barwin.h
Normal file
@ -0,0 +1,32 @@
|
||||
/*
|
||||
* wmfs2 by Martin Duquesnoy <xorg62@gmail.com> { for(i = 2011; i < 2111; ++i) ©(i); }
|
||||
* For license, see COPYING.
|
||||
*/
|
||||
|
||||
#ifndef BARWIN_H
|
||||
#define BARWIN_H
|
||||
|
||||
#include "wmfs.h"
|
||||
|
||||
#define BARWIN_MASK \
|
||||
(SubstructureRedirectMask | SubstructureNotifyMask \
|
||||
| ButtonMask | MouseMask | ExposureMask | VisibilityChangeMask \
|
||||
| StructureNotifyMask | SubstructureRedirectMask)
|
||||
|
||||
#define BARWIN_ENTERMASK (EnterWindowMask | LeaveWindowMask | FocusChangeMask)
|
||||
#define BARWIN_WINCW (CWOverrideRedirect | CWBackPixmap | CWEventMask)
|
||||
|
||||
#define barwin_delete_subwin(b) XDestroySubwindows(W->dpy, b->win)
|
||||
#define barwin_map_subwin(b) XMapSubwindows(W->dpy, b->win)
|
||||
#define barwin_unmap_subwin(b) XUnmapSubwindows(W->dpy, b->win)
|
||||
#define barwin_refresh(b) XCopyArea(W->dpy, b->dr, b->win, W->gc, 0, 0, b->geo.w, b->geo.h, 0, 0)
|
||||
#define barwin_map(b) XMapWindow(W->dpy, b->win);
|
||||
#define barwin_unmap(b) XUnmapWindow(W->dpy, b->win);
|
||||
|
||||
struct barwin* barwin_new(Window parent, int x, int y, int w, int h, Color fg, Color bg, bool entermask);
|
||||
void barwin_remove(struct barwin *b);
|
||||
void barwin_resize(struct barwin *b, int w, int h);
|
||||
void barwin_mousebind_new(struct barwin *b, unsigned int button, bool u, struct geo a, void (*func)(Uicb), Uicb cmd);
|
||||
void barwin_refresh_color(struct barwin *b);
|
||||
|
||||
#endif /* BARWIN_H */
|
||||
BIN
src/barwin.o
Normal file
BIN
src/barwin.o
Normal file
Binary file not shown.
432
src/client.c
Normal file
432
src/client.c
Normal file
@ -0,0 +1,432 @@
|
||||
/*
|
||||
* wmfs2 by Martin Duquesnoy <xorg62@gmail.com> { for(i = 2011; i < 2111; ++i) ©(i); }
|
||||
* For license, see COPYING.
|
||||
*/
|
||||
|
||||
#include <X11/Xutil.h>
|
||||
|
||||
#include "client.h"
|
||||
#include "config.h"
|
||||
#include "util.h"
|
||||
#include "barwin.h"
|
||||
#include "ewmh.h"
|
||||
#include "layout.h"
|
||||
#include "draw.h"
|
||||
|
||||
#define CLIENT_MOUSE_MOD Mod1Mask
|
||||
|
||||
#define CLIENT_RESIZE_DIR(D) \
|
||||
void uicb_client_resize_##D(Uicb cmd) \
|
||||
{ \
|
||||
if(W->client) \
|
||||
client_fac_resize(W->client, D, ATOI(cmd)); \
|
||||
}
|
||||
|
||||
#define CLIENT_ACTION_DIR(A, D) \
|
||||
void uicb_client_##A##_##D(Uicb cmd) \
|
||||
{ \
|
||||
(void)cmd; \
|
||||
struct client *c; \
|
||||
if(W->client && (c = client_next_with_pos(W->client, D))) \
|
||||
client_##A(c); \
|
||||
}
|
||||
|
||||
#define CLIENT_ACTION_LIST(A, L) \
|
||||
void uicb_client_##A##_##L(Uicb cmd) \
|
||||
{ \
|
||||
(void)cmd; \
|
||||
struct client *c; \
|
||||
if(W->client && (c = client_##L(W->client))) \
|
||||
client_##A(c); \
|
||||
}
|
||||
|
||||
/* uicb_client_resize_dir() */
|
||||
CLIENT_RESIZE_DIR(Right)
|
||||
CLIENT_RESIZE_DIR(Left)
|
||||
CLIENT_RESIZE_DIR(Top)
|
||||
CLIENT_RESIZE_DIR(Bottom)
|
||||
|
||||
/* uicb_client_focus_dir() */
|
||||
CLIENT_ACTION_DIR(focus, Right)
|
||||
CLIENT_ACTION_DIR(focus, Left)
|
||||
CLIENT_ACTION_DIR(focus, Top)
|
||||
CLIENT_ACTION_DIR(focus, Bottom)
|
||||
|
||||
/* uicb_client_swapsel_dir() */
|
||||
#define client_swapsel(c) client_swap(W->client, c)
|
||||
CLIENT_ACTION_DIR(swapsel, Right)
|
||||
CLIENT_ACTION_DIR(swapsel, Left)
|
||||
CLIENT_ACTION_DIR(swapsel, Top)
|
||||
CLIENT_ACTION_DIR(swapsel, Bottom)
|
||||
|
||||
/* uicb_client_focus_next/prev() */
|
||||
CLIENT_ACTION_LIST(focus, next)
|
||||
CLIENT_ACTION_LIST(focus, prev)
|
||||
|
||||
/* uicb_client_swapsel_next/prev() */
|
||||
CLIENT_ACTION_LIST(swapsel, next)
|
||||
CLIENT_ACTION_LIST(swapsel, prev)
|
||||
|
||||
/** Send a ConfigureRequest event to the struct client
|
||||
* \param c struct client pointer
|
||||
*/
|
||||
void
|
||||
client_configure(struct client *c)
|
||||
{
|
||||
XConfigureEvent ev =
|
||||
{
|
||||
.type = ConfigureNotify,
|
||||
.event = c->win,
|
||||
.window = c->win,
|
||||
.x = c->geo.x,
|
||||
.y = c->geo.y,
|
||||
.width = c->geo.w,
|
||||
.height = c->geo.h,
|
||||
.above = None,
|
||||
.border_width = 0,
|
||||
.override_redirect = 0
|
||||
};
|
||||
|
||||
XSendEvent(W->dpy, c->win, False, StructureNotifyMask, (XEvent *)&ev);
|
||||
XSync(W->dpy, False);
|
||||
}
|
||||
|
||||
struct client*
|
||||
client_gb_win(Window w)
|
||||
{
|
||||
struct client *c = SLIST_FIRST(&W->h.client);
|
||||
|
||||
while(c && c->win != w)
|
||||
c = SLIST_NEXT(c, next);
|
||||
|
||||
return c;
|
||||
}
|
||||
|
||||
struct client*
|
||||
client_gb_pos(struct tag *t, int x, int y)
|
||||
{
|
||||
struct client *c = SLIST_FIRST(&t->clients);
|
||||
|
||||
while(c)
|
||||
{
|
||||
if(INAREA(x, y, c->geo))
|
||||
return c;
|
||||
|
||||
c = SLIST_NEXT(c, tnext);
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/** Get client left/right/top/bottom of selected client
|
||||
*\param bc Base client
|
||||
*\param pos Position
|
||||
*\return Client found or NULL
|
||||
*/
|
||||
struct client*
|
||||
client_next_with_pos(struct client *bc, Position p)
|
||||
{
|
||||
struct client *c;
|
||||
int x, y;
|
||||
static const char scanfac[PositionLast] = { +10, -10, 0, 0 };
|
||||
Position ip = Bottom - p;
|
||||
|
||||
/*
|
||||
* Set start place of pointer (edge with position
|
||||
* of base client) for faster scanning.
|
||||
*/
|
||||
x = bc->geo.x + ((p == Right) ? bc->geo.w : 0);
|
||||
y = bc->geo.y + ((p == Bottom) ? bc->geo.h : 0);
|
||||
y += ((LDIR(p)) ? (bc->geo.h >> 1) : 0);
|
||||
x += ((p > Left) ? (bc->geo.w >> 1) : 0);
|
||||
|
||||
/* Scan in right direction to next(p) physical client */
|
||||
while((c = client_gb_pos(bc->tag, x, y)) == bc)
|
||||
{
|
||||
x += scanfac[p];
|
||||
y += scanfac[ip];
|
||||
}
|
||||
|
||||
return c;
|
||||
}
|
||||
|
||||
void
|
||||
client_swap(struct client *c1, struct client *c2)
|
||||
{
|
||||
struct tag *t;
|
||||
struct geo g;
|
||||
|
||||
if(c1 == c2 || !c1 || !c2)
|
||||
return;
|
||||
|
||||
t = c1->tag;
|
||||
g = c1->geo;
|
||||
|
||||
swap_ptr((void**)&c1->screen, (void**)&c2->screen);
|
||||
|
||||
tag_client(c2->tag, c1);
|
||||
tag_client(t, c2);
|
||||
|
||||
client_moveresize(c1, c2->geo);
|
||||
client_moveresize(c2, g);
|
||||
}
|
||||
|
||||
static void
|
||||
client_grabbuttons(struct client *c, bool focused)
|
||||
{
|
||||
XUngrabButton(W->dpy, AnyButton, AnyModifier, c->win);
|
||||
|
||||
if(focused)
|
||||
{
|
||||
int i = 0;
|
||||
|
||||
while(i++ != Button5)
|
||||
{
|
||||
XGrabButton(W->dpy, i, CLIENT_MOUSE_MOD, c->win, False,
|
||||
ButtonMask, GrabModeAsync, GrabModeSync, None, None);
|
||||
XGrabButton(W->dpy, i, CLIENT_MOUSE_MOD | LockMask, c->win, False,
|
||||
ButtonMask, GrabModeAsync, GrabModeSync, None, None);
|
||||
XGrabButton(W->dpy, i, CLIENT_MOUSE_MOD | W->numlockmask, c->win, False,
|
||||
ButtonMask, GrabModeAsync, GrabModeSync, None, None);
|
||||
XGrabButton(W->dpy, i, CLIENT_MOUSE_MOD | LockMask | W->numlockmask, c->win, False,
|
||||
ButtonMask, GrabModeAsync, GrabModeSync, None, None);
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
XGrabButton(W->dpy, AnyButton, AnyModifier, c->win, False,
|
||||
ButtonMask, GrabModeAsync, GrabModeSync, None, None);
|
||||
|
||||
}
|
||||
|
||||
static inline void
|
||||
client_draw_bord(struct client *c)
|
||||
{
|
||||
struct geo g = { 0, 0, c->screen->ugeo.w, c->screen->ugeo.h };
|
||||
|
||||
draw_rect(c->tag->frame, g, THEME_DEFAULT->client_n.bg);
|
||||
|
||||
/* Selected client's border */
|
||||
if(W->client)
|
||||
draw_rect(W->client->tag->frame, W->client->tag->sel->geo, THEME_DEFAULT->client_s.bg);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
client_focus(struct client *c)
|
||||
{
|
||||
/* Unfocus selected */
|
||||
if(W->client && W->client != c)
|
||||
client_grabbuttons(W->client, false);
|
||||
|
||||
/* Focus c */
|
||||
if((W->client = c))
|
||||
{
|
||||
c->tag->sel = c;
|
||||
|
||||
client_draw_bord(c);
|
||||
client_grabbuttons(c, true);
|
||||
|
||||
XSetInputFocus(W->dpy, c->win, RevertToPointerRoot, CurrentTime);
|
||||
}
|
||||
else
|
||||
{
|
||||
W->client = W->screen->seltag->sel = NULL;
|
||||
XSetInputFocus(W->dpy, W->root, RevertToPointerRoot, CurrentTime);
|
||||
}
|
||||
}
|
||||
|
||||
/** Get a client name
|
||||
* \param c struct client pointer
|
||||
*/
|
||||
void
|
||||
client_get_name(struct client *c)
|
||||
{
|
||||
Atom rt;
|
||||
int rf;
|
||||
unsigned long ir, il;
|
||||
|
||||
/* This one instead XFetchName for utf8 name support */
|
||||
if(XGetWindowProperty(W->dpy, c->win, ATOM("_NET_WM_NAME"), 0, 4096,
|
||||
False, ATOM("UTF8_STRING"), &rt, &rf, &ir, &il, (unsigned char**)&c->title) != Success)
|
||||
XGetWindowProperty(W->dpy, c->win, ATOM("WM_NAME"), 0, 4096,
|
||||
False, ATOM("UTF8_STRING"), &rt, &rf, &ir, &il, (unsigned char**)&c->title);
|
||||
|
||||
/* Still no title... */
|
||||
if(!c->title)
|
||||
XFetchName(W->dpy, c->win, &(c->title));
|
||||
}
|
||||
|
||||
/** Close a client
|
||||
* \param c struct client pointer
|
||||
*/
|
||||
void
|
||||
client_close(struct client *c)
|
||||
{
|
||||
int proto;
|
||||
XEvent ev;
|
||||
Atom *atom = NULL;
|
||||
|
||||
/* Event will call client_remove */
|
||||
if(XGetWMProtocols(W->dpy, c->win, &atom, &proto) && atom)
|
||||
{
|
||||
while(proto--)
|
||||
if(atom[proto] == ATOM("WM_DELETE_WINDOW"))
|
||||
{
|
||||
ev.type = ClientMessage;
|
||||
ev.xclient.window = c->win;
|
||||
ev.xclient.message_type = ATOM("WM_PROTOCOLS");
|
||||
ev.xclient.format = 32;
|
||||
ev.xclient.data.l[0] = ATOM("WM_DELETE_WINDOW");
|
||||
ev.xclient.data.l[1] = CurrentTime;
|
||||
|
||||
XSendEvent(W->dpy, c->win, False, NoEventMask, &ev);
|
||||
XFree(atom);
|
||||
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
XKillClient(W->dpy, c->win);
|
||||
}
|
||||
|
||||
void
|
||||
uicb_client_close(Uicb cmd)
|
||||
{
|
||||
(void)cmd;
|
||||
|
||||
if(W->client)
|
||||
client_close(W->client);
|
||||
}
|
||||
|
||||
struct client*
|
||||
client_new(Window w, XWindowAttributes *wa)
|
||||
{
|
||||
struct client *c = xcalloc(1, sizeof(struct client));
|
||||
|
||||
/* C attributes */
|
||||
c->win = w;
|
||||
c->screen = W->screen;
|
||||
c->flags = 0;
|
||||
c->tag = NULL;
|
||||
|
||||
/* struct geometry */
|
||||
c->geo.x = wa->x;
|
||||
c->geo.y = wa->y;
|
||||
c->geo.w = wa->width;
|
||||
c->geo.h = wa->height;
|
||||
c->tgeo = c->wgeo = c->geo;
|
||||
|
||||
/* Set tag */
|
||||
tag_client(W->screen->seltag, c);
|
||||
|
||||
/* X window attributes */
|
||||
XSelectInput(W->dpy, w, EnterWindowMask | LeaveWindowMask | StructureNotifyMask | PropertyChangeMask);
|
||||
XSetWindowBorderWidth(W->dpy, w, 0);
|
||||
client_grabbuttons(c, false);
|
||||
|
||||
/* Attach */
|
||||
SLIST_INSERT_HEAD(&W->h.client, c, next);
|
||||
|
||||
/* Map */
|
||||
WIN_STATE(w, Map);
|
||||
ewmh_set_wm_state(w, NormalState);
|
||||
|
||||
client_get_name(c);
|
||||
client_focus(c);
|
||||
client_configure(c);
|
||||
|
||||
return c;
|
||||
}
|
||||
|
||||
void
|
||||
client_moveresize(struct client *c, struct geo g)
|
||||
{
|
||||
int bord = THEME_DEFAULT->client_border_width;
|
||||
|
||||
c->geo = g;
|
||||
|
||||
/* Window geo */
|
||||
c->wgeo.x = g.x + bord;
|
||||
c->wgeo.y = g.y + bord ;
|
||||
c->wgeo.w = g.w - (bord << 1);
|
||||
c->wgeo.h = g.h - (bord << 1);
|
||||
|
||||
XMoveResizeWindow(W->dpy, c->win,
|
||||
c->wgeo.x, c->wgeo.y,
|
||||
c->wgeo.w, c->wgeo.h);
|
||||
|
||||
client_draw_bord(c);
|
||||
client_configure(c);
|
||||
}
|
||||
|
||||
void
|
||||
client_maximize(struct client *c)
|
||||
{
|
||||
c->geo = c->tag->screen->ugeo;
|
||||
|
||||
c->geo.x = c->geo.y = 0; /* Frame x/y, not screen geo */
|
||||
c->geo.w = c->tag->screen->ugeo.w;
|
||||
c->geo.h = c->tag->screen->ugeo.h;
|
||||
|
||||
client_moveresize(c, c->geo);
|
||||
}
|
||||
|
||||
void
|
||||
client_fac_resize(struct client *c, Position p, int fac)
|
||||
{
|
||||
struct client *gc = client_next_with_pos(c, p);
|
||||
Position rp = RPOS(p);
|
||||
|
||||
if(!gc || gc->screen != c->screen)
|
||||
return;
|
||||
|
||||
/* Check futur size/pos */
|
||||
if(!client_fac_geo(c, p, fac)
|
||||
|| !client_fac_geo(gc, rp, -fac)
|
||||
|| !client_fac_check_row(c, p, fac)
|
||||
|| !client_fac_check_row(gc, rp, -fac))
|
||||
return;
|
||||
|
||||
|
||||
/* Simple resize with only c & gc */
|
||||
if(GEO_CHECK2(c->geo, gc->geo, p))
|
||||
{
|
||||
client_moveresize(c, c->tgeo);
|
||||
client_moveresize(gc, gc->tgeo);
|
||||
}
|
||||
/* Resize with row parents */
|
||||
else
|
||||
{
|
||||
client_fac_arrange_row(c, p, fac);
|
||||
client_fac_arrange_row(gc, rp, -fac);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
client_remove(struct client *c)
|
||||
{
|
||||
XGrabServer(W->dpy);
|
||||
XSetErrorHandler(wmfs_error_handler_dummy);
|
||||
XReparentWindow(W->dpy, c->win, W->root, c->geo.x, c->geo.y);
|
||||
|
||||
/* Remove from global client list */
|
||||
SLIST_REMOVE(&W->h.client, c, client, next);
|
||||
|
||||
tag_client(NULL, c);
|
||||
|
||||
ewmh_set_wm_state(c->win, WithdrawnState);
|
||||
|
||||
XUngrabServer(W->dpy);
|
||||
XSync(W->dpy, False);
|
||||
XSetErrorHandler(wmfs_error_handler);
|
||||
|
||||
free(c);
|
||||
}
|
||||
|
||||
void
|
||||
client_free(void)
|
||||
{
|
||||
FREE_LIST(client, W->h.client);
|
||||
}
|
||||
130
src/client.h
Normal file
130
src/client.h
Normal file
@ -0,0 +1,130 @@
|
||||
/*
|
||||
* wmfs2 by Martin Duquesnoy <xorg62@gmail.com> { for(i = 2011; i < 2111; ++i) ©(i); }
|
||||
* For license, see COPYING.
|
||||
*/
|
||||
|
||||
#ifndef CLIENT_H
|
||||
#define CLIENT_H
|
||||
|
||||
#include "wmfs.h"
|
||||
#include "layout.h"
|
||||
|
||||
void client_configure(struct client *c);
|
||||
struct client *client_gb_win(Window w);
|
||||
struct client *client_gb_pos(struct tag *t, int x, int y);
|
||||
struct client *client_next_with_pos(struct client *bc, Position p);
|
||||
void client_swap(struct client *c1, struct client *c2);
|
||||
void client_focus(struct client *c);
|
||||
void client_get_name(struct client *c);
|
||||
void client_close(struct client *c);
|
||||
void uicb_client_close(Uicb cmd);
|
||||
struct client *client_new(Window w, XWindowAttributes *wa);
|
||||
void client_moveresize(struct client *c, struct geo g);
|
||||
void client_maximize(struct client *c);
|
||||
void client_fac_resize(struct client *c, Position p, int fac);
|
||||
void client_remove(struct client *c);
|
||||
void client_free(void);
|
||||
|
||||
/* Generated */
|
||||
void uicb_client_resize_Right(Uicb);
|
||||
void uicb_client_resize_Left(Uicb);
|
||||
void uicb_client_resize_Top(Uicb);
|
||||
void uicb_client_resize_Bottom(Uicb);
|
||||
void uicb_client_focus_Right(Uicb);
|
||||
void uicb_client_focus_Left(Uicb);
|
||||
void uicb_client_focus_Top(Uicb);
|
||||
void uicb_client_focus_Bottom(Uicb);
|
||||
void uicb_client_swapsel_Right(Uicb);
|
||||
void uicb_client_swapsel_Left(Uicb);
|
||||
void uicb_client_swapsel_Top(Uicb);
|
||||
void uicb_client_swapsel_Bottom(Uicb);
|
||||
void uicb_client_focus_next(Uicb);
|
||||
void uicb_client_focus_prev(Uicb);
|
||||
void uicb_client_swapsel_next(Uicb);
|
||||
void uicb_client_swapsel_prev(Uicb);
|
||||
|
||||
static inline struct client*
|
||||
client_next(struct client *c)
|
||||
{
|
||||
return (SLIST_NEXT(c, tnext)
|
||||
? SLIST_NEXT(c, tnext)
|
||||
: SLIST_FIRST(&c->tag->clients));
|
||||
}
|
||||
|
||||
static inline struct client*
|
||||
client_prev(struct client *c)
|
||||
{
|
||||
struct client *cc;
|
||||
|
||||
for(cc = SLIST_FIRST(&c->tag->clients);
|
||||
SLIST_NEXT(cc, tnext) && SLIST_NEXT(cc, tnext) != c;
|
||||
cc = SLIST_NEXT(cc, tnext));
|
||||
|
||||
return cc;
|
||||
}
|
||||
|
||||
static inline bool
|
||||
client_fac_geo(struct client *c, Position p, int fac)
|
||||
{
|
||||
struct geo cg = c->geo;
|
||||
|
||||
switch(p)
|
||||
{
|
||||
default:
|
||||
case Right:
|
||||
cg.w += fac;
|
||||
break;
|
||||
case Left:
|
||||
cg.x -= fac;
|
||||
cg.w += fac;
|
||||
break;
|
||||
case Top:
|
||||
cg.y -= fac;
|
||||
cg.h += fac;
|
||||
break;
|
||||
case Bottom:
|
||||
cg.h += fac;
|
||||
break;
|
||||
}
|
||||
|
||||
/* Check for incompatible geo */
|
||||
if(cg.w > c->screen->ugeo.w || cg.h > c->screen->ugeo.h
|
||||
|| cg.w < 5 || cg.h < 5)
|
||||
return false;
|
||||
|
||||
/* Set transformed geo in tmp geo */
|
||||
c->tgeo = cg;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static inline bool
|
||||
client_fac_check_row(struct client *c, Position p, int fac)
|
||||
{
|
||||
struct geo g = c->geo;
|
||||
struct client *cc;
|
||||
|
||||
/* Travel clients to search parents of row and check geos */
|
||||
SLIST_FOREACH(cc, &c->tag->clients, tnext)
|
||||
if(GEO_PARENTROW(g, cc->geo, p) && !client_fac_geo(cc, p, fac))
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static inline void
|
||||
client_fac_arrange_row(struct client *c, Position p, int fac)
|
||||
{
|
||||
struct geo g = c->geo;
|
||||
struct client *cc;
|
||||
|
||||
/* Travel clients to search row parents and apply fac */
|
||||
SLIST_FOREACH(cc, &c->tag->clients, tnext)
|
||||
if(GEO_PARENTROW(g, cc->geo, p))
|
||||
{
|
||||
client_fac_geo(cc, p, fac);
|
||||
client_moveresize(cc, cc->tgeo);
|
||||
}
|
||||
}
|
||||
|
||||
#endif /* CLIENT_H */
|
||||
BIN
src/client.o
Normal file
BIN
src/client.o
Normal file
Binary file not shown.
216
src/config.c
Normal file
216
src/config.c
Normal file
@ -0,0 +1,216 @@
|
||||
/*
|
||||
* wmfs2 by Martin Duquesnoy <xorg62@gmail.com> { for(i = 2011; i < 2111; ++i) ©(i); }
|
||||
* For license, see COPYING.
|
||||
*/
|
||||
|
||||
#include "config.h"
|
||||
#include "wmfs.h"
|
||||
#include "parse.h"
|
||||
#include "tag.h"
|
||||
#include "screen.h"
|
||||
#include "infobar.h"
|
||||
#include "util.h"
|
||||
|
||||
#define CONFIG_DEFAULT_PATH ".config/wmfs/wmfsrc2" /* tmp */
|
||||
|
||||
static void
|
||||
config_theme(void)
|
||||
{
|
||||
struct theme *t, *p = NULL;
|
||||
size_t i, n;
|
||||
struct conf_sec *sec, **ks;
|
||||
|
||||
/* [themes] */
|
||||
sec = fetch_section_first(NULL, "themes");
|
||||
ks = fetch_section(sec, "theme");
|
||||
|
||||
/* No theme section? Make one with default value anyway. */
|
||||
if(!(n = fetch_section_count(ks)))
|
||||
++n;
|
||||
|
||||
SLIST_INIT(&W->h.theme);
|
||||
|
||||
/* [theme]*/
|
||||
for(i = 0; i < n; ++i)
|
||||
{
|
||||
t = (struct theme*)xcalloc(1, sizeof(struct theme));
|
||||
|
||||
t->name = fetch_opt_first(ks[i], "default", "name").str;
|
||||
|
||||
wmfs_init_font(fetch_opt_first(ks[i], "fixed", "font").str, t);
|
||||
|
||||
/* bars */
|
||||
t->bars.fg = color_atoh(fetch_opt_first(ks[i], "#CCCCCC", "bars_fg").str);
|
||||
t->bars.bg = color_atoh(fetch_opt_first(ks[i], "#222222", "bars_bg").str);
|
||||
t->bars_width = fetch_opt_first(ks[i], "12", "bars_width").num;
|
||||
|
||||
/*
|
||||
* Elements
|
||||
*/
|
||||
t->tags_n.fg = color_atoh(fetch_opt_first(ks[i], "#CCCCCC", "tags_normal_fg").str);
|
||||
t->tags_n.bg = color_atoh(fetch_opt_first(ks[i], "#222222", "tags_normal_bg").str);
|
||||
t->tags_s.fg = color_atoh(fetch_opt_first(ks[i], "#222222", "tags_sel_fg").str);
|
||||
t->tags_s.bg = color_atoh(fetch_opt_first(ks[i], "#CCCCCC", "tags_sel_bg").str);
|
||||
t->tags_border_col = color_atoh(fetch_opt_first(ks[i], "#888888", "tags_border_color").str);
|
||||
t->tags_border_width = fetch_opt_first(ks[i], "0", "tags_border_width").num;
|
||||
|
||||
/* Client / frame */
|
||||
t->client_n.fg = color_atoh(fetch_opt_first(ks[i], "#CCCCCC", "client_normal_fg").str);
|
||||
t->client_n.bg = color_atoh(fetch_opt_first(ks[i], "#222222", "client_normal_bg").str);
|
||||
t->client_s.fg = color_atoh(fetch_opt_first(ks[i], "#222222", "client_sel_fg").str);
|
||||
t->client_s.bg = color_atoh(fetch_opt_first(ks[i], "#CCCCCC", "client_sel_bg").str);
|
||||
t->frame_bg = color_atoh(fetch_opt_first(ks[i], "#555555", "frame_bg").str);
|
||||
t->client_titlebar_width = fetch_opt_first(ks[i], "12", "client_titlebar_width").num;
|
||||
t->client_border_width = fetch_opt_first(ks[i], "1", "client_border_width").num;
|
||||
|
||||
/* insert_tail with SLIST */
|
||||
if(SLIST_EMPTY(&W->h.theme))
|
||||
SLIST_INSERT_HEAD(&W->h.theme, t, next);
|
||||
else
|
||||
SLIST_INSERT_AFTER(p, t, next);
|
||||
|
||||
p = t;
|
||||
}
|
||||
|
||||
free(ks);
|
||||
}
|
||||
|
||||
static void
|
||||
config_bars(void)
|
||||
{
|
||||
struct screen *s;
|
||||
struct theme *t;
|
||||
size_t i, n;
|
||||
struct conf_sec *sec, **ks;
|
||||
int screenid;
|
||||
char *elem;
|
||||
Barpos pos = BarTop;
|
||||
|
||||
/* [bars] */
|
||||
sec = fetch_section_first(NULL, "bars");
|
||||
ks = fetch_section(sec, "bar");
|
||||
n = fetch_section_count(ks);
|
||||
|
||||
/* [bar] */
|
||||
for(i = 0; i < n; ++i)
|
||||
{
|
||||
elem = fetch_opt_first(ks[i], "", "elements").str;
|
||||
screenid = fetch_opt_first(ks[i], "-1", "screen").num;
|
||||
t = name_to_theme(fetch_opt_first(ks[i], "default", "theme").str);
|
||||
pos = fetch_opt_first(ks[i], "0", "position").num;
|
||||
|
||||
SLIST_FOREACH(s, &W->h.screen, next)
|
||||
if(screenid == s->id || screenid == -1)
|
||||
infobar_new(s, t, pos, elem);
|
||||
}
|
||||
|
||||
free(ks);
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
config_tag(void)
|
||||
{
|
||||
struct screen *s;
|
||||
struct tag *t;
|
||||
size_t i, n;
|
||||
struct conf_sec *sec, **ks;
|
||||
char *name;
|
||||
int screenid;
|
||||
|
||||
/* [tags] */
|
||||
sec = fetch_section_first(NULL, "tags");
|
||||
ks = fetch_section(sec, "tag");
|
||||
n = fetch_section_count(ks);
|
||||
|
||||
/* [tag] */
|
||||
for(i = 0; i < n; ++i)
|
||||
{
|
||||
name = fetch_opt_first(ks[i], "tag", "name").str;
|
||||
screenid = fetch_opt_first(ks[i], "-1", "screen").num;
|
||||
|
||||
SLIST_FOREACH(s, &W->h.screen, next)
|
||||
if(screenid == s->id || screenid == -1)
|
||||
{
|
||||
t = tag_new(s, name);
|
||||
|
||||
/* Set first tag as seltag */
|
||||
if(t == TAILQ_FIRST(&s->tags))
|
||||
s->seltag = t;
|
||||
}
|
||||
}
|
||||
|
||||
free(ks);
|
||||
}
|
||||
|
||||
static void
|
||||
config_keybind(void)
|
||||
{
|
||||
int i, n;
|
||||
size_t j;
|
||||
struct conf_sec *sec, **ks;
|
||||
struct opt_type *opt;
|
||||
char *cmd;
|
||||
struct keybind *k;
|
||||
|
||||
/* [keys] */
|
||||
sec = fetch_section_first(NULL, "keys");
|
||||
ks = fetch_section(sec, "key");
|
||||
n = fetch_section_count(ks);
|
||||
|
||||
SLIST_INIT(&W->h.keybind);
|
||||
|
||||
/* [key] */
|
||||
for(i = 0; i < n; ++i)
|
||||
{
|
||||
k = (struct keybind*)xcalloc(1, sizeof(struct keybind));
|
||||
|
||||
/* mod = {} */
|
||||
opt = fetch_opt(ks[i], "", "mod");
|
||||
|
||||
for(j = k->mod = 0; j < fetch_opt_count(opt); ++j)
|
||||
k->mod |= modkey_keysym(opt[j].str);
|
||||
|
||||
free(opt);
|
||||
|
||||
/* key = */
|
||||
k->keysym = XStringToKeysym(fetch_opt_first(ks[i], "None", "key").str);
|
||||
|
||||
/* func = */
|
||||
if(!(k->func = uicb_name_func(fetch_opt_first(ks[i], "", "func").str)))
|
||||
{
|
||||
warnx("configuration: Unknown Function \"%s\".",
|
||||
fetch_opt_first(ks[i], "", "func").str);
|
||||
k->func = uicb_spawn;
|
||||
}
|
||||
|
||||
/* cmd = */
|
||||
if((cmd = fetch_opt_first(ks[i], "", "cmd").str))
|
||||
k->cmd = xstrdup(cmd);
|
||||
|
||||
SLIST_INSERT_HEAD(&W->h.keybind, k, next);
|
||||
}
|
||||
|
||||
wmfs_grab_keys();
|
||||
|
||||
free(ks);
|
||||
}
|
||||
|
||||
void
|
||||
config_init(void)
|
||||
{
|
||||
char *path;
|
||||
|
||||
xasprintf(&path, "%s/"CONFIG_DEFAULT_PATH, getenv("HOME"));
|
||||
|
||||
if(get_conf(path) == -1)
|
||||
errx(1, "parsing configuration file (%s) failed.", path);
|
||||
|
||||
config_theme();
|
||||
config_keybind();
|
||||
config_tag();
|
||||
config_bars();
|
||||
|
||||
free(path);
|
||||
free_conf();
|
||||
}
|
||||
115
src/config.h
Normal file
115
src/config.h
Normal file
@ -0,0 +1,115 @@
|
||||
/*
|
||||
* wmfs2 by Martin Duquesnoy <xorg62@gmail.com> { for(i = 2011; i < 2111; ++i) ©(i); }
|
||||
* For license, see COPYING.
|
||||
*/
|
||||
|
||||
|
||||
#ifndef CONFIG_H
|
||||
#define CONFIG_H
|
||||
|
||||
#include <string.h>
|
||||
#include <X11/Xlib.h>
|
||||
|
||||
#include "wmfs.h"
|
||||
#include "util.h"
|
||||
#include "tag.h"
|
||||
#include "client.h"
|
||||
|
||||
#define THEME_DEFAULT (SLIST_FIRST(&W->h.theme))
|
||||
|
||||
static const struct { char *name; void (*func)(Uicb cmd); } uicb_list[] =
|
||||
{
|
||||
/* Sys */
|
||||
{ "spawn", uicb_spawn },
|
||||
{ "quit", uicb_quit },
|
||||
{ "reload", uicb_reload },
|
||||
|
||||
/* Tag */
|
||||
{ "tag_set", uicb_tag_set },
|
||||
{ "tag", uicb_tag_set_with_name },
|
||||
{ "tag_next", uicb_tag_next },
|
||||
{ "tag_prev", uicb_tag_prev },
|
||||
|
||||
/* Layout */
|
||||
{ "layout_vmirror", uicb_layout_vmirror },
|
||||
{ "layout_hmirror", uicb_layout_hmirror },
|
||||
{ "layout_rotate_left", uicb_layout_rotate_left },
|
||||
{ "layout_rotate_right", uicb_layout_rotate_right },
|
||||
|
||||
/* Client */
|
||||
{ "client_close", uicb_client_close },
|
||||
{ "client_resize_right", uicb_client_resize_Right },
|
||||
{ "client_resize_left", uicb_client_resize_Left },
|
||||
{ "client_resize_top", uicb_client_resize_Top },
|
||||
{ "client_resize_bottom", uicb_client_resize_Bottom },
|
||||
{ "client_focus_right", uicb_client_focus_Right },
|
||||
{ "client_focus_left", uicb_client_focus_Left },
|
||||
{ "client_focus_top", uicb_client_focus_Top },
|
||||
{ "client_focus_bottom", uicb_client_focus_Bottom },
|
||||
{ "client_swap_right", uicb_client_swapsel_Right },
|
||||
{ "client_swap_left", uicb_client_swapsel_Left },
|
||||
{ "client_swap_top", uicb_client_swapsel_Top },
|
||||
{ "client_swap_bottom", uicb_client_swapsel_Bottom },
|
||||
{ "client_focus_next", uicb_client_focus_next },
|
||||
{ "client_focus_prev", uicb_client_focus_prev },
|
||||
{ "client_swap_next", uicb_client_swapsel_next },
|
||||
{ "client_swap_prev", uicb_client_swapsel_prev },
|
||||
{ NULL, NULL }
|
||||
};
|
||||
|
||||
static inline void*
|
||||
uicb_name_func(Uicb name)
|
||||
{
|
||||
int i = 0;
|
||||
|
||||
for(; uicb_list[i].func; ++i)
|
||||
if(!strcmp(name, uicb_list[i].name))
|
||||
return uicb_list[i].func;
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static const struct { const char *name; KeySym keysym; } key_list[] =
|
||||
{
|
||||
{"Control", ControlMask },
|
||||
{"Shift", ShiftMask },
|
||||
{"Lock", LockMask },
|
||||
{"Alt", Mod1Mask },
|
||||
{"Mod1", Mod1Mask },
|
||||
{"Mod2", Mod2Mask },
|
||||
{"Mod3", Mod3Mask },
|
||||
{"Mod4", Mod4Mask },
|
||||
{"Super", Mod4Mask },
|
||||
{"Home", Mod4Mask },
|
||||
{"Mod5", Mod5Mask },
|
||||
{NULL, NoSymbol }
|
||||
};
|
||||
|
||||
static inline KeySym
|
||||
modkey_keysym(const char *name)
|
||||
{
|
||||
int i = 0;
|
||||
|
||||
for(; key_list[i].name; ++i)
|
||||
if(!strcmp(name, key_list[i].name))
|
||||
return key_list[i].keysym;
|
||||
|
||||
return NoSymbol;
|
||||
}
|
||||
|
||||
static inline struct theme*
|
||||
name_to_theme(const char *name)
|
||||
{
|
||||
struct theme *t;
|
||||
|
||||
SLIST_FOREACH(t, &W->h.theme, next)
|
||||
if(!strcmp(t->name, name))
|
||||
return t;
|
||||
|
||||
return THEME_DEFAULT;
|
||||
}
|
||||
|
||||
|
||||
void config_init(void);
|
||||
|
||||
#endif /* CONFIG_H */
|
||||
BIN
src/config.o
Normal file
BIN
src/config.o
Normal file
Binary file not shown.
42
src/draw.h
Normal file
42
src/draw.h
Normal file
@ -0,0 +1,42 @@
|
||||
/*
|
||||
* wmfs2 by Martin Duquesnoy <xorg62@gmail.com> { for(i = 2011; i < 2111; ++i) ©(i); }
|
||||
* For license, see COPYING.
|
||||
*/
|
||||
|
||||
|
||||
#ifndef DRAW_H
|
||||
#define DRAW_H
|
||||
|
||||
#include <string.h>
|
||||
#include <X11/Xlib.h>
|
||||
|
||||
#include "wmfs.h"
|
||||
|
||||
#define TEXTY(t, w) ((t->font.height - t->font.de) + ((w - t->font.height) >> 1))
|
||||
#define PAD (8)
|
||||
|
||||
static inline void
|
||||
draw_text(Drawable d, struct theme *t, int x, int y, Color fg, const char *str)
|
||||
{
|
||||
XSetForeground(W->dpy, W->gc, fg);
|
||||
XmbDrawString(W->dpy, d, t->font.fontset, W->gc, x, y, str, strlen(str));
|
||||
}
|
||||
|
||||
static inline void
|
||||
draw_rect(Drawable d, struct geo g, Color bg)
|
||||
{
|
||||
XSetForeground(W->dpy, W->gc, bg);
|
||||
XFillRectangle(W->dpy, d, W->gc, g.x, g.y, g.w, g.h);
|
||||
}
|
||||
|
||||
static inline unsigned short
|
||||
draw_textw(struct theme *t, const char *str)
|
||||
{
|
||||
XRectangle r;
|
||||
|
||||
XmbTextExtents(t->font.fontset, str, strlen(str), NULL, &r);
|
||||
|
||||
return r.width;
|
||||
}
|
||||
|
||||
#endif /* DRAW_H */
|
||||
260
src/event.c
Normal file
260
src/event.c
Normal file
@ -0,0 +1,260 @@
|
||||
/*
|
||||
* wmfs2 by Martin Duquesnoy <xorg62@gmail.com> { for(i = 2011; i < 2111; ++i) ©(i); }
|
||||
* For license, see COPYING.
|
||||
*/
|
||||
|
||||
#include "event.h"
|
||||
#include "ewmh.h"
|
||||
#include "util.h"
|
||||
#include "wmfs.h"
|
||||
#include "client.h"
|
||||
#include "barwin.h"
|
||||
#include "screen.h"
|
||||
|
||||
#define EVDPY(e) (e)->xany.display
|
||||
|
||||
static void
|
||||
event_buttonpress(XEvent *e)
|
||||
{
|
||||
XButtonEvent *ev = &e->xbutton;
|
||||
struct mousebind *m;
|
||||
struct barwin *b;
|
||||
|
||||
screen_update_sel();
|
||||
|
||||
SLIST_FOREACH(b, &W->h.barwin, next)
|
||||
if(b->win == ev->window)
|
||||
{
|
||||
SLIST_FOREACH(m, &b->mousebinds, next)
|
||||
if(m->button == ev->button)
|
||||
if(!m->use_area || (m->use_area && INAREA(ev->x, ev->y, m->area)))
|
||||
if(m->func)
|
||||
m->func(m->cmd);
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
event_enternotify(XEvent *e)
|
||||
{
|
||||
XCrossingEvent *ev = &e->xcrossing;
|
||||
struct client *c;
|
||||
|
||||
if((ev->mode != NotifyNormal
|
||||
|| ev->detail == NotifyInferior
|
||||
|| ev->detail == NotifyAncestor)
|
||||
&& ev->window != W->root)
|
||||
return;
|
||||
|
||||
if((c = client_gb_win(ev->window)))
|
||||
client_focus(c);
|
||||
}
|
||||
|
||||
static void
|
||||
event_clientmessageevent(XEvent *e)
|
||||
{
|
||||
(void)e;
|
||||
/* XClientMessageEvent *ev = &e->xclient;
|
||||
client *c;*/
|
||||
}
|
||||
|
||||
static void
|
||||
event_configureevent(XEvent *e)
|
||||
{
|
||||
XConfigureRequestEvent *ev = &e->xconfigurerequest;
|
||||
XWindowChanges wc;
|
||||
struct client *c;
|
||||
|
||||
if((c = client_gb_win(ev->window)))
|
||||
{
|
||||
if(ev->value_mask & CWX)
|
||||
c->geo.x = ev->x;
|
||||
if(ev->value_mask & CWY)
|
||||
c->geo.y = ev->y;
|
||||
if(ev->value_mask & CWWidth)
|
||||
c->geo.w = ev->width;
|
||||
if(ev->value_mask & CWHeight)
|
||||
c->geo.h = ev->height;
|
||||
|
||||
client_configure(c);
|
||||
|
||||
XMoveResizeWindow(EVDPY(e), c->win, c->geo.x, c->geo.y, c->geo.w, c->geo.h);
|
||||
}
|
||||
else
|
||||
{
|
||||
wc.x = ev->x;
|
||||
wc.y = ev->y;
|
||||
wc.width = ev->width;
|
||||
wc.height = ev->height;
|
||||
wc.border_width = ev->border_width;
|
||||
wc.sibling = ev->above;
|
||||
wc.stack_mode = ev->detail;
|
||||
|
||||
XConfigureWindow(EVDPY(e), ev->window, ev->value_mask, &wc);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
event_destroynotify(XEvent *e)
|
||||
{
|
||||
XDestroyWindowEvent *ev = &e->xdestroywindow;
|
||||
struct client *c;
|
||||
|
||||
if((c = client_gb_win(ev->window)))
|
||||
client_remove(c);
|
||||
}
|
||||
|
||||
static void
|
||||
event_focusin(XEvent *e)
|
||||
{
|
||||
if(W->client && e->xfocus.window != W->client->win)
|
||||
client_focus(W->client);
|
||||
}
|
||||
|
||||
static void
|
||||
event_maprequest(XEvent *e)
|
||||
{
|
||||
XMapRequestEvent *ev = &e->xmaprequest;
|
||||
XWindowAttributes at;
|
||||
|
||||
/* Which windows to manage */
|
||||
if(!XGetWindowAttributes(EVDPY(e), ev->window, &at)
|
||||
|| at.override_redirect)
|
||||
return;
|
||||
|
||||
if(!client_gb_win(ev->window))
|
||||
client_new(ev->window, &at);
|
||||
}
|
||||
|
||||
static void
|
||||
event_mappingnotify(XEvent *e)
|
||||
{
|
||||
XMappingEvent *ev = &e->xmapping;
|
||||
XRefreshKeyboardMapping(ev);
|
||||
|
||||
if(ev->request == MappingKeyboard)
|
||||
wmfs_grab_keys();
|
||||
}
|
||||
|
||||
static void
|
||||
event_propertynotify(XEvent *e)
|
||||
{
|
||||
XPropertyEvent *ev = &e->xproperty;
|
||||
struct client *c;
|
||||
|
||||
if(ev->state == PropertyDelete)
|
||||
return;
|
||||
|
||||
if((c = client_gb_win(ev->window)))
|
||||
{
|
||||
switch(ev->atom)
|
||||
{
|
||||
case XA_WM_TRANSIENT_FOR:
|
||||
break;
|
||||
case XA_WM_NORMAL_HINTS:
|
||||
/* client_get_size_hints(c); */
|
||||
break;
|
||||
case XA_WM_HINTS:
|
||||
/*
|
||||
XWMHints *h;
|
||||
|
||||
if((h = XGetWMHints(EVDPY, c->win)) && (h->flags & XUrgencyHint) && c != sel)
|
||||
{
|
||||
client_urgent(c, True);
|
||||
XFree(h);
|
||||
}
|
||||
*/
|
||||
break;
|
||||
default:
|
||||
if(ev->atom == XA_WM_NAME || ev->atom == W->net_atom[net_wm_name])
|
||||
client_get_name(c);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
event_unmapnotify(XEvent *e)
|
||||
{
|
||||
XUnmapEvent *ev = &e->xunmap;
|
||||
struct client *c;
|
||||
|
||||
if((c = client_gb_win(ev->window)) && ev->send_event)
|
||||
client_remove(c);
|
||||
}
|
||||
|
||||
/*
|
||||
static void
|
||||
event_motionnotify(XEvent *e)
|
||||
{
|
||||
XMotionEvent *ev = &e->xmotion;
|
||||
struct client *c;
|
||||
|
||||
if((c = client_gb_win(ev->subwindow)) && c != c->tag->sel)
|
||||
client_focus(c);
|
||||
}
|
||||
*/
|
||||
|
||||
static void
|
||||
event_keypress(XEvent *e)
|
||||
{
|
||||
XKeyPressedEvent *ev = &e->xkey;
|
||||
KeySym keysym = XKeycodeToKeysym(EVDPY(e), (KeyCode)ev->keycode, 0);
|
||||
struct keybind *k;
|
||||
|
||||
screen_update_sel();
|
||||
|
||||
SLIST_FOREACH(k, &W->h.keybind, next)
|
||||
if(k->keysym == keysym && KEYPRESS_MASK(k->mod) == KEYPRESS_MASK(ev->state))
|
||||
if(k->func)
|
||||
k->func(k->cmd);
|
||||
}
|
||||
|
||||
static void
|
||||
event_expose(XEvent *e)
|
||||
{
|
||||
XExposeEvent *ev = &e->xexpose;
|
||||
struct barwin *b;
|
||||
|
||||
SLIST_FOREACH(b, &W->h.barwin, next)
|
||||
if(b->win == ev->window)
|
||||
{
|
||||
barwin_refresh(b);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
event_dummy(XEvent *e)
|
||||
{
|
||||
/* printf("%d\n", e->type);*/
|
||||
(void)e;
|
||||
}
|
||||
|
||||
void
|
||||
event_init(void)
|
||||
{
|
||||
int i = MAX_EV;
|
||||
|
||||
while(i--)
|
||||
event_handle[i] = event_dummy;
|
||||
|
||||
event_handle[ButtonPress] = event_buttonpress;
|
||||
event_handle[ClientMessage] = event_clientmessageevent;
|
||||
event_handle[ConfigureRequest] = event_configureevent;
|
||||
event_handle[DestroyNotify] = event_destroynotify;
|
||||
event_handle[EnterNotify] = event_enternotify;
|
||||
event_handle[Expose] = event_expose;
|
||||
event_handle[FocusIn] = event_focusin;
|
||||
event_handle[KeyPress] = event_keypress;
|
||||
/*event_handle[MapNotify] = event_mapnotify;*/
|
||||
event_handle[MapRequest] = event_maprequest;
|
||||
event_handle[MappingNotify] = event_mappingnotify;
|
||||
/*event_handle[MotionNotify] = event_motionnotify;*/
|
||||
event_handle[PropertyNotify] = event_propertynotify;
|
||||
/*event_handle[ReparentNotify] = event_reparentnotify;*/
|
||||
/*event_handle[SelectionClear] = event_selectionclearevent;*/
|
||||
event_handle[UnmapNotify] = event_unmapnotify;
|
||||
}
|
||||
|
||||
20
src/event.h
Normal file
20
src/event.h
Normal file
@ -0,0 +1,20 @@
|
||||
/*
|
||||
* wmfs2 by Martin Duquesnoy <xorg62@gmail.com> { for(i = 2011; i < 2111; ++i) ©(i); }
|
||||
* For license, see COPYING.
|
||||
*/
|
||||
|
||||
#ifndef EVENT_H
|
||||
#define EVENT_H
|
||||
|
||||
#include "wmfs.h"
|
||||
|
||||
#define MAX_EV 256
|
||||
|
||||
#define KEYPRESS_MASK(m) (m & ~(W->numlockmask | LockMask))
|
||||
#define EVENT_HANDLE(e) event_handle[(e)->type](e);
|
||||
|
||||
void event_init(void);
|
||||
|
||||
void (*event_handle[MAX_EV])(XEvent*);
|
||||
|
||||
#endif /* EVENT_H */
|
||||
BIN
src/event.o
Normal file
BIN
src/event.o
Normal file
Binary file not shown.
106
src/ewmh.c
Normal file
106
src/ewmh.c
Normal file
@ -0,0 +1,106 @@
|
||||
/*
|
||||
* wmfs2 by Martin Duquesnoy <xorg62@gmail.com> { for(i = 2011; i < 2111; ++i) ©(i); }
|
||||
* For license, see COPYING.
|
||||
*/
|
||||
|
||||
#include <X11/Xatom.h>
|
||||
#include <X11/Xutil.h>
|
||||
|
||||
#include "ewmh.h"
|
||||
#include "util.h"
|
||||
|
||||
void
|
||||
ewmh_init(void)
|
||||
{
|
||||
int b = 1;
|
||||
|
||||
W->net_atom = xcalloc(net_last, sizeof(Atom));
|
||||
|
||||
/* EWMH hints */
|
||||
W->net_atom[wm_state] = ATOM("WM_STATE");
|
||||
W->net_atom[net_supported] = ATOM("_NET_SUPPORTED");
|
||||
W->net_atom[net_client_list] = ATOM("_NET_CLIENT_LIST");
|
||||
W->net_atom[net_frame_extents] = ATOM("_NET_FRAME_EXTENTS");
|
||||
W->net_atom[net_number_of_desktops] = ATOM("_NET_NUMBER_OF_DESKTOPS");
|
||||
W->net_atom[net_current_desktop] = ATOM("_NET_CURRENT_DESKTOP");
|
||||
W->net_atom[net_desktop_names] = ATOM("_NET_DESKTOP_NAMES");
|
||||
W->net_atom[net_desktop_geometry] = ATOM("_NET_DESKTOP_GEOMETRY");
|
||||
W->net_atom[net_active_window] = ATOM("_NET_ACTIVE_WINDOW");
|
||||
W->net_atom[net_close_window] = ATOM("_NET_CLOSE_WINDOW");
|
||||
W->net_atom[net_wm_name] = ATOM("_NET_WM_NAME");
|
||||
W->net_atom[net_wm_pid] = ATOM("_NET_WM_PID");
|
||||
W->net_atom[net_wm_desktop] = ATOM("_NET_WM_DESKTOP");
|
||||
W->net_atom[net_showing_desktop] = ATOM("_NET_SHOWING_DESKTOP");
|
||||
W->net_atom[net_wm_icon_name] = ATOM("_NET_WM_ICON_NAME");
|
||||
W->net_atom[net_wm_window_type] = ATOM("_NET_WM_WINDOW_TYPE");
|
||||
W->net_atom[net_supporting_wm_check] = ATOM("_NET_SUPPORTING_WM_CHECK");
|
||||
W->net_atom[net_wm_window_opacity] = ATOM("_NET_WM_WINDOW_OPACITY");
|
||||
W->net_atom[net_wm_window_type_normal] = ATOM("_NET_WM_WINDOW_TYPE_NORMAL");
|
||||
W->net_atom[net_wm_window_type_dock] = ATOM("_NET_WM_WINDOW_TYPE_DOCK");
|
||||
W->net_atom[net_wm_window_type_splash] = ATOM("_NET_WM_WINDOW_TYPE_SPLASH");
|
||||
W->net_atom[net_wm_window_type_dialog] = ATOM("_NET_WM_WINDOW_TYPE_DIALOG");
|
||||
W->net_atom[net_wm_icon] = ATOM("_NET_WM_ICON");
|
||||
W->net_atom[net_wm_state] = ATOM("_NET_WM_STATE");
|
||||
W->net_atom[net_wm_state_fullscreen] = ATOM("_NET_WM_STATE_FULLSCREEN");
|
||||
W->net_atom[net_wm_state_sticky] = ATOM("_NET_WM_STATE_STICKY");
|
||||
W->net_atom[net_wm_state_demands_attention] = ATOM("_NET_WM_STATE_DEMANDS_ATTENTION");
|
||||
W->net_atom[net_wm_system_tray_opcode] = ATOM("_NET_SYSTEM_TRAY_OPCODE");
|
||||
W->net_atom[net_system_tray_message_data] = ATOM("_NET_SYSTEM_TRAY_MESSAGE_DATA");
|
||||
W->net_atom[net_system_tray_visual] = ATOM("_NET_SYSTEM_TRAY_VISUAL");
|
||||
W->net_atom[net_system_tray_orientation] = ATOM("_NET_SYSTEM_TRAY_ORIENTATION");
|
||||
W->net_atom[xembed] = ATOM("_XEMBED");
|
||||
W->net_atom[xembedinfo] = ATOM("_XEMBED_INFO");
|
||||
W->net_atom[manager] = ATOM("MANAGER");
|
||||
W->net_atom[utf8_string] = ATOM("UTF8_STRING");
|
||||
|
||||
/* WMFS hints */
|
||||
W->net_atom[wmfs_running] = ATOM("_WMFS_RUNNING");
|
||||
W->net_atom[wmfs_update_hints] = ATOM("_WMFS_UPDATE_HINTS");
|
||||
W->net_atom[wmfs_set_screen] = ATOM("_WMFS_SET_SCREEN");
|
||||
W->net_atom[wmfs_screen_count] = ATOM("_WMFS_SCREEN_COUNT");
|
||||
W->net_atom[wmfs_current_tag] = ATOM("_WMFS_CURRENT_TAG");
|
||||
W->net_atom[wmfs_tag_list] = ATOM("_WMFS_TAG_LIST");
|
||||
W->net_atom[wmfs_current_screen] = ATOM("_WMFS_CURRENT_SCREEN");
|
||||
W->net_atom[wmfs_current_layout] = ATOM("_WMFS_CURRENT_LAYOUT");
|
||||
W->net_atom[wmfs_mwfact] = ATOM("_WMFS_MWFACT");
|
||||
W->net_atom[wmfs_nmaster] = ATOM("_WMFS_NMASTER");
|
||||
W->net_atom[wmfs_function] = ATOM("_WMFS_FUNCTION");
|
||||
W->net_atom[wmfs_cmd] = ATOM("_WMFS_CMD");
|
||||
W->net_atom[wmfs_font] = ATOM("_WMFS_FONT");
|
||||
|
||||
XChangeProperty(W->dpy, W->root, W->net_atom[net_supported], XA_ATOM, 32,
|
||||
PropModeReplace, (unsigned char*)W->net_atom, net_last);
|
||||
|
||||
XChangeProperty(W->dpy, W->root, W->net_atom[wmfs_running], XA_CARDINAL, 32,
|
||||
PropModeReplace, (unsigned char*)&b, 1);
|
||||
|
||||
/* Set _NET_SUPPORTING_WM_CHECK */
|
||||
XChangeProperty(W->dpy, W->root, W->net_atom[net_supporting_wm_check], XA_WINDOW, 32,
|
||||
PropModeReplace, (unsigned char*)&W->root, 1);
|
||||
/*
|
||||
XChangeProperty(W->dpy, W->root, W->net_atom[net_wm_name], W->net_atom[utf8_string], 8,
|
||||
PropModeReplace, (unsigned char*)&rootn, strlen(rootn));
|
||||
|
||||
XChangeProperty(W->dpy, W->root, ATOM("WM_CLASS"), XA_STRING, 8,
|
||||
PropModeReplace, (unsigned char*)&class, strlen(class));
|
||||
|
||||
* Set _NET_WM_PID
|
||||
XChangeProperty(W->dpy, W->root, W->net_atom[net_wm_pid], XA_CARDINAL, 32,
|
||||
PropModeReplace, (unsigned char*)&pid, 1);
|
||||
|
||||
* Set _NET_SHOWING_DESKTOP
|
||||
XChangeProperty(W->dpy, W->root, W->net_atom[net_showing_desktop], XA_CARDINAL, 32,
|
||||
PropModeReplace, (unsigned char*)&showing_desk, 1);
|
||||
*/
|
||||
|
||||
}
|
||||
|
||||
void
|
||||
ewmh_set_wm_state(Window w, int state)
|
||||
{
|
||||
unsigned char d[] = { state, None };
|
||||
|
||||
XChangeProperty(W->dpy, w, W->net_atom[wm_state],
|
||||
W->net_atom[wm_state], 32, PropModeReplace, d, 2);
|
||||
}
|
||||
|
||||
74
src/ewmh.h
Normal file
74
src/ewmh.h
Normal file
@ -0,0 +1,74 @@
|
||||
/*
|
||||
* wmfs2 by Martin Duquesnoy <xorg62@gmail.com> { for(i = 2011; i < 2111; ++i) ©(i); }
|
||||
* For license, see COPYING.
|
||||
*/
|
||||
|
||||
|
||||
#ifndef EWMH_H
|
||||
#define EWMH_H
|
||||
|
||||
#include "wmfs.h"
|
||||
|
||||
/* Ewmh hints list */
|
||||
enum
|
||||
{
|
||||
/* ICCCM */
|
||||
wm_state,
|
||||
/* EWMH */
|
||||
net_supported,
|
||||
net_wm_name,
|
||||
net_client_list,
|
||||
net_frame_extents,
|
||||
net_number_of_desktops,
|
||||
net_current_desktop,
|
||||
net_desktop_names,
|
||||
net_desktop_geometry,
|
||||
net_active_window,
|
||||
net_close_window,
|
||||
net_wm_icon_name,
|
||||
net_wm_window_type,
|
||||
net_wm_pid,
|
||||
net_showing_desktop,
|
||||
net_supporting_wm_check,
|
||||
net_wm_window_opacity,
|
||||
net_wm_window_type_normal,
|
||||
net_wm_window_type_dock,
|
||||
net_wm_window_type_splash,
|
||||
net_wm_window_type_dialog,
|
||||
net_wm_desktop,
|
||||
net_wm_icon,
|
||||
net_wm_state,
|
||||
net_wm_state_fullscreen,
|
||||
net_wm_state_sticky,
|
||||
net_wm_state_demands_attention,
|
||||
net_wm_system_tray_opcode,
|
||||
net_system_tray_message_data,
|
||||
net_system_tray_s,
|
||||
net_system_tray_visual,
|
||||
net_system_tray_orientation,
|
||||
xembed,
|
||||
xembedinfo,
|
||||
manager,
|
||||
utf8_string,
|
||||
/* WMFS HINTS */
|
||||
wmfs_running,
|
||||
wmfs_update_hints,
|
||||
wmfs_current_tag,
|
||||
wmfs_current_screen,
|
||||
wmfs_current_layout,
|
||||
wmfs_tag_list,
|
||||
wmfs_mwfact,
|
||||
wmfs_nmaster,
|
||||
wmfs_set_screen,
|
||||
wmfs_screen_count,
|
||||
wmfs_function,
|
||||
wmfs_cmd,
|
||||
wmfs_font,
|
||||
wmfs_statustext,
|
||||
net_last
|
||||
};
|
||||
|
||||
void ewmh_init(void);
|
||||
void ewmh_set_wm_state(Window w, int state);
|
||||
|
||||
#endif /* EWMH_H */
|
||||
BIN
src/ewmh.o
Normal file
BIN
src/ewmh.o
Normal file
Binary file not shown.
246
src/infobar.c
Normal file
246
src/infobar.c
Normal file
@ -0,0 +1,246 @@
|
||||
/*
|
||||
* wmfs2 by Martin Duquesnoy <xorg62@gmail.com> { for(i = 2011; i < 2111; ++i) ©(i); }
|
||||
* For license, see COPYING.
|
||||
*/
|
||||
|
||||
#include "wmfs.h"
|
||||
#include "draw.h"
|
||||
#include "infobar.h"
|
||||
#include "barwin.h"
|
||||
#include "util.h"
|
||||
#include "tag.h"
|
||||
|
||||
static void infobar_elem_tag_init(struct element *e);
|
||||
static void infobar_elem_tag_update(struct element *e);
|
||||
|
||||
const struct elem_funcs
|
||||
{
|
||||
char c;
|
||||
void (*func_init)(struct element *e);
|
||||
void (*func_update)(struct element *e);
|
||||
} elem_funcs[] =
|
||||
{
|
||||
{ 't', infobar_elem_tag_init, infobar_elem_tag_update },
|
||||
|
||||
/* { 'l', infobar_elem_layout_init, infobar_elem_layout_update },
|
||||
{ 's', infobar_elem_selbar_init, infobar_elem_selbar_update },
|
||||
{ 'S', infobar_elem_status_init, infobar_elem_status_update },*/
|
||||
|
||||
{ '\0', NULL, NULL }
|
||||
};
|
||||
|
||||
static void
|
||||
infobar_elem_tag_init(struct element *e)
|
||||
{
|
||||
struct tag *t;
|
||||
struct barwin *b, *prev = NULL;
|
||||
struct geo g = { 0, 0, 0, 0 };
|
||||
int s, j;
|
||||
|
||||
infobar_elem_placement(e);
|
||||
|
||||
j = e->geo.x;
|
||||
e->geo.h -= (e->infobar->theme->tags_border_width << 1);
|
||||
|
||||
TAILQ_FOREACH(t, &e->infobar->screen->tags, next)
|
||||
{
|
||||
s = draw_textw(e->infobar->theme, t->name) + PAD;
|
||||
|
||||
/* Init barwin */
|
||||
b = barwin_new(e->infobar->bar->win, j, 0, s, e->geo.h, 0, 0, false);
|
||||
|
||||
/* Set border */
|
||||
if(e->infobar->theme->tags_border_width)
|
||||
{
|
||||
XSetWindowBorder(W->dpy, b->win, e->infobar->theme->tags_border_col);
|
||||
XSetWindowBorderWidth(W->dpy, b->win, e->infobar->theme->tags_border_width);
|
||||
}
|
||||
|
||||
b->ptr = (void*)t;
|
||||
barwin_map(b);
|
||||
|
||||
/* TODO: refer to tag element configuration */
|
||||
barwin_mousebind_new(b, Button1, false, g, uicb_tag_set_with_name, (Uicb)t->name);
|
||||
barwin_mousebind_new(b, Button4, false, g, uicb_tag_next, NULL);
|
||||
barwin_mousebind_new(b, Button5, false, g, uicb_tag_prev, NULL);
|
||||
|
||||
/* insert_tail with SLIST */
|
||||
if(SLIST_EMPTY(&e->bars))
|
||||
SLIST_INSERT_HEAD(&e->bars, b, enext);
|
||||
else
|
||||
SLIST_INSERT_AFTER(prev, b, enext);
|
||||
|
||||
prev = b;
|
||||
j += s;
|
||||
}
|
||||
|
||||
e->infobar->screen->elemupdate |= FLAGINT(ElemTag);
|
||||
|
||||
e->geo.w = j;
|
||||
}
|
||||
|
||||
static void
|
||||
infobar_elem_tag_update(struct element *e)
|
||||
{
|
||||
struct tag *t, *sel = e->infobar->screen->seltag;
|
||||
struct barwin *b;
|
||||
|
||||
SLIST_FOREACH(b, &e->bars, enext)
|
||||
{
|
||||
t = (struct tag*)b->ptr;
|
||||
|
||||
/* Selected */
|
||||
/* TODO: color from conf */
|
||||
if(t == sel)
|
||||
{
|
||||
b->fg = e->infobar->theme->tags_s.fg;
|
||||
b->bg = e->infobar->theme->tags_s.bg;
|
||||
}
|
||||
else
|
||||
{
|
||||
b->fg = e->infobar->theme->tags_n.fg;
|
||||
b->bg = e->infobar->theme->tags_n.bg;
|
||||
}
|
||||
|
||||
barwin_refresh_color(b);
|
||||
|
||||
draw_text(b->dr, e->infobar->theme, (PAD >> 1),
|
||||
TEXTY(e->infobar->theme, e->geo.h), b->fg, t->name);
|
||||
|
||||
barwin_refresh(b);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
infobar_elem_init(struct infobar *i)
|
||||
{
|
||||
struct element *e;
|
||||
int n, j;
|
||||
|
||||
TAILQ_INIT(&i->elements);
|
||||
|
||||
for(n = 0; n < (int)strlen(i->elemorder); ++n)
|
||||
{
|
||||
for(j = 0; j < (int)LEN(elem_funcs); ++j)
|
||||
if(elem_funcs[j].c == i->elemorder[n])
|
||||
{
|
||||
e = xcalloc(1, sizeof(struct element));
|
||||
|
||||
SLIST_INIT(&e->bars);
|
||||
|
||||
e->infobar = i;
|
||||
e->type = j;
|
||||
e->func_init = elem_funcs[j].func_init;
|
||||
e->func_update = elem_funcs[j].func_update;
|
||||
|
||||
TAILQ_INSERT_TAIL(&i->elements, e, next);
|
||||
|
||||
e->func_init(e);
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
infobar_elem_update(struct infobar *i)
|
||||
{
|
||||
struct element *e;
|
||||
|
||||
TAILQ_FOREACH(e, &i->elements, next)
|
||||
if(i->screen->elemupdate & FLAGINT(e->type))
|
||||
e->func_update(e);
|
||||
}
|
||||
|
||||
void
|
||||
infobar_elem_remove(struct element *e)
|
||||
{
|
||||
struct barwin *b;
|
||||
|
||||
TAILQ_REMOVE(&e->infobar->elements, e, next);
|
||||
|
||||
while(!SLIST_EMPTY(&e->bars))
|
||||
{
|
||||
b = SLIST_FIRST(&e->bars);
|
||||
SLIST_REMOVE_HEAD(&e->bars, enext);
|
||||
barwin_remove(b);
|
||||
}
|
||||
}
|
||||
|
||||
struct infobar*
|
||||
infobar_new(struct screen *s, struct theme *theme, Barpos pos, const char *elem)
|
||||
{
|
||||
bool map;
|
||||
struct infobar *i = (struct infobar*)xcalloc(1, sizeof(struct infobar));
|
||||
|
||||
i->screen = s;
|
||||
i->theme = theme;
|
||||
i->elemorder = xstrdup(elem);
|
||||
|
||||
map = infobar_placement(i, pos);
|
||||
|
||||
/* struct barwin create */
|
||||
i->bar = barwin_new(W->root, i->geo.x, i->geo.y, i->geo.w, i->geo.h,
|
||||
theme->bars.fg, theme->bars.bg, false);
|
||||
|
||||
SLIST_INSERT_HEAD(&s->infobars, i, next);
|
||||
|
||||
/* struct elements */
|
||||
infobar_elem_init(i);
|
||||
|
||||
/* Render, only if pos is Top or Bottom */
|
||||
if(!map)
|
||||
return i;
|
||||
|
||||
barwin_map(i->bar);
|
||||
barwin_map_subwin(i->bar);
|
||||
barwin_refresh_color(i->bar);
|
||||
infobar_refresh(i);
|
||||
|
||||
return i;
|
||||
}
|
||||
|
||||
void
|
||||
infobar_refresh(struct infobar *i)
|
||||
{
|
||||
infobar_elem_update(i);
|
||||
|
||||
barwin_refresh(i->bar);
|
||||
}
|
||||
|
||||
void
|
||||
infobar_remove(struct infobar *i)
|
||||
{
|
||||
struct element *e;
|
||||
|
||||
free(i->elemorder);
|
||||
|
||||
TAILQ_FOREACH(e, &i->elements, next)
|
||||
infobar_elem_remove(e);
|
||||
|
||||
barwin_remove(i->bar);
|
||||
|
||||
SLIST_REMOVE(&i->screen->infobars, i, infobar, next);
|
||||
|
||||
free(i);
|
||||
}
|
||||
|
||||
void
|
||||
infobar_free(struct screen *s)
|
||||
{
|
||||
struct infobar *i;
|
||||
|
||||
while(!SLIST_EMPTY(&s->infobars))
|
||||
{
|
||||
i = SLIST_FIRST(&s->infobars);
|
||||
|
||||
/* SLIST_REMOVE is done by infobar_remove */
|
||||
infobar_remove(i);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
74
src/infobar.h
Normal file
74
src/infobar.h
Normal file
@ -0,0 +1,74 @@
|
||||
/*
|
||||
* wmfs2 by Martin Duquesnoy <xorg62@gmail.com> { for(i = 2011; i < 2111; ++i) ©(i); }
|
||||
* For license, see COPYING.
|
||||
*/
|
||||
|
||||
#ifndef INFOBAR_H
|
||||
#define INFOBAR_H
|
||||
|
||||
#include "wmfs.h"
|
||||
#include "util.h"
|
||||
#include "draw.h"
|
||||
#include "tag.h"
|
||||
|
||||
enum { ElemTag = 0, ElemLayout, ElemSelbar, ElemStatus, ElemCustom, ElemLast };
|
||||
|
||||
struct infobar *infobar_new(struct screen *s, struct theme *theme, Barpos pos, const char *elem);
|
||||
void infobar_elem_update(struct infobar *i);
|
||||
void infobar_refresh(struct infobar *i);
|
||||
void infobar_remove(struct infobar *i);
|
||||
void infobar_free(struct screen *s);
|
||||
|
||||
/* Basic placement of elements */
|
||||
static inline void
|
||||
infobar_elem_placement(struct element *e)
|
||||
{
|
||||
struct element *p = TAILQ_PREV(e, esub, next);
|
||||
|
||||
e->geo.y = e->geo.w = 0;
|
||||
e->geo.h = e->infobar->geo.h;
|
||||
e->geo.x = (p ? p->geo.x + p->geo.w + PAD : 0);
|
||||
}
|
||||
|
||||
/* Bars placement management and usable space management */
|
||||
static inline bool
|
||||
infobar_placement(struct infobar *i, Barpos p)
|
||||
{
|
||||
i->pos = p;
|
||||
i->geo = i->screen->ugeo;
|
||||
i->geo.h = i->theme->bars_width;
|
||||
|
||||
switch(p)
|
||||
{
|
||||
case BarTop:
|
||||
i->screen->ugeo.y += i->geo.h;
|
||||
i->screen->ugeo.h -= i->geo.h;
|
||||
break;
|
||||
case BarBottom:
|
||||
i->geo.y = (i->screen->ugeo.y + i->screen->ugeo.h) - i->geo.h;
|
||||
i->screen->ugeo.h -= i->geo.h;
|
||||
break;
|
||||
default:
|
||||
case BarHide:
|
||||
return false;
|
||||
}
|
||||
|
||||
tag_update_frame_geo(i->screen);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static inline void
|
||||
infobar_elem_screen_update(struct screen *s, int addf)
|
||||
{
|
||||
struct infobar *i;
|
||||
|
||||
s->elemupdate |= FLAGINT(addf);
|
||||
|
||||
SLIST_FOREACH(i, &s->infobars, next)
|
||||
infobar_elem_update(i);
|
||||
|
||||
s->elemupdate &= ~FLAGINT(ElemTag);
|
||||
}
|
||||
|
||||
#endif /* INFOBAR_H */
|
||||
BIN
src/infobar.o
Normal file
BIN
src/infobar.o
Normal file
Binary file not shown.
316
src/layout.c
Normal file
316
src/layout.c
Normal file
@ -0,0 +1,316 @@
|
||||
/*
|
||||
* wmfs2 by Martin Duquesnoy <xorg62@gmail.com> { for(i = 2011; i < 2111; ++i) ©(i); }
|
||||
* For license, see COPYING.
|
||||
*/
|
||||
|
||||
#include "layout.h"
|
||||
#include "config.h"
|
||||
#include "client.h"
|
||||
#include "util.h"
|
||||
|
||||
static struct geo
|
||||
layout_split(struct client *c, bool vertical)
|
||||
{
|
||||
struct geo og, geo;
|
||||
|
||||
geo = og = c->geo;
|
||||
|
||||
if(vertical)
|
||||
{
|
||||
c->geo.w >>= 1;
|
||||
geo.x = c->geo.x + c->geo.w;
|
||||
geo.w >>= 1;
|
||||
|
||||
/* Remainder */
|
||||
geo.w += (og.x + og.w) - (geo.x + geo.w);
|
||||
}
|
||||
else
|
||||
{
|
||||
c->geo.h >>= 1;
|
||||
geo.y = c->geo.y + c->geo.h;
|
||||
geo.h >>= 1;
|
||||
|
||||
/* Remainder */
|
||||
geo.h += (og.y + og.h) - (geo.y + geo.h);
|
||||
}
|
||||
|
||||
client_moveresize(c, c->geo);
|
||||
|
||||
return geo;
|
||||
}
|
||||
|
||||
static inline void
|
||||
layout_split_arrange_size(struct geo g, struct client *c, Position p)
|
||||
{
|
||||
if(LDIR(p))
|
||||
{
|
||||
c->geo.w += g.w;
|
||||
|
||||
if(p == Right)
|
||||
c->geo.x = g.x;
|
||||
}
|
||||
else
|
||||
{
|
||||
c->geo.h += g.h;
|
||||
|
||||
if(p == Bottom)
|
||||
c->geo.y = g.y;
|
||||
}
|
||||
|
||||
client_moveresize(c, c->geo);
|
||||
}
|
||||
|
||||
static inline bool
|
||||
layout_split_check_row_dir(struct client *c, struct client *g, Position p)
|
||||
{
|
||||
struct geo cgeo = c->geo;
|
||||
struct client *cc;
|
||||
int s = 0, cs = (LDIR(p) ? g->geo.h : g->geo.w);
|
||||
|
||||
SLIST_FOREACH(cc, &c->tag->clients, tnext)
|
||||
if(GEO_PARENTROW(cgeo, cc->geo, RPOS(p))
|
||||
&& GEO_CHECK_ROW(cc->geo, g->geo, p))
|
||||
{
|
||||
s += (LDIR(p) ? cc->geo.h : cc->geo.w);
|
||||
|
||||
if(s == cs)
|
||||
return true;
|
||||
if(s > cs)
|
||||
return false;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/* Use ghost client properties to fix holes in tile
|
||||
*
|
||||
* ~ .--. ~ ~
|
||||
*_____ ~ /xx \ ~ ~
|
||||
* |>>| ~\O _ (____ ~
|
||||
* | |__.| .--'-==~ ~
|
||||
* |>>'---\ '. ~ , ~
|
||||
*__|__| '. '-.___.-'/ ~
|
||||
* '-.__ _.' ~
|
||||
* ````` ~
|
||||
*/
|
||||
void
|
||||
layout_split_arrange_closed(struct client *ghost)
|
||||
{
|
||||
struct client *c, *cc;
|
||||
struct geo g;
|
||||
bool b = false;
|
||||
Position p;
|
||||
|
||||
|
||||
/* Search for single parent for easy resize
|
||||
* Example case:
|
||||
* ___________ ___________
|
||||
* | | B | -> -> | | |
|
||||
* | A |_____| -> Close -> | A | B |
|
||||
* | | C | -> C -> | |v v v|
|
||||
* |_____|_____| -> -> |_____|_____|
|
||||
*/
|
||||
for(p = Right; p < Center; ++p) /* Check every direction */
|
||||
{
|
||||
if((c = client_next_with_pos(ghost, p)))
|
||||
if(GEO_CHECK2(ghost->geo, c->geo, p))
|
||||
{
|
||||
layout_split_arrange_size(ghost->geo, c, p);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
/* Check row parents for full resize
|
||||
* Example case:
|
||||
* ___________ ___________
|
||||
* | | B | -> -> | << B |
|
||||
* | A |_____| -> Close -> |___________|
|
||||
* | | C | -> A -> | << C |
|
||||
* |_____|_____| -> -> |___________|
|
||||
*/
|
||||
for(p = Right; p < Center && !b; ++p)
|
||||
{
|
||||
if((c = client_next_with_pos(ghost, p))
|
||||
&& layout_split_check_row_dir(c, ghost, p))
|
||||
{
|
||||
g = c->geo;
|
||||
SLIST_FOREACH(cc, &c->tag->clients, tnext)
|
||||
if(GEO_PARENTROW(g, cc->geo, RPOS(p))
|
||||
&& GEO_CHECK_ROW(cc->geo, ghost->geo, p))
|
||||
{
|
||||
layout_split_arrange_size(ghost->geo, cc, p);
|
||||
b = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Integrate a client in split layout: split sc and fill c in new geo */
|
||||
void
|
||||
layout_split_integrate(struct client *c, struct client *sc)
|
||||
{
|
||||
struct geo g;
|
||||
|
||||
/* No sc */
|
||||
if(!sc || sc == c || sc->tag != c->tag)
|
||||
{
|
||||
/*
|
||||
* Not even a first client in list, then
|
||||
* maximize the lonely client
|
||||
*/
|
||||
if(!(sc = SLIST_FIRST(&c->tag->clients)))
|
||||
{
|
||||
client_maximize(c);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
g = layout_split(sc, (sc->geo.h < sc->geo.w));
|
||||
client_moveresize(c, g);
|
||||
}
|
||||
|
||||
/* Arrange inter-clients holes:
|
||||
* ___________ ___________
|
||||
* | || | -> | | |
|
||||
* | A || B | -> | A >| B |
|
||||
* | || | -> | >| |
|
||||
* |_____||____| -> |______|____|
|
||||
* ^ void
|
||||
*
|
||||
* and client-screen edge holes
|
||||
* ___________ ___________
|
||||
* | | || -> | | |
|
||||
* | A | B || -> | A | B >|
|
||||
* | | || -> | | >|
|
||||
* |_____|----'| -> |_____|__v__|
|
||||
* ^^^ void
|
||||
*/
|
||||
static inline void
|
||||
layout_fix_hole(struct client *c)
|
||||
{
|
||||
struct client *cr = client_next_with_pos(c, Right);
|
||||
struct client *cb = client_next_with_pos(c, Bottom);
|
||||
|
||||
c->geo.w += (cr ? cr->geo.x : c->screen->ugeo.w) - (c->geo.x + c->geo.w);
|
||||
c->geo.h += (cb ? cb->geo.y : c->screen->ugeo.h) - (c->geo.y + c->geo.h);
|
||||
|
||||
client_moveresize(c, c->geo);
|
||||
}
|
||||
|
||||
/* Layout rotation: Rotate 90° all client to right or left.
|
||||
* Avoid if(left) condition in layout_rotate loop; use func ptr
|
||||
*
|
||||
* Left rotation
|
||||
* ____________ ____________
|
||||
* | | B | -> | | A |
|
||||
* | A |_______| -> |__|_________|
|
||||
* |____| C | D | -> |_____| B |
|
||||
* |____|___|___| -> |_____|______|
|
||||
*
|
||||
* Right rotation
|
||||
* ____________ ____________
|
||||
* | | B | -> | B |_____|
|
||||
* | A |_______| -> |______|_____|
|
||||
* |____| C | D | -> | A | |
|
||||
* |____|___|___| -> |_________|__|
|
||||
*
|
||||
*/
|
||||
|
||||
static inline void
|
||||
_pos_rotate_left(struct geo *g, struct geo ug, struct geo og)
|
||||
{
|
||||
g->x = (ug.h - (og.y + og.h));
|
||||
g->y = og.x;
|
||||
}
|
||||
|
||||
static inline void
|
||||
_pos_rotate_right(struct geo *g, struct geo ug, struct geo og)
|
||||
{
|
||||
g->x = og.y;
|
||||
g->y = (ug.w - (og.x + og.w));
|
||||
}
|
||||
|
||||
static void
|
||||
layout_rotate(struct tag *t, bool left)
|
||||
{
|
||||
struct client *c;
|
||||
struct geo g;
|
||||
float f1 = (float)t->screen->ugeo.w / (float)t->screen->ugeo.h;
|
||||
float f2 = 1 / f1;
|
||||
void (*pos)(struct geo*, struct geo, struct geo) =
|
||||
(left ? _pos_rotate_left : _pos_rotate_right);
|
||||
|
||||
SLIST_FOREACH(c, &t->clients, tnext)
|
||||
{
|
||||
pos(&g, t->screen->ugeo, c->geo);
|
||||
|
||||
g.x *= f1;
|
||||
g.y *= f2;
|
||||
g.w = c->geo.h * f1;
|
||||
g.h = c->geo.w * f2;
|
||||
|
||||
client_moveresize(c, g);
|
||||
}
|
||||
|
||||
/* Rotate sometimes do not set back perfect size.. */
|
||||
SLIST_FOREACH(c, &t->clients, tnext)
|
||||
layout_fix_hole(c);
|
||||
}
|
||||
|
||||
void
|
||||
uicb_layout_rotate_left(Uicb cmd)
|
||||
{
|
||||
(void)cmd;
|
||||
layout_rotate(W->screen->seltag, true);
|
||||
}
|
||||
|
||||
void
|
||||
uicb_layout_rotate_right(Uicb cmd)
|
||||
{
|
||||
(void)cmd;
|
||||
layout_rotate(W->screen->seltag, false);
|
||||
}
|
||||
|
||||
/*
|
||||
* Really simple functions, don't need static no-uicb backend
|
||||
* so we avoid the use of if(vertical) .. else
|
||||
*
|
||||
* Vertical mirror
|
||||
* ____________ ____________
|
||||
* | | B | -> | B | |
|
||||
* | A |_______| -> |_______| A |
|
||||
* | | C | D | -> | D | C | |
|
||||
* |____|___|___| -> |___|___|____|
|
||||
*
|
||||
* Horizontal mirror
|
||||
* ____________ ____________
|
||||
* | | B | -> | | C | D |
|
||||
* | A |_______| -> | A |___|___|
|
||||
* | | C | D | -> | | B |
|
||||
* |____|___|___| -> |____|_______|
|
||||
*/
|
||||
void
|
||||
uicb_layout_vmirror(Uicb cmd)
|
||||
{
|
||||
(void)cmd;
|
||||
struct client *c;
|
||||
|
||||
SLIST_FOREACH(c, &W->screen->seltag->clients, tnext)
|
||||
{
|
||||
c->geo.x = W->screen->ugeo.w - (c->geo.x + c->geo.w);
|
||||
client_moveresize(c, c->geo);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
uicb_layout_hmirror(Uicb cmd)
|
||||
{
|
||||
(void)cmd;
|
||||
struct client *c;
|
||||
|
||||
SLIST_FOREACH(c, &W->screen->seltag->clients, tnext)
|
||||
{
|
||||
c->geo.y = W->screen->ugeo.h - (c->geo.y + c->geo.h);
|
||||
client_moveresize(c, c->geo);
|
||||
}
|
||||
}
|
||||
40
src/layout.h
Normal file
40
src/layout.h
Normal file
@ -0,0 +1,40 @@
|
||||
/*
|
||||
* wmfs2 by Martin Duquesnoy <xorg62@gmail.com> { for(i = 2011; i < 2111; ++i) ©(i); }
|
||||
* For license, see COPYING.
|
||||
*/
|
||||
|
||||
#ifndef LAYOUT_H
|
||||
#define LAYOUT_H
|
||||
|
||||
#include "wmfs.h"
|
||||
|
||||
/* Check lateral direction (if p is Right or Left) */
|
||||
#define LDIR(P) (P < Top)
|
||||
|
||||
/* Reverse position */
|
||||
#define RPOS(P) (P & 1 ? P - 1 : P + 1)
|
||||
|
||||
/* geo comparaison */
|
||||
#define GEO_CHECK2(g1, g2, p) (LDIR(p) ? ((g1).h == (g2).h) : ((g1).w == (g2).w))
|
||||
#define GEO_CHECK_ROW(g1, g2, p) \
|
||||
(LDIR(p) \
|
||||
? ((g1).y >= (g2).y && ((g1).y + (g1).h) <= ((g2).y + (g2).h)) \
|
||||
: ((g1).x >= (g2).x && ((g1).x + (g1).w) <= ((g2).x + (g2).w)))
|
||||
#define GEO_PARENTROW(g1, g2, p) \
|
||||
(LDIR(p) \
|
||||
? (p == Left ? ((g1).x == (g2).x) : ((g1).x + (g1).w == (g2).x + (g2).w)) \
|
||||
: (p == Top ? ((g1).y == (g2).y) : ((g1).y + (g1).h == (g2).y + (g2).h)))
|
||||
|
||||
|
||||
/* Debug */
|
||||
#define DGEO(G) printf(": %d %d %d %d\n", G.x, G.y, G.w, G.h)
|
||||
|
||||
void layout_split_integrate(struct client *c, struct client *sc);
|
||||
void layout_split_arrange_closed(struct client *ghost);
|
||||
void uicb_layout_vmirror(Uicb cmd);
|
||||
void uicb_layout_hmirror(Uicb cmd);
|
||||
void uicb_layout_rotate_left(Uicb cmd);
|
||||
void uicb_layout_rotate_right(Uicb cmd);
|
||||
|
||||
#endif /* LAYOUT_H */
|
||||
|
||||
BIN
src/layout.o
Normal file
BIN
src/layout.o
Normal file
Binary file not shown.
693
src/parse.c
Normal file
693
src/parse.c
Normal file
@ -0,0 +1,693 @@
|
||||
/*
|
||||
* Copyright (c) 2010 Philippe Pepiot <phil@philpep.org>
|
||||
* Copyright (c) 2011 Martin Duquesnoy <xorg62@gmail.com>
|
||||
*
|
||||
* Permission to use, copy, modify, and distribute this software for any
|
||||
* purpose with or without fee is hereby granted, provided that the above
|
||||
* copyright notice and this permission notice appear in all copies.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*/
|
||||
|
||||
#ifndef _GNU_SOURCE
|
||||
#define _GNU_SOURCE
|
||||
#endif
|
||||
#ifndef _BSD_SOURCE
|
||||
#define _BSD_SOURCE
|
||||
#endif
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdarg.h>
|
||||
#include <limits.h>
|
||||
#include <unistd.h>
|
||||
#include <fcntl.h>
|
||||
#include <libgen.h>
|
||||
#include <pwd.h>
|
||||
#include <sys/stat.h>
|
||||
#include <sys/param.h>
|
||||
#include <err.h>
|
||||
|
||||
#include "parse.h"
|
||||
#include "util.h"
|
||||
|
||||
extern char *__progname;
|
||||
|
||||
enum keyword_t { SEC_START, SEC_END, INCLUDE, WORD, EQUAL, LIST_START, LIST_END, NONE };
|
||||
|
||||
#ifdef DEBUG
|
||||
static const struct
|
||||
{
|
||||
const char *name;
|
||||
enum keyword_t type;
|
||||
} kw_t_name[] =
|
||||
{
|
||||
{"SEC_START", SEC_START},
|
||||
{"SEC_END", SEC_END},
|
||||
{"INCLUDE", INCLUDE},
|
||||
{"WORD", WORD},
|
||||
{"EQUAL", EQUAL},
|
||||
{"LIST_START", LIST_START},
|
||||
{"LIST_END", LIST_END},
|
||||
{"NONE", NONE},
|
||||
};
|
||||
#endif
|
||||
|
||||
struct files
|
||||
{
|
||||
char *name;
|
||||
struct files *parent;
|
||||
};
|
||||
|
||||
struct keyword
|
||||
{
|
||||
enum keyword_t type;
|
||||
/* if WORD */
|
||||
int line;
|
||||
struct files *file;
|
||||
char *name;
|
||||
struct keyword *next;
|
||||
};
|
||||
|
||||
struct state
|
||||
{
|
||||
bool quote;
|
||||
bool comment;
|
||||
char quote_char;
|
||||
};
|
||||
|
||||
/* TO REMOVE (use a identifier for config and fallback XDG in api functions) */
|
||||
TAILQ_HEAD(, conf_sec) config;
|
||||
static struct keyword *keywords = NULL;
|
||||
|
||||
static struct keyword *
|
||||
push_keyword(struct keyword *tail, enum keyword_t type, char *buf, size_t *offset, struct files *file, int line)
|
||||
{
|
||||
struct keyword *kw;
|
||||
#ifdef DEBUG
|
||||
int i = 0;
|
||||
#endif
|
||||
|
||||
if(type == WORD && *offset == 0)
|
||||
return tail;
|
||||
|
||||
kw = xcalloc(1, sizeof(*kw));
|
||||
kw->type = type;
|
||||
kw->line = line;
|
||||
kw->file = file;
|
||||
kw->next = NULL;
|
||||
|
||||
if(*offset)
|
||||
{
|
||||
buf[*offset] = '\0';
|
||||
|
||||
if(!strcmp(buf, INCLUDE_CMD))
|
||||
kw->type = INCLUDE;
|
||||
else
|
||||
kw->name = strdup(buf);
|
||||
|
||||
*offset = 0;
|
||||
}
|
||||
else
|
||||
kw->name = NULL;
|
||||
|
||||
if(tail)
|
||||
tail->next = kw;
|
||||
|
||||
#ifdef DEBUG
|
||||
for(i = 0; kw_t_name[i].type != NONE; ++i)
|
||||
if(kw_t_name[i].type == kw->type)
|
||||
warnx("%s %s %s:%d\n", kw_t_name[i].name,
|
||||
(kw->name) ? kw->name : "",
|
||||
kw->file->name, kw->line);
|
||||
#endif
|
||||
|
||||
return kw;
|
||||
}
|
||||
|
||||
static void
|
||||
syntax(struct keyword *kw, const char *fmt, ...)
|
||||
{
|
||||
va_list args;
|
||||
|
||||
fprintf(stderr, "%s:", __progname);
|
||||
|
||||
if(kw && kw->file && kw->file->name)
|
||||
fprintf(stderr, "%s:%d", kw->file->name, kw->line);
|
||||
|
||||
if(kw && kw->name)
|
||||
fprintf(stderr, ", near '%s'", kw->name);
|
||||
fprintf(stderr, ": ");
|
||||
|
||||
va_start(args, fmt);
|
||||
vfprintf(stderr, fmt, args);
|
||||
va_end(args);
|
||||
|
||||
fprintf(stderr, "\n");
|
||||
}
|
||||
|
||||
|
||||
#define PUSH_KEYWORD(type) tail = push_keyword(tail, type, bufname, &j, file, line)
|
||||
static struct keyword *
|
||||
parse_keywords(const char *filename)
|
||||
{
|
||||
int fd;
|
||||
struct stat st;
|
||||
char *buf;
|
||||
struct keyword *head = NULL;
|
||||
struct keyword *tail = NULL;
|
||||
struct files *file;
|
||||
enum keyword_t type; /* keyword type to push */
|
||||
struct state s = { false, false, '\0'};
|
||||
char *bufname;
|
||||
char path[PATH_MAX];
|
||||
size_t i, j;
|
||||
int line;
|
||||
bool error = false;
|
||||
|
||||
|
||||
if((fd = open(filename, O_RDONLY)) == -1 || stat(filename, &st) == -1)
|
||||
{
|
||||
warn("%s", filename);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if(!st.st_size)
|
||||
{
|
||||
warnx("%s: empty file", filename);
|
||||
close(fd);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if(!realpath(filename, path))
|
||||
{
|
||||
warn("%s", filename);
|
||||
close(fd);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
buf = xmalloc(1, st.st_size + 1);
|
||||
|
||||
if(read(fd, buf, st.st_size) == -1)
|
||||
{
|
||||
warn("%s", filename);
|
||||
free(buf);
|
||||
close(fd);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
buf[st.st_size] = '\0';
|
||||
|
||||
file = xcalloc(1, sizeof(*file));
|
||||
bufname = xcalloc(BUFSIZ, sizeof(*bufname));
|
||||
file->name = strdup(path);
|
||||
file->parent = NULL;
|
||||
|
||||
for(i = j = 0, line = 1; i < (size_t)st.st_size; ++i)
|
||||
{
|
||||
if(!head && tail)
|
||||
head = tail;
|
||||
|
||||
if(buf[i] == '\n' && s.comment)
|
||||
{
|
||||
line++;
|
||||
s.comment = false;
|
||||
continue;
|
||||
}
|
||||
|
||||
if(buf[i] == '#' && !s.quote)
|
||||
{
|
||||
s.comment = true;
|
||||
continue;
|
||||
}
|
||||
|
||||
if(s.comment)
|
||||
continue;
|
||||
|
||||
/* end of quotted string */
|
||||
if(s.quote && buf[i] == s.quote_char)
|
||||
{
|
||||
PUSH_KEYWORD(WORD);
|
||||
s.quote = false;
|
||||
continue;
|
||||
}
|
||||
|
||||
if(!s.quote)
|
||||
{
|
||||
if((buf[i] == '"' || buf[i] == '\''))
|
||||
{
|
||||
PUSH_KEYWORD(WORD);
|
||||
/* begin quotted string */
|
||||
s.quote_char = buf[i];
|
||||
s.quote = true;
|
||||
continue;
|
||||
}
|
||||
|
||||
if(buf[i] == '[')
|
||||
{
|
||||
PUSH_KEYWORD(WORD);
|
||||
|
||||
if(buf[i + 1] == '/')
|
||||
{
|
||||
i += 2;
|
||||
type = SEC_END;
|
||||
}
|
||||
else
|
||||
{
|
||||
++i;
|
||||
type = SEC_START;
|
||||
}
|
||||
|
||||
/* get section name */
|
||||
while(buf[i] != ']')
|
||||
{
|
||||
if(i >= ((size_t)st.st_size-1) || j >= (BUFSIZ-1))
|
||||
{
|
||||
bufname[j] = '\0';
|
||||
syntax(NULL, "word too long in %s:%d near '%s'",
|
||||
file->name, line, bufname);
|
||||
error = true;
|
||||
break;
|
||||
}
|
||||
bufname[j++] = buf[i++];
|
||||
}
|
||||
PUSH_KEYWORD(type);
|
||||
continue;
|
||||
}
|
||||
|
||||
if(buf[i] == '{')
|
||||
{
|
||||
PUSH_KEYWORD(WORD);
|
||||
PUSH_KEYWORD(LIST_START);
|
||||
continue;
|
||||
}
|
||||
|
||||
if(buf[i] == '}')
|
||||
{
|
||||
PUSH_KEYWORD(WORD);
|
||||
PUSH_KEYWORD(LIST_END);
|
||||
continue;
|
||||
}
|
||||
|
||||
if(buf[i] == ',')
|
||||
{
|
||||
PUSH_KEYWORD(WORD);
|
||||
continue;
|
||||
}
|
||||
|
||||
if(buf[i] == '=')
|
||||
{
|
||||
PUSH_KEYWORD(WORD);
|
||||
PUSH_KEYWORD(EQUAL);
|
||||
continue;
|
||||
}
|
||||
|
||||
if(strchr("\t\n ", buf[i]))
|
||||
{
|
||||
PUSH_KEYWORD(WORD);
|
||||
|
||||
if(buf[i] == '\n')
|
||||
++line;
|
||||
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
if(j >= (BUFSIZ - 1))
|
||||
{
|
||||
bufname[j] = '\0';
|
||||
syntax(NULL, "word too long in %s:%d near '%s'",
|
||||
file->name, line, bufname);
|
||||
error = true;
|
||||
break;
|
||||
}
|
||||
|
||||
bufname[j++] = buf[i];
|
||||
}
|
||||
|
||||
free(buf);
|
||||
free(bufname);
|
||||
close(fd);
|
||||
warnx("%s read", file->name);
|
||||
|
||||
return (error ? NULL: head);
|
||||
}
|
||||
|
||||
/*
|
||||
* return NULL on failure and head->next if
|
||||
* no config found (of file doesn't exist)
|
||||
* NOTE to devs: head->name is the file to include
|
||||
*/
|
||||
static struct keyword *
|
||||
include(struct keyword *head)
|
||||
{
|
||||
struct keyword *kw;
|
||||
struct keyword *tail;
|
||||
struct files *file;
|
||||
struct passwd *user;
|
||||
char *filename = NULL;
|
||||
char *base = NULL;
|
||||
|
||||
head = head->next;
|
||||
|
||||
if(!head || head->type != WORD)
|
||||
{
|
||||
syntax(head, "missing filename to include");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* replace ~ by user directory */
|
||||
if(head->name && head->name[0] == '~')
|
||||
{
|
||||
if((user = getpwuid(getuid())) && user->pw_dir)
|
||||
xasprintf(&filename, "%s%s", user->pw_dir, head->name + 1);
|
||||
else if(getenv("HOME"))
|
||||
xasprintf(&filename, "%s%s", getenv("HOME"), head->name + 1);
|
||||
else /* to warning ? */
|
||||
filename = head->name;
|
||||
}
|
||||
|
||||
/* relative path from parent file */
|
||||
else if(head->name && head->name[0] != '/')
|
||||
{
|
||||
base = strdup(head->file->name);
|
||||
xasprintf(&filename, "%s/%s", dirname(base), head->name);
|
||||
free(base);
|
||||
}
|
||||
else
|
||||
filename = head->name;
|
||||
|
||||
if(!(kw = parse_keywords(filename)))
|
||||
{
|
||||
warnx("no config found in include file %s", head->name);
|
||||
|
||||
if(filename != head->name)
|
||||
free(filename);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
kw->file->parent = head->file;
|
||||
|
||||
/* detect circular include */
|
||||
for(file = kw->file->parent; file != NULL; file = file->parent)
|
||||
if(!strcmp(file->name, kw->file->name))
|
||||
{
|
||||
syntax(kw, "circular include of %s", kw->file->name);
|
||||
|
||||
if(filename != head->name)
|
||||
free(filename);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if(filename != head->name)
|
||||
free(filename);
|
||||
|
||||
head = head->next;
|
||||
|
||||
if(kw)
|
||||
{
|
||||
for(tail = kw; tail->next; tail = tail->next);
|
||||
tail->next = head;
|
||||
}
|
||||
|
||||
return kw;
|
||||
}
|
||||
|
||||
static void *
|
||||
free_opt(struct conf_opt *o)
|
||||
{
|
||||
free(o);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static struct conf_opt *
|
||||
get_option(struct keyword **head)
|
||||
{
|
||||
struct conf_opt *o;
|
||||
size_t j = 0;
|
||||
struct keyword *kw = *head;
|
||||
|
||||
o = xcalloc(1, sizeof(*o));
|
||||
o->name = kw->name;
|
||||
o->used = false;
|
||||
o->line = kw->line;
|
||||
o->filename = kw->file->name;
|
||||
|
||||
kw = kw->next;
|
||||
|
||||
if(kw->type != EQUAL)
|
||||
{
|
||||
syntax(kw, "missing '=' here");
|
||||
return free_opt(o);
|
||||
}
|
||||
|
||||
if(!(kw = kw->next))
|
||||
{
|
||||
syntax(kw, "missing value");
|
||||
return free_opt(o);
|
||||
}
|
||||
|
||||
switch(kw->type)
|
||||
{
|
||||
case INCLUDE:
|
||||
if(!(kw = include(kw)))
|
||||
return free_opt(o);
|
||||
break;
|
||||
|
||||
case WORD:
|
||||
o->val[0] = kw->name;
|
||||
o->val[1] = NULL;
|
||||
kw = kw->next;
|
||||
break;
|
||||
|
||||
case LIST_START:
|
||||
kw = kw->next;
|
||||
|
||||
while(kw && kw->type != LIST_END)
|
||||
{
|
||||
switch(kw->type)
|
||||
{
|
||||
case WORD:
|
||||
if(j >= (PARSE_MAX_LIST - 1))
|
||||
{
|
||||
syntax(kw, "too much values in list");
|
||||
return free_opt(o);
|
||||
}
|
||||
|
||||
o->val[j++] = kw->name;
|
||||
kw = kw->next;
|
||||
break;
|
||||
|
||||
case INCLUDE:
|
||||
if(!(kw = include(kw)))
|
||||
return free_opt(o);
|
||||
break;
|
||||
|
||||
default:
|
||||
syntax(kw, "declaration into a list");
|
||||
return free_opt(o);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if(!kw)
|
||||
{
|
||||
syntax(kw, "list unclosed");
|
||||
return free_opt(o);
|
||||
}
|
||||
|
||||
kw = kw->next;
|
||||
break;
|
||||
|
||||
default:
|
||||
syntax(kw, "missing value");
|
||||
return free_opt(o);
|
||||
break;
|
||||
}
|
||||
|
||||
*head = kw;
|
||||
return o;
|
||||
}
|
||||
|
||||
static void *
|
||||
free_sec(struct conf_sec *sec)
|
||||
{
|
||||
struct conf_opt *o;
|
||||
struct conf_sec *s;
|
||||
|
||||
if(sec)
|
||||
{
|
||||
while(!SLIST_EMPTY(&sec->optlist))
|
||||
{
|
||||
o = SLIST_FIRST(&sec->optlist);
|
||||
SLIST_REMOVE_HEAD(&sec->optlist, entry);
|
||||
free_opt(o);
|
||||
}
|
||||
|
||||
while(!TAILQ_EMPTY(&sec->sub))
|
||||
{
|
||||
s = TAILQ_FIRST(&sec->sub);
|
||||
TAILQ_REMOVE(&sec->sub, s, entry);
|
||||
free_sec(s);
|
||||
}
|
||||
|
||||
free(sec);
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static struct conf_sec *
|
||||
get_section(struct keyword **head)
|
||||
{
|
||||
struct conf_sec *s;
|
||||
struct conf_opt *o;
|
||||
struct conf_sec *sub;
|
||||
struct keyword *kw = *head;
|
||||
|
||||
s = xcalloc(1, sizeof(*s));
|
||||
s->name = kw->name;
|
||||
|
||||
TAILQ_INIT(&s->sub);
|
||||
SLIST_INIT(&s->optlist);
|
||||
|
||||
kw = kw->next;
|
||||
|
||||
while(kw && kw->type != SEC_END)
|
||||
{
|
||||
switch(kw->type)
|
||||
{
|
||||
case INCLUDE:
|
||||
if(!(kw = include(kw)))
|
||||
return free_sec(s);
|
||||
break;
|
||||
|
||||
case SEC_START:
|
||||
if(!(sub = get_section(&kw)))
|
||||
return free_sec(s);
|
||||
TAILQ_INSERT_TAIL(&s->sub, sub, entry);
|
||||
++s->nsub;
|
||||
break;
|
||||
|
||||
case WORD:
|
||||
if(!(o = get_option(&kw)))
|
||||
return free_sec(s);
|
||||
SLIST_INSERT_HEAD(&s->optlist, o, entry);
|
||||
++s->nopt;
|
||||
break;
|
||||
|
||||
default:
|
||||
syntax(kw, "syntax error");
|
||||
return free_sec(s);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if(!kw || strcmp(kw->name, s->name))
|
||||
{
|
||||
syntax(kw, "missing end section %s", s->name);
|
||||
return free_sec(s);
|
||||
}
|
||||
|
||||
kw = kw->next;
|
||||
*head = kw;
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
int
|
||||
free_conf(void)
|
||||
{
|
||||
struct conf_sec *s;
|
||||
struct keyword *kw, *nkw;
|
||||
struct files **f = NULL;
|
||||
int i, nf = 0;
|
||||
|
||||
while(!TAILQ_EMPTY(&config))
|
||||
{
|
||||
s = TAILQ_FIRST(&config);
|
||||
TAILQ_REMOVE(&config, s, entry);
|
||||
free_sec(s);
|
||||
}
|
||||
|
||||
kw = keywords;
|
||||
|
||||
while(kw)
|
||||
{
|
||||
nkw = kw->next;
|
||||
|
||||
free(kw->name);
|
||||
|
||||
for(i = 0; i < nf; ++i)
|
||||
if(f[i] == kw->file)
|
||||
{
|
||||
if(!(f = realloc(f, sizeof(*f) * (++i))))
|
||||
err(EXIT_FAILURE, "realloc");
|
||||
|
||||
f[i - 1] = kw->file;
|
||||
}
|
||||
|
||||
kw = nkw;
|
||||
}
|
||||
|
||||
if(nf > 0)
|
||||
{
|
||||
for(i = 0; i < nf; ++i)
|
||||
{
|
||||
free(f[i]->name);
|
||||
free(f[i]);
|
||||
}
|
||||
free(f);
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
int
|
||||
get_conf(const char *filename)
|
||||
{
|
||||
struct conf_sec *s;
|
||||
struct keyword *head, *kw;
|
||||
|
||||
head = kw = parse_keywords(filename);
|
||||
|
||||
if(!head)
|
||||
return -1; /* TODO ERREUR */
|
||||
|
||||
keywords = head;
|
||||
|
||||
TAILQ_INIT(&config);
|
||||
|
||||
while(kw)
|
||||
{
|
||||
switch(kw->type)
|
||||
{
|
||||
case INCLUDE:
|
||||
if(!(kw = include(kw)))
|
||||
return free_conf();
|
||||
break;
|
||||
|
||||
case SEC_START:
|
||||
if(!(s = get_section(&kw)))
|
||||
return free_conf();
|
||||
TAILQ_INSERT_TAIL(&config, s, entry);
|
||||
break;
|
||||
|
||||
default:
|
||||
syntax(kw, "out of any section");
|
||||
return free_conf();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
118
src/parse.h
Normal file
118
src/parse.h
Normal file
@ -0,0 +1,118 @@
|
||||
/*
|
||||
* Copyright (c) 2010 Philippe Pepiot <phil@philpep.org>
|
||||
* Copyright (c) 2011 Martin Duquesnoy <xorg62@gmail.com>
|
||||
*
|
||||
* Permission to use, copy, modify, and distribute this software for any
|
||||
* purpose with or without fee is hereby granted, provided that the above
|
||||
* copyright notice and this permission notice appear in all copies.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*/
|
||||
|
||||
#ifndef PARSE_H
|
||||
#define PARSE_H
|
||||
|
||||
#include "wmfs.h"
|
||||
|
||||
#define INCLUDE_CMD "@include"
|
||||
#define PARSE_MAX_LIST 32
|
||||
|
||||
struct conf_opt
|
||||
{
|
||||
char *name;
|
||||
char *val[PARSE_MAX_LIST];
|
||||
size_t nval;
|
||||
bool used;
|
||||
int line;
|
||||
char *filename;
|
||||
SLIST_ENTRY(conf_opt) entry;
|
||||
};
|
||||
|
||||
struct conf_sec
|
||||
{
|
||||
char *name;
|
||||
SLIST_HEAD(, conf_opt) optlist;
|
||||
TAILQ_HEAD(cshead, conf_sec) sub;
|
||||
size_t nopt;
|
||||
size_t nsub;
|
||||
TAILQ_ENTRY(conf_sec) entry;
|
||||
};
|
||||
|
||||
struct opt_type
|
||||
{
|
||||
long int num;
|
||||
float fnum;
|
||||
bool boolean;
|
||||
char *str;
|
||||
};
|
||||
|
||||
/*
|
||||
* Create config from file
|
||||
* return -1 on failure
|
||||
*/
|
||||
int get_conf(const char *);
|
||||
|
||||
/*
|
||||
* Print unused option name from section s (and subsections).
|
||||
* If s == NULL print unused option name for all config struct.
|
||||
*/
|
||||
void print_unused(struct conf_sec *s);
|
||||
|
||||
/*
|
||||
* Free the config struct.
|
||||
* WARNING: This make all string
|
||||
* returned by fetch_(opt|section)(_first) unusable.
|
||||
*/
|
||||
int free_conf(void);
|
||||
|
||||
/*
|
||||
* Get all subsection matching the given name on the given
|
||||
* section.
|
||||
* If section == NULL, return subsections from root section.
|
||||
* Return a NULL terminated array.
|
||||
* Subsections are returned in order as they are in config file
|
||||
* WARNING : This MUST be free() after use.
|
||||
*/
|
||||
struct conf_sec **fetch_section(struct conf_sec *, char *);
|
||||
|
||||
/*
|
||||
* Get first subsection matching the given name
|
||||
* on the given section. (first found on the file)
|
||||
*/
|
||||
struct conf_sec *fetch_section_first(struct conf_sec *, char *);
|
||||
|
||||
/*
|
||||
* Count member of a conf_sec **
|
||||
*/
|
||||
size_t fetch_section_count(struct conf_sec **);
|
||||
|
||||
/*
|
||||
* Return all options matching the given name on the given subsection.
|
||||
* If none match or section == NULL return opt_type build with the
|
||||
* given default param.
|
||||
* WARNING: This MUST be free() after use.
|
||||
* WARNING: The string member is directly taken from the config struct.
|
||||
* WARNING: Returned in reverse order as they are in config file.
|
||||
* (I think the last option MUST overwrite all others)
|
||||
*/
|
||||
struct opt_type fetch_opt_first(struct conf_sec *, char *, char *);
|
||||
|
||||
/*
|
||||
* Get first (last in config file) option matching the given name
|
||||
* on the given section.
|
||||
* WARNING: The string member is directly taken from the config struct.
|
||||
*/
|
||||
struct opt_type *fetch_opt(struct conf_sec *, char *, char *);
|
||||
|
||||
/*
|
||||
* Count member of a opt_type *
|
||||
*/
|
||||
size_t fetch_opt_count(struct opt_type *);
|
||||
|
||||
#endif /* PARSE_H */
|
||||
BIN
src/parse.o
Normal file
BIN
src/parse.o
Normal file
Binary file not shown.
214
src/parse_api.c
Normal file
214
src/parse_api.c
Normal file
@ -0,0 +1,214 @@
|
||||
/*
|
||||
* Copyright (c) 2010 Philippe Pepiot <phil@philpep.org>
|
||||
* Copyright (c) 2011 Martin Duquesnoy <xorg62@gmail.com>
|
||||
*
|
||||
* Permission to use, copy, modify, and distribute this software for any
|
||||
* purpose with or without fee is hereby granted, provided that the above
|
||||
* copyright notice and this permission notice appear in all copies.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*/
|
||||
|
||||
#ifndef _BSD_SOURCE
|
||||
#define _BSD_SOURCE
|
||||
#endif
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <err.h>
|
||||
|
||||
#include "wmfs.h"
|
||||
#include "parse.h"
|
||||
#include "util.h"
|
||||
|
||||
extern TAILQ_HEAD(, conf_sec) config;
|
||||
|
||||
static const struct opt_type opt_type_null = { 0, 0, false, NULL };
|
||||
|
||||
static struct opt_type
|
||||
string_to_opt(char *s)
|
||||
{
|
||||
struct opt_type ret = opt_type_null;
|
||||
|
||||
if(!s || !strlen(s))
|
||||
return ret;
|
||||
|
||||
ret.num = strtol(s, (char**)NULL, 10);
|
||||
ret.fnum = strtod(s, NULL);
|
||||
|
||||
ret.boolean = (!strcmp(s, "true")
|
||||
|| !strcmp(s, "true")
|
||||
|| !strcmp(s, "TRUE")
|
||||
|| !strcmp(s, "1"));
|
||||
|
||||
ret.str = s;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
print_unused(struct conf_sec *sec)
|
||||
{
|
||||
struct conf_sec *s;
|
||||
struct conf_opt *o;
|
||||
|
||||
if(!sec)
|
||||
{
|
||||
TAILQ_FOREACH(s, &config, entry)
|
||||
print_unused(s);
|
||||
return;
|
||||
}
|
||||
|
||||
SLIST_FOREACH(o, &sec->optlist, entry)
|
||||
if(!o->used)
|
||||
warnx("%s:%d, unused param %s", o->filename, o->line, o->name);
|
||||
|
||||
TAILQ_FOREACH(s, &sec->sub, entry)
|
||||
if(!TAILQ_EMPTY(&s->sub))
|
||||
print_unused(s);
|
||||
}
|
||||
|
||||
struct conf_sec **
|
||||
fetch_section(struct conf_sec *s, char *name)
|
||||
{
|
||||
struct conf_sec **ret;
|
||||
struct conf_sec *sec;
|
||||
size_t i = 0;
|
||||
|
||||
if(!name)
|
||||
return NULL;
|
||||
|
||||
if(!s)
|
||||
{
|
||||
ret = xcalloc(2, sizeof(struct conf_sec *));
|
||||
|
||||
TAILQ_FOREACH(sec, &config, entry)
|
||||
if(!strcmp(sec->name, name))
|
||||
{
|
||||
ret[0] = sec;
|
||||
ret[1] = NULL;
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
ret = xcalloc(s->nsub + 1, sizeof(struct conf_sec *));
|
||||
|
||||
TAILQ_FOREACH(sec, &s->sub, entry)
|
||||
if(!strcmp(sec->name, name) && i < s->nsub)
|
||||
ret[i++] = sec;
|
||||
|
||||
ret[i] = NULL;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
struct conf_sec *
|
||||
fetch_section_first(struct conf_sec *s, char *name)
|
||||
{
|
||||
struct conf_sec *sec, *ret = NULL;
|
||||
TAILQ_HEAD(cshead, conf_sec) *head =
|
||||
(s
|
||||
? (struct cshead*)&s->sub
|
||||
: (struct cshead*)&config);
|
||||
|
||||
if(!name)
|
||||
return NULL;
|
||||
|
||||
TAILQ_FOREACH(sec, head, entry)
|
||||
if(sec->name && !strcmp(sec->name, name))
|
||||
{
|
||||
ret = sec;
|
||||
break;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
size_t
|
||||
fetch_section_count(struct conf_sec **s)
|
||||
{
|
||||
size_t ret = 0;
|
||||
|
||||
while(s[ret])
|
||||
++ret;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
struct opt_type *
|
||||
fetch_opt(struct conf_sec *s, char *dfl, char *name)
|
||||
{
|
||||
struct conf_opt *o;
|
||||
struct opt_type *ret;
|
||||
size_t i = 0;
|
||||
|
||||
if(!name)
|
||||
return NULL;
|
||||
|
||||
ret = xcalloc(10, sizeof(struct opt_type));
|
||||
|
||||
if(s)
|
||||
{
|
||||
SLIST_FOREACH(o, &s->optlist, entry)
|
||||
if(!strcmp(o->name, name))
|
||||
{
|
||||
while(o->val[i])
|
||||
{
|
||||
o->used = true;
|
||||
ret[i] = string_to_opt(o->val[i]);
|
||||
++i;
|
||||
}
|
||||
|
||||
ret[i] = opt_type_null;
|
||||
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
ret[0] = string_to_opt(dfl);
|
||||
ret[1] = opt_type_null;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
struct opt_type
|
||||
fetch_opt_first(struct conf_sec *s, char *dfl, char *name)
|
||||
{
|
||||
struct conf_opt *o;
|
||||
|
||||
if(!name)
|
||||
return opt_type_null;
|
||||
else if(s)
|
||||
{
|
||||
SLIST_FOREACH(o, &s->optlist, entry)
|
||||
if(!strcmp(o->name, name))
|
||||
{
|
||||
o->used = true;
|
||||
|
||||
return string_to_opt(o->val[0]);
|
||||
}
|
||||
}
|
||||
|
||||
return string_to_opt(dfl);
|
||||
}
|
||||
|
||||
size_t
|
||||
fetch_opt_count(struct opt_type *o)
|
||||
{
|
||||
size_t ret = 0;
|
||||
|
||||
while(o[ret].str)
|
||||
++ret;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
BIN
src/parse_api.o
Normal file
BIN
src/parse_api.o
Normal file
Binary file not shown.
114
src/screen.c
Normal file
114
src/screen.c
Normal file
@ -0,0 +1,114 @@
|
||||
/*
|
||||
* wmfs2 by Martin Duquesnoy <xorg62@gmail.com> { for(i = 2011; i < 2111; ++i) ©(i); }
|
||||
* For license, see COPYING.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_XINERAMA
|
||||
#include <X11/extensions/Xinerama.h>
|
||||
#endif /* HAVE_XINERAMA */
|
||||
|
||||
#include "screen.h"
|
||||
#include "util.h"
|
||||
#include "tag.h"
|
||||
#include "infobar.h"
|
||||
#include "client.h"
|
||||
|
||||
static struct screen*
|
||||
screen_new(struct geo *g, int id)
|
||||
{
|
||||
struct screen *s = (struct screen*)xcalloc(1, sizeof(struct screen));
|
||||
|
||||
s->geo = s->ugeo = *g;
|
||||
s->seltag = NULL;
|
||||
s->id = id;
|
||||
|
||||
TAILQ_INIT(&s->tags);
|
||||
SLIST_INIT(&s->infobars);
|
||||
|
||||
SLIST_INSERT_HEAD(&W->h.screen, s, next);
|
||||
|
||||
/* Set as selected screen */
|
||||
W->screen = s;
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
void
|
||||
screen_init(void)
|
||||
{
|
||||
struct geo g;
|
||||
|
||||
SLIST_INIT(&W->h.screen);
|
||||
|
||||
#ifdef HAVE_XINERAMA
|
||||
XineramaScreenInfo *xsi;
|
||||
int i, n = 0;
|
||||
|
||||
if(XineramaIsActive(W->dpy))
|
||||
{
|
||||
xsi = XineramaQueryScreens(W->dpy, &n);
|
||||
|
||||
for(i = 0; i < n; ++i)
|
||||
{
|
||||
g.x = xsi[i].x_org;
|
||||
g.y = xsi[i].y_org;
|
||||
g.w = xsi[i].width;
|
||||
g.h = xsi[i].height;
|
||||
|
||||
screen_new(&g, i);
|
||||
}
|
||||
|
||||
XFree(xsi);
|
||||
}
|
||||
else
|
||||
#endif /* HAVE_XINERAMA */
|
||||
{
|
||||
g.x = g.y = 0;
|
||||
g.w = DisplayWidth(W->dpy, W->xscreen);
|
||||
g.h = DisplayHeight(W->dpy, W->xscreen);
|
||||
|
||||
screen_new(&g, 0);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Update selected screen with mouse location
|
||||
*/
|
||||
struct screen*
|
||||
screen_update_sel(void)
|
||||
{
|
||||
#ifdef HAVE_XINERAMA
|
||||
if(XineramaIsActive(W->dpy))
|
||||
{
|
||||
struct screen *s;
|
||||
Window w;
|
||||
int d, x, y;
|
||||
|
||||
XQueryPointer(W->dpy, W->root, &w, &w, &x, &y, &d, &d, (unsigned int *)&d);
|
||||
|
||||
SLIST_FOREACH(s, &W->h.screen, next)
|
||||
if(INAREA(x, y, s->geo))
|
||||
break;
|
||||
|
||||
return (W->screen = s);
|
||||
}
|
||||
#endif /* HAVE_XINERAMA */
|
||||
|
||||
return W->screen;
|
||||
}
|
||||
|
||||
void
|
||||
screen_free(void)
|
||||
{
|
||||
struct screen *s;
|
||||
|
||||
while(!SLIST_EMPTY(&W->h.screen))
|
||||
{
|
||||
s = SLIST_FIRST(&W->h.screen);
|
||||
SLIST_REMOVE_HEAD(&W->h.screen, next);
|
||||
|
||||
infobar_free(s);
|
||||
tag_free(s);
|
||||
free(s);
|
||||
}
|
||||
}
|
||||
27
src/screen.h
Normal file
27
src/screen.h
Normal file
@ -0,0 +1,27 @@
|
||||
/*
|
||||
* wmfs2 by Martin Duquesnoy <xorg62@gmail.com> { for(i = 2011; i < 2111; ++i) ©(i); }
|
||||
* For license, see COPYING.
|
||||
*/
|
||||
|
||||
#ifndef SCREEN_H
|
||||
#define SCREEN_H
|
||||
|
||||
#include "wmfs.h"
|
||||
|
||||
static inline struct screen*
|
||||
screen_gb_id(int id)
|
||||
{
|
||||
struct screen *s;
|
||||
|
||||
SLIST_FOREACH(s, &W->h.screen, next)
|
||||
if(s->id == id)
|
||||
return s;
|
||||
|
||||
return SLIST_FIRST(&W->h.screen);
|
||||
}
|
||||
|
||||
void screen_init(void);
|
||||
struct screen* screen_update_sel(void);
|
||||
void screen_free(void);
|
||||
|
||||
#endif /* SCREEN_H */
|
||||
BIN
src/screen.o
Normal file
BIN
src/screen.o
Normal file
Binary file not shown.
198
src/tag.c
Normal file
198
src/tag.c
Normal file
@ -0,0 +1,198 @@
|
||||
/*
|
||||
* wmfs2 by Martin Duquesnoy <xorg62@gmail.com> { for(i = 2011; i < 2111; ++i) ©(i); }
|
||||
* For license, see COPYING.
|
||||
*/
|
||||
|
||||
#include <X11/Xutil.h> /* IconicState / NormalState */
|
||||
|
||||
#include "tag.h"
|
||||
#include "util.h"
|
||||
#include "infobar.h"
|
||||
#include "client.h"
|
||||
#include "config.h"
|
||||
#include "barwin.h"
|
||||
#include "ewmh.h"
|
||||
#include "layout.h"
|
||||
|
||||
struct tag*
|
||||
tag_new(struct screen *s, char *name)
|
||||
{
|
||||
struct tag *t;
|
||||
XSetWindowAttributes at =
|
||||
{
|
||||
.background_pixel = THEME_DEFAULT->frame_bg,
|
||||
.override_redirect = true,
|
||||
.background_pixmap = ParentRelative,
|
||||
.event_mask = BARWIN_MASK
|
||||
};
|
||||
|
||||
t = xcalloc(1, sizeof(struct tag));
|
||||
|
||||
t->screen = s;
|
||||
t->name = xstrdup(name);
|
||||
t->flags = 0;
|
||||
t->sel = NULL;
|
||||
|
||||
/* Frame window */
|
||||
t->frame = XCreateWindow(W->dpy, W->root,
|
||||
s->ugeo.x, s->ugeo.y,
|
||||
s->ugeo.w, s->ugeo.h,
|
||||
0, CopyFromParent,
|
||||
InputOutput,
|
||||
CopyFromParent,
|
||||
(CWOverrideRedirect | CWBackPixmap
|
||||
| CWBackPixel | CWEventMask),
|
||||
&at);
|
||||
|
||||
SLIST_INIT(&t->clients);
|
||||
|
||||
TAILQ_INSERT_TAIL(&s->tags, t, next);
|
||||
|
||||
return t;
|
||||
}
|
||||
|
||||
void
|
||||
tag_screen(struct screen *s, struct tag *t)
|
||||
{
|
||||
struct client *c;
|
||||
|
||||
/* Unmap previous tag's frame */
|
||||
WIN_STATE(s->seltag->frame, Unmap);
|
||||
SLIST_FOREACH(c, &s->seltag->clients, tnext)
|
||||
ewmh_set_wm_state(c->win, IconicState);
|
||||
|
||||
/*
|
||||
* Map selected tag's frame, only if there is
|
||||
* clients in t
|
||||
*/
|
||||
if(!SLIST_EMPTY(&t->clients))
|
||||
{
|
||||
WIN_STATE(t->frame, Map);
|
||||
SLIST_FOREACH(c, &t->clients, tnext)
|
||||
ewmh_set_wm_state(c->win, NormalState);
|
||||
|
||||
client_focus(t->sel);
|
||||
}
|
||||
|
||||
s->seltag = t;
|
||||
|
||||
infobar_elem_screen_update(s, ElemTag);
|
||||
}
|
||||
|
||||
/* Set t to NULL to untag c from c->tag */
|
||||
void
|
||||
tag_client(struct tag *t, struct client *c)
|
||||
{
|
||||
/* Remove client from its previous tag */
|
||||
if(c->tag)
|
||||
{
|
||||
if(c->tag == t)
|
||||
return;
|
||||
|
||||
layout_split_arrange_closed(c);
|
||||
|
||||
SLIST_REMOVE(&c->tag->clients, c, client, tnext);
|
||||
|
||||
if(c->tag->sel == c || W->client == c)
|
||||
client_focus(client_next(c));
|
||||
}
|
||||
|
||||
/*
|
||||
* Case of client removing: umap frame if empty
|
||||
*/
|
||||
if(!t)
|
||||
{
|
||||
/* Unmap frame if tag is now empty */
|
||||
if(SLIST_EMPTY(&c->tag->clients))
|
||||
WIN_STATE(c->tag->frame, Unmap);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
/* Reparent client win in frame win */
|
||||
XReparentWindow(W->dpy, c->win, t->frame, 0, 0);
|
||||
|
||||
/* Map frame if tag was empty */
|
||||
if(SLIST_EMPTY(&t->clients))
|
||||
WIN_STATE(t->frame, Map);
|
||||
|
||||
c->tag = t;
|
||||
|
||||
layout_split_integrate(c, t->sel);
|
||||
|
||||
/* Insert in new tag list */
|
||||
SLIST_INSERT_HEAD(&t->clients, c, tnext);
|
||||
}
|
||||
|
||||
void
|
||||
uicb_tag_set(Uicb cmd)
|
||||
{
|
||||
int i = 0, n = ATOI(cmd);
|
||||
struct tag *t;
|
||||
|
||||
TAILQ_FOREACH(t, &W->screen->tags, next)
|
||||
if(++i == n)
|
||||
{
|
||||
tag_screen(W->screen, t);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
uicb_tag_set_with_name(Uicb cmd)
|
||||
{
|
||||
struct tag *t;
|
||||
|
||||
TAILQ_FOREACH(t, &W->screen->tags, next)
|
||||
if(!strcmp(cmd, t->name))
|
||||
{
|
||||
tag_screen(W->screen, t);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
uicb_tag_next(Uicb cmd)
|
||||
{
|
||||
(void)cmd;
|
||||
struct tag *t;
|
||||
|
||||
if((t = TAILQ_NEXT(W->screen->seltag, next)))
|
||||
tag_screen(W->screen, t);
|
||||
else if( /* CIRCULAR OPTION */ 1)
|
||||
tag_screen(W->screen, TAILQ_FIRST(&W->screen->tags));
|
||||
}
|
||||
|
||||
void
|
||||
uicb_tag_prev(Uicb cmd)
|
||||
{
|
||||
(void)cmd;
|
||||
struct tag *t;
|
||||
|
||||
if((t = TAILQ_PREV(W->screen->seltag, tsub, next)))
|
||||
tag_screen(W->screen, t);
|
||||
else if( /* CIRCULAR OPTION */ 1)
|
||||
tag_screen(W->screen, TAILQ_LAST(&W->screen->tags, tsub));
|
||||
}
|
||||
|
||||
static void
|
||||
tag_remove(struct tag *t)
|
||||
{
|
||||
free(t->name);
|
||||
|
||||
XDestroyWindow(W->dpy, t->frame);
|
||||
|
||||
free(t);
|
||||
}
|
||||
|
||||
void
|
||||
tag_free(struct screen *s)
|
||||
{
|
||||
struct tag *t;
|
||||
|
||||
TAILQ_FOREACH(t, &s->tags, next)
|
||||
{
|
||||
TAILQ_REMOVE(&s->tags, t, next);
|
||||
tag_remove(t);
|
||||
}
|
||||
}
|
||||
38
src/tag.h
Normal file
38
src/tag.h
Normal file
@ -0,0 +1,38 @@
|
||||
/*
|
||||
* wmfs2 by Martin Duquesnoy <xorg62@gmail.com> { for(i = 2011; i < 2111; ++i) ©(i); }
|
||||
* For license, see COPYING.
|
||||
*/
|
||||
|
||||
#ifndef TAG_H
|
||||
#define TAG_H
|
||||
|
||||
#include "wmfs.h"
|
||||
|
||||
struct tag *tag_new(struct screen *s, char *name);
|
||||
void tag_screen(struct screen *s, struct tag *t);
|
||||
void tag_client(struct tag *t, struct client *c);
|
||||
void tag_free(struct screen *s);
|
||||
void uicb_tag_set(Uicb cmd);
|
||||
void uicb_tag_set_with_name(Uicb cmd);
|
||||
void uicb_tag_next(Uicb cmd);
|
||||
void uicb_tag_prev(Uicb cmd);
|
||||
|
||||
/*
|
||||
* Update frames size with screen usable geo
|
||||
*/
|
||||
static inline void
|
||||
tag_update_frame_geo(struct screen *s)
|
||||
{
|
||||
struct tag *t;
|
||||
|
||||
TAILQ_FOREACH(t, &s->tags, next)
|
||||
XMoveResizeWindow(W->dpy,
|
||||
t->frame,
|
||||
s->ugeo.x,
|
||||
s->ugeo.y,
|
||||
s->ugeo.w,
|
||||
s->ugeo.h);
|
||||
}
|
||||
|
||||
|
||||
#endif /* TAG_H */
|
||||
128
src/util.c
Normal file
128
src/util.c
Normal file
@ -0,0 +1,128 @@
|
||||
/*
|
||||
* wmfs2 by Martin Duquesnoy <xorg62@gmail.com> { for(i = 2011; i < 2111; ++i) ©(i); }
|
||||
* For license, see COPYING.
|
||||
*/
|
||||
|
||||
#define _GNU_SOURCE /* vasprintf() */
|
||||
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "util.h"
|
||||
|
||||
/** malloc with error support and size_t overflow protection
|
||||
* \param nmemb number of objects
|
||||
* \param size size of single object
|
||||
* \return non null void pointer
|
||||
*/
|
||||
void*
|
||||
xmalloc(size_t nmemb, size_t size)
|
||||
{
|
||||
void *ret;
|
||||
|
||||
if(SIZE_MAX / nmemb < size)
|
||||
err(EXIT_FAILURE, "xmalloc(%zu, %zu), "
|
||||
"size_t overflow detected", nmemb, size);
|
||||
|
||||
if((ret = malloc(nmemb * size)) == NULL)
|
||||
err(EXIT_FAILURE, "malloc(%zu)", nmemb * size);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
/** calloc with error support
|
||||
* \param nmemb Number of objects
|
||||
* \param size size of single object
|
||||
* \return non null void pointer
|
||||
*/
|
||||
void*
|
||||
xcalloc(size_t nmemb, size_t size)
|
||||
{
|
||||
void *ret;
|
||||
|
||||
if((ret = calloc(nmemb, size)) == NULL)
|
||||
err(EXIT_FAILURE, "calloc(%zu * %zu)", nmemb, size);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
/** asprintf wrapper
|
||||
* \param strp target string
|
||||
* \param fmt format
|
||||
* \return non zero integer
|
||||
*/
|
||||
int
|
||||
xasprintf(char **strp, const char *fmt, ...)
|
||||
{
|
||||
int ret;
|
||||
va_list args;
|
||||
|
||||
va_start(args, fmt);
|
||||
ret = vasprintf(strp, fmt, args);
|
||||
va_end(args);
|
||||
|
||||
if (ret == -1)
|
||||
err(EXIT_FAILURE, "asprintf(%s)", fmt);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
/** strdup with error support
|
||||
* \param str char pointer
|
||||
* \retun non null void pointer
|
||||
*/
|
||||
char *
|
||||
xstrdup(const char *str)
|
||||
{
|
||||
char *ret;
|
||||
|
||||
if (str == NULL || (ret = strdup(str)) == NULL)
|
||||
err(EXIT_FAILURE, "strdup(%s)", str);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
/** Execute a system command
|
||||
* \param cmd Command
|
||||
* \return child pid
|
||||
*/
|
||||
pid_t
|
||||
spawn(const char *format, ...)
|
||||
{
|
||||
char *sh = NULL;
|
||||
char cmd[512];
|
||||
va_list ap;
|
||||
pid_t pid;
|
||||
size_t len;
|
||||
|
||||
va_start(ap, format);
|
||||
len = vsnprintf(cmd, sizeof(cmd), format, ap);
|
||||
va_end(ap);
|
||||
|
||||
if (len >= sizeof(cmd))
|
||||
{
|
||||
warnx("command too long (> 512 bytes)");
|
||||
return -1;
|
||||
}
|
||||
|
||||
if(!(sh = getenv("SHELL")))
|
||||
sh = "/bin/sh";
|
||||
|
||||
if((pid = fork()) == 0)
|
||||
{
|
||||
setsid();
|
||||
if (execl(sh, sh, "-c", cmd, (char*)NULL) == -1)
|
||||
warn("execl(sh -c %s)", cmd);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
else if (pid == -1)
|
||||
warn("fork");
|
||||
|
||||
return pid;
|
||||
}
|
||||
|
||||
void
|
||||
uicb_spawn(Uicb cmd)
|
||||
{
|
||||
spawn("%s", cmd);
|
||||
}
|
||||
63
src/util.h
Normal file
63
src/util.h
Normal file
@ -0,0 +1,63 @@
|
||||
/*
|
||||
* wmfs2 by Martin Duquesnoy <xorg62@gmail.com> { for(i = 2011; i < 2111; ++i) ©(i); }
|
||||
* For license, see COPYING.
|
||||
*/
|
||||
|
||||
#ifndef UTIL_H
|
||||
#define UTIL_H
|
||||
|
||||
#include "wmfs.h"
|
||||
|
||||
/* Todo FREE_LIST(type, head, function_remove) */
|
||||
#define FREE_LIST(type, head) \
|
||||
do { \
|
||||
struct type *Z; \
|
||||
while(!SLIST_EMPTY(&head)) { \
|
||||
Z = SLIST_FIRST(&head); \
|
||||
SLIST_REMOVE_HEAD(&head, next); \
|
||||
free(Z); /* function_remove(t)*/ \
|
||||
} \
|
||||
} while(/* CONSTCOND */ 0);
|
||||
|
||||
/* t is Map or Unmap */
|
||||
#define WIN_STATE(w, t) do { \
|
||||
X##t##Subwindows(W->dpy, w); \
|
||||
X##t##Window(W->dpy, w); \
|
||||
} while( /* CONSTCOND */ 0);
|
||||
|
||||
|
||||
#define ATOM(a) XInternAtom(W->dpy, (a), False)
|
||||
#define LEN(x) (sizeof(x) / sizeof(*x))
|
||||
#define FLAGINT(i) (1 << i)
|
||||
#define ATOI(s) strtol(s, NULL, 10)
|
||||
#define ABS(j) (j < 0 ? -j : j)
|
||||
#define INAREA(i, j, a) ((i) >= (a).x && (i) <= (a).x + (a).w && (j) >= (a).y && (j) <= (a).y + (a).h)
|
||||
|
||||
/*
|
||||
* "#RRGGBB" -> 0xRRGGBB
|
||||
*/
|
||||
static inline Color
|
||||
color_atoh(const char *col)
|
||||
{
|
||||
int shift = (col[0] == '#');
|
||||
|
||||
return (Color)strtol(col + shift, NULL, 16);
|
||||
}
|
||||
|
||||
static inline void
|
||||
swap_ptr(void **x, void **y)
|
||||
{
|
||||
void *t = *x;
|
||||
|
||||
*x = *y;
|
||||
*y = t;
|
||||
}
|
||||
|
||||
void *xmalloc(size_t nmemb, size_t size);
|
||||
void *xcalloc(size_t nmemb, size_t size);
|
||||
int xasprintf(char **strp, const char *fmt, ...);
|
||||
char *xstrdup(const char *str);
|
||||
pid_t spawn(const char *format, ...);
|
||||
void uicb_spawn(Uicb cmd);
|
||||
|
||||
#endif /* UTIL_H */
|
||||
BIN
src/util.o
Normal file
BIN
src/util.o
Normal file
Binary file not shown.
344
src/wmfs.c
Normal file
344
src/wmfs.c
Normal file
@ -0,0 +1,344 @@
|
||||
/*
|
||||
* wmfs2 by Martin Duquesnoy <xorg62@gmail.com> { for(i = 2011; i < 2111; ++i) ©(i); }
|
||||
* For license, see COPYING.
|
||||
*/
|
||||
|
||||
#include <getopt.h>
|
||||
#include <X11/keysym.h>
|
||||
#include <X11/cursorfont.h>
|
||||
|
||||
#include "wmfs.h"
|
||||
#include "event.h"
|
||||
#include "ewmh.h"
|
||||
#include "screen.h"
|
||||
#include "infobar.h"
|
||||
#include "util.h"
|
||||
#include "config.h"
|
||||
#include "client.h"
|
||||
|
||||
int
|
||||
wmfs_error_handler(Display *d, XErrorEvent *event)
|
||||
{
|
||||
char mess[256];
|
||||
|
||||
/* Check if there is another WM running */
|
||||
if(event->error_code == BadAccess
|
||||
&& W->root == event->resourceid)
|
||||
errx(EXIT_FAILURE, "Another Window Manager is already running.");
|
||||
|
||||
/* Ignore focus change error for unmapped client
|
||||
* 42 = X_SetInputFocus
|
||||
* 28 = X_GrabButton
|
||||
*/
|
||||
if(client_gb_win(event->resourceid))
|
||||
if(event->error_code == BadWindow
|
||||
|| event->request_code == 42
|
||||
|| event->request_code == 28)
|
||||
return 0;
|
||||
|
||||
|
||||
if(XGetErrorText(d, event->error_code, mess, 128))
|
||||
warnx("%s(%d) opcodes %d/%d\n resource #%lx\n",
|
||||
mess,
|
||||
event->error_code,
|
||||
event->request_code,
|
||||
event->minor_code,
|
||||
event->resourceid);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int
|
||||
wmfs_error_handler_dummy(Display *d, XErrorEvent *event)
|
||||
{
|
||||
(void)d;
|
||||
(void)event;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void
|
||||
wmfs_numlockmask(void)
|
||||
{
|
||||
int i, j;
|
||||
XModifierKeymap *mm = XGetModifierMapping(W->dpy);
|
||||
|
||||
for(i = 0; i < 8; i++)
|
||||
for(j = 0; j < mm->max_keypermod; ++j)
|
||||
if(mm->modifiermap[i * mm->max_keypermod + j]
|
||||
== XKeysymToKeycode(W->dpy, XK_Num_Lock))
|
||||
W->numlockmask = (1 << i);
|
||||
|
||||
XFreeModifiermap(mm);
|
||||
}
|
||||
|
||||
void
|
||||
wmfs_init_font(char *font, struct theme *t)
|
||||
{
|
||||
XFontStruct **xfs = NULL;
|
||||
char **misschar, **names, *defstring;
|
||||
int d;
|
||||
|
||||
if(!(t->font.fontset = XCreateFontSet(W->dpy, font, &misschar, &d, &defstring)))
|
||||
{
|
||||
warnx("Can't load font '%s'", font);
|
||||
t->font.fontset = XCreateFontSet(W->dpy, "fixed", &misschar, &d, &defstring);
|
||||
}
|
||||
|
||||
XExtentsOfFontSet(t->font.fontset);
|
||||
XFontsOfFontSet(t->font.fontset, &xfs, &names);
|
||||
|
||||
t->font.as = xfs[0]->max_bounds.ascent;
|
||||
t->font.de = xfs[0]->max_bounds.descent;
|
||||
t->font.width = xfs[0]->max_bounds.width;
|
||||
|
||||
t->font.height = t->font.as + t->font.de;
|
||||
|
||||
if(misschar)
|
||||
XFreeStringList(misschar);
|
||||
}
|
||||
|
||||
static void
|
||||
wmfs_xinit(void)
|
||||
{
|
||||
XSetWindowAttributes at =
|
||||
{
|
||||
.event_mask = (KeyMask | ButtonMask | MouseMask
|
||||
| PropertyChangeMask | SubstructureRedirectMask
|
||||
| SubstructureNotifyMask | StructureNotifyMask),
|
||||
.cursor = XCreateFontCursor(W->dpy, XC_left_ptr)
|
||||
};
|
||||
|
||||
/*
|
||||
* X Error handler
|
||||
*/
|
||||
XSetErrorHandler(wmfs_error_handler);
|
||||
|
||||
/*
|
||||
* X var
|
||||
*/
|
||||
W->xscreen = DefaultScreen(W->dpy);
|
||||
W->xdepth = DefaultDepth(W->dpy, W->xscreen);
|
||||
W->gc = DefaultGC(W->dpy, W->xscreen);
|
||||
|
||||
/*
|
||||
* Keys
|
||||
*/
|
||||
wmfs_numlockmask();
|
||||
|
||||
/*
|
||||
* Root window/cursor
|
||||
*/
|
||||
W->root = RootWindow(W->dpy, W->xscreen);
|
||||
XChangeWindowAttributes(W->dpy, W->root, CWEventMask | CWCursor, &at);
|
||||
|
||||
/*
|
||||
* Locale (font encode)
|
||||
*/
|
||||
setlocale(LC_CTYPE, "");
|
||||
|
||||
/*
|
||||
* Barwin linked list
|
||||
*/
|
||||
SLIST_INIT(&W->h.barwin);
|
||||
|
||||
W->running = true;
|
||||
}
|
||||
|
||||
void
|
||||
wmfs_grab_keys(void)
|
||||
{
|
||||
KeyCode c;
|
||||
struct keybind *k;
|
||||
|
||||
wmfs_numlockmask();
|
||||
|
||||
XUngrabKey(W->dpy, AnyKey, AnyModifier, W->root);
|
||||
|
||||
SLIST_FOREACH(k, &W->h.keybind, next)
|
||||
if((c = XKeysymToKeycode(W->dpy, k->keysym)))
|
||||
{
|
||||
XGrabKey(W->dpy, c, k->mod, W->root, True, GrabModeAsync, GrabModeAsync);
|
||||
XGrabKey(W->dpy, c, k->mod | LockMask, W->root, True, GrabModeAsync, GrabModeAsync);
|
||||
XGrabKey(W->dpy, c, k->mod | W->numlockmask, W->root, True, GrabModeAsync, GrabModeAsync);
|
||||
XGrabKey(W->dpy, c, k->mod | LockMask | W->numlockmask, W->root, True, GrabModeAsync, GrabModeAsync);
|
||||
}
|
||||
}
|
||||
|
||||
/** Scan if there are windows on X
|
||||
* for manage it
|
||||
*/
|
||||
static void
|
||||
wmfs_scan(void)
|
||||
{
|
||||
int i, n;
|
||||
XWindowAttributes wa;
|
||||
Window usl, usl2, *w = NULL;
|
||||
|
||||
SLIST_INIT(&W->h.client);
|
||||
|
||||
/*
|
||||
Atom rt;
|
||||
int s, rf, tag = -1, screen = -1, flags = -1, i;
|
||||
ulong ir, il;
|
||||
uchar *ret;
|
||||
*/
|
||||
|
||||
if(XQueryTree(W->dpy, W->root, &usl, &usl2, &w, (unsigned int*)&n))
|
||||
for(i = n - 1; i != -1; --i)
|
||||
{
|
||||
XGetWindowAttributes(W->dpy, w[i], &wa);
|
||||
|
||||
if(!wa.override_redirect && wa.map_state == IsViewable)
|
||||
{/*
|
||||
if(XGetWindowProperty(dpy, w[i], ATOM("_WMFS_TAG"), 0, 32,
|
||||
False, XA_CARDINAL, &rt, &rf, &ir, &il, &ret) == Success && ret)
|
||||
{
|
||||
tag = *ret;
|
||||
XFree(ret);
|
||||
}
|
||||
|
||||
if(XGetWindowProperty(dpy, w[i], ATOM("_WMFS_SCREEN"), 0, 32,
|
||||
False, XA_CARDINAL, &rt, &rf, &ir, &il, &ret) == Success && ret)
|
||||
{
|
||||
screen = *ret;
|
||||
XFree(ret);
|
||||
}
|
||||
|
||||
if(XGetWindowProperty(dpy, w[i], ATOM("_WMFS_FLAGS"), 0, 32,
|
||||
False, XA_CARDINAL, &rt, &rf, &ir, &il, &ret) == Success && ret)
|
||||
{
|
||||
flags = *ret;
|
||||
XFree(ret);
|
||||
}
|
||||
*/
|
||||
/*c = */ client_new(w[i], &wa);
|
||||
|
||||
/*
|
||||
if(tag != -1)
|
||||
c->tag = tag;
|
||||
if(screen != -1)
|
||||
c->screen = screen;
|
||||
if(flags != -1)
|
||||
c->flags = flags;
|
||||
*/
|
||||
}
|
||||
}
|
||||
|
||||
XFree(w);
|
||||
}
|
||||
|
||||
static void
|
||||
wmfs_loop(void)
|
||||
{
|
||||
XEvent ev;
|
||||
|
||||
while(XPending(W->dpy))
|
||||
while(W->running && !XNextEvent(W->dpy, &ev))
|
||||
EVENT_HANDLE(&ev);
|
||||
}
|
||||
|
||||
static inline void
|
||||
wmfs_init(void)
|
||||
{
|
||||
wmfs_xinit();
|
||||
ewmh_init();
|
||||
screen_init();
|
||||
event_init();
|
||||
config_init();
|
||||
}
|
||||
|
||||
void
|
||||
wmfs_quit(void)
|
||||
{
|
||||
struct keybind *k;
|
||||
struct theme *t;
|
||||
|
||||
/* Will free:
|
||||
*
|
||||
* Screens -> tags
|
||||
* -> Infobars -> Elements
|
||||
*/
|
||||
screen_free();
|
||||
|
||||
XCloseDisplay(W->dpy);
|
||||
|
||||
/* Conf stuffs */
|
||||
while(!SLIST_EMPTY(&W->h.keybind))
|
||||
{
|
||||
k = SLIST_FIRST(&W->h.keybind);
|
||||
SLIST_REMOVE_HEAD(&W->h.keybind, next);
|
||||
free((void*)k->cmd);
|
||||
free(k);
|
||||
}
|
||||
|
||||
while(!SLIST_EMPTY(&W->h.theme))
|
||||
{
|
||||
t = SLIST_FIRST(&W->h.theme);
|
||||
SLIST_REMOVE_HEAD(&W->h.theme, next);
|
||||
XFreeFontSet(W->dpy, t->font.fontset);
|
||||
free(t);
|
||||
}
|
||||
|
||||
free(W->net_atom);
|
||||
free(W);
|
||||
|
||||
W->running = false;
|
||||
}
|
||||
|
||||
/** Reload WMFS binary
|
||||
*/
|
||||
void
|
||||
uicb_reload(Uicb cmd)
|
||||
{
|
||||
(void)cmd;
|
||||
/* TODO */
|
||||
}
|
||||
|
||||
void
|
||||
uicb_quit(Uicb cmd)
|
||||
{
|
||||
(void)cmd;
|
||||
W->running = false;
|
||||
}
|
||||
|
||||
int
|
||||
main(int argc, char **argv)
|
||||
{
|
||||
W = (struct wmfs*)xcalloc(1, sizeof(struct wmfs));
|
||||
|
||||
|
||||
/* Get X display */
|
||||
if(!(W->dpy = XOpenDisplay(NULL)))
|
||||
{
|
||||
fprintf(stderr, "%s: Can't open X server\n", argv[0]);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
/* Opt */
|
||||
/*
|
||||
int i;
|
||||
while((i = getopt(argc, argv, "hviC:")) != -1)
|
||||
{
|
||||
switch(i)
|
||||
{
|
||||
case 'h':
|
||||
break;
|
||||
case 'v':
|
||||
break;
|
||||
case 'C':
|
||||
break;
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
/* Core */
|
||||
wmfs_init();
|
||||
wmfs_scan();
|
||||
|
||||
wmfs_loop();
|
||||
|
||||
wmfs_quit();
|
||||
|
||||
return 1;
|
||||
}
|
||||
210
src/wmfs.h
Normal file
210
src/wmfs.h
Normal file
@ -0,0 +1,210 @@
|
||||
/*
|
||||
* wmfs2 by Martin Duquesnoy <xorg62@gmail.com> { for(i = 2011; i < 2111; ++i) ©(i); }
|
||||
* For license, see COPYING.
|
||||
*/
|
||||
|
||||
#ifndef WMFS_H
|
||||
#define WMFS_H
|
||||
|
||||
/* Standard */
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdarg.h>
|
||||
#include <signal.h>
|
||||
#include <unistd.h>
|
||||
#include <locale.h>
|
||||
#include <err.h>
|
||||
#include <sys/queue.h>
|
||||
|
||||
/* Xlib */
|
||||
#include <X11/Xlib.h>
|
||||
#include <X11/Xatom.h>
|
||||
|
||||
/* Local */
|
||||
|
||||
#define ButtonMask (ButtonPressMask | ButtonReleaseMask | ButtonMotionMask)
|
||||
#define MouseMask (ButtonMask | PointerMotionMask)
|
||||
#define KeyMask (KeyPressMask | KeyReleaseMask)
|
||||
|
||||
typedef unsigned int Flags;
|
||||
typedef unsigned int Color;
|
||||
typedef const char* Uicb;
|
||||
typedef enum { BarTop = 0, BarBottom, BarHide, BarLast } Barpos;
|
||||
typedef enum { Right = 0, Left, Top, Bottom, Center, PositionLast } Position;
|
||||
|
||||
/*
|
||||
* Structures
|
||||
*/
|
||||
|
||||
struct geo
|
||||
{
|
||||
int x, y, w, h;
|
||||
};
|
||||
|
||||
struct barwin
|
||||
{
|
||||
struct geo geo;
|
||||
Window win;
|
||||
Drawable dr;
|
||||
Color fg, bg;
|
||||
void *ptr; /* Special cases */
|
||||
SLIST_HEAD(, mousebind) mousebinds;
|
||||
SLIST_ENTRY(barwin) next; /* global barwin */
|
||||
SLIST_ENTRY(barwin) enext; /* element barwin */
|
||||
};
|
||||
|
||||
struct element
|
||||
{
|
||||
struct geo geo;
|
||||
struct infobar *infobar;
|
||||
int type;
|
||||
void (*func_init)(struct element *e);
|
||||
void (*func_update)(struct element *e);
|
||||
SLIST_HEAD(, barwin) bars;
|
||||
TAILQ_ENTRY(element) next;
|
||||
};
|
||||
|
||||
struct infobar
|
||||
{
|
||||
struct barwin *bar;
|
||||
struct geo geo;
|
||||
struct screen *screen;
|
||||
struct theme *theme;
|
||||
char *elemorder;
|
||||
Barpos pos;
|
||||
TAILQ_HEAD(esub, element) elements;
|
||||
SLIST_ENTRY(infobar) next;
|
||||
};
|
||||
|
||||
struct screen
|
||||
{
|
||||
struct geo geo, ugeo;
|
||||
struct tag *seltag;
|
||||
int id;
|
||||
Flags elemupdate;
|
||||
TAILQ_HEAD(tsub, tag) tags;
|
||||
SLIST_HEAD(, infobar) infobars;
|
||||
SLIST_ENTRY(screen) next;
|
||||
};
|
||||
|
||||
struct tag
|
||||
{
|
||||
struct screen *screen;
|
||||
struct client *sel;
|
||||
char *name;
|
||||
Flags flags;
|
||||
Window frame;
|
||||
SLIST_HEAD(, client) clients;
|
||||
TAILQ_ENTRY(tag) next;
|
||||
};
|
||||
|
||||
struct client
|
||||
{
|
||||
struct tag *tag;
|
||||
struct screen *screen;
|
||||
struct barwin *titlebar;
|
||||
struct geo geo, tgeo, wgeo;
|
||||
char *title;
|
||||
Flags flags;
|
||||
Window win;
|
||||
SLIST_ENTRY(client) next; /* Global list */
|
||||
SLIST_ENTRY(client) tnext; /* struct tag list */
|
||||
};
|
||||
|
||||
struct keybind
|
||||
{
|
||||
unsigned int mod;
|
||||
void (*func)(Uicb);
|
||||
Uicb cmd;
|
||||
KeySym keysym;
|
||||
SLIST_ENTRY(keybind) next;
|
||||
};
|
||||
|
||||
struct mousebind
|
||||
{
|
||||
struct geo area;
|
||||
unsigned int button;
|
||||
bool use_area;
|
||||
void (*func)(Uicb);
|
||||
Uicb cmd;
|
||||
SLIST_ENTRY(mousebind) next;
|
||||
};
|
||||
|
||||
struct colpair
|
||||
{
|
||||
Color fg, bg;
|
||||
};
|
||||
|
||||
struct theme
|
||||
{
|
||||
char *name;
|
||||
|
||||
/* Font */
|
||||
struct
|
||||
{
|
||||
int as, de, width, height;
|
||||
XFontSet fontset;
|
||||
} font;
|
||||
|
||||
/* Bars */
|
||||
struct colpair bars;
|
||||
int bars_width;
|
||||
|
||||
/* struct elements */
|
||||
struct colpair tags_n, tags_s; /* normal / selected */
|
||||
int tags_border_width;
|
||||
Color tags_border_col;
|
||||
|
||||
/* client / frame */
|
||||
struct colpair client_n, client_s;
|
||||
Color frame_bg;
|
||||
int client_titlebar_width;
|
||||
int client_border_width;
|
||||
|
||||
SLIST_ENTRY(theme) next;
|
||||
};
|
||||
|
||||
struct wmfs
|
||||
{
|
||||
/* X11 stuffs */
|
||||
Display *dpy;
|
||||
Window root;
|
||||
int xscreen, xdepth;
|
||||
Flags numlockmask;
|
||||
GC gc;
|
||||
Atom *net_atom;
|
||||
bool running;
|
||||
|
||||
/* Lists heads */
|
||||
struct
|
||||
{
|
||||
SLIST_HEAD(, screen) screen;
|
||||
SLIST_HEAD(, client) client;
|
||||
SLIST_HEAD(, keybind) keybind;
|
||||
SLIST_HEAD(, barwin) barwin;
|
||||
SLIST_HEAD(, theme) theme;
|
||||
} h;
|
||||
|
||||
/*
|
||||
* Selected screen, client
|
||||
*/
|
||||
struct screen *screen;
|
||||
struct client *client;
|
||||
|
||||
};
|
||||
|
||||
int wmfs_error_handler(Display *d, XErrorEvent *event);
|
||||
int wmfs_error_handler_dummy(Display *d, XErrorEvent *event);
|
||||
void wmfs_grab_keys(void);
|
||||
void wmfs_numlockmask(void);
|
||||
void wmfs_init_font(char *font, struct theme *t);
|
||||
void wmfs_quit(void);
|
||||
void uicb_reload(Uicb cmd);
|
||||
void uicb_quit(Uicb cmd);
|
||||
|
||||
|
||||
/* Single global variable */
|
||||
struct wmfs *W;
|
||||
|
||||
#endif /* WMFS_H */
|
||||
BIN
src/wmfs.o
Normal file
BIN
src/wmfs.o
Normal file
Binary file not shown.
149
wmfsrc2
Normal file
149
wmfsrc2
Normal file
@ -0,0 +1,149 @@
|
||||
#
|
||||
# WMFS2 configuration file
|
||||
#
|
||||
|
||||
[themes]
|
||||
|
||||
|
||||
[theme]
|
||||
# name = "default"
|
||||
|
||||
font = "fixed"
|
||||
|
||||
# Bars
|
||||
bars_width = 14
|
||||
bars_fg = "#CCCCCC"
|
||||
bars_bg = "#222222"
|
||||
|
||||
# Element tags
|
||||
tags_normal_fg = "#CCCCCC"
|
||||
tags_normal_bg = "#222222"
|
||||
tags_sel_fg = "#222222"
|
||||
tags_sel_bg = "#CCCCCC"
|
||||
tags_border_color = "#888888"
|
||||
tags_border_width = 1
|
||||
|
||||
# Frame / Client
|
||||
client_normal_fg = "#CCCCCC"
|
||||
client_normal_bg = "#222222"
|
||||
client_sel_fg = "#222222"
|
||||
client_sel_bg = "#CCCCCC"
|
||||
frame_bg = "#555555"
|
||||
client_titlebar_width = 12 #useless for now
|
||||
client_border_width = 1
|
||||
|
||||
[/theme]
|
||||
|
||||
[theme]
|
||||
name = "perso"
|
||||
|
||||
font = "-*-fixed-bold"
|
||||
|
||||
bars_width = 20
|
||||
bars_fg = "#222222"
|
||||
bars_bg = "#CCCCCC"
|
||||
|
||||
tags_sel_bg = "#33AA33"
|
||||
tags_normal_fg = "#AA3333"
|
||||
|
||||
[/theme]
|
||||
|
||||
[/themes]
|
||||
|
||||
[bars]
|
||||
|
||||
# Position:
|
||||
# 0 Top
|
||||
# 1 Bottom
|
||||
# 2 Hide
|
||||
|
||||
# Element type:
|
||||
# t Tags
|
||||
# S Statustext
|
||||
|
||||
[bar]
|
||||
position = 1
|
||||
screen = 0
|
||||
elements = "t"
|
||||
theme = "perso"
|
||||
[/bar]
|
||||
|
||||
[bar]
|
||||
position = 1
|
||||
screen = 0
|
||||
elements = "t"
|
||||
theme = "default"
|
||||
[/bar]
|
||||
|
||||
[bar]
|
||||
screen = 1
|
||||
elements = "t"
|
||||
theme = "perso"
|
||||
[/bar]
|
||||
[bar]
|
||||
screen = 1
|
||||
elements = "t"
|
||||
theme = "default"
|
||||
[/bar]
|
||||
|
||||
|
||||
[/bars]
|
||||
|
||||
[tags]
|
||||
|
||||
[tag] screen = 0 name = "one" [/tag]
|
||||
[tag] screen = 0 name = "two" [/tag]
|
||||
[tag] screen = 0 name = "three" [/tag]
|
||||
|
||||
[tag] screen = 1 name = "four" [/tag]
|
||||
[tag] screen = 1 name = "five" [/tag]
|
||||
|
||||
[tag] name = "universal tag" [/tag]
|
||||
|
||||
[/tags]
|
||||
|
||||
[keys]
|
||||
|
||||
[key] mod = {"Super"} key = "Return" func = "spawn" cmd = "xterm" [/key]
|
||||
[key] mod = {"Control","Alt"} key = "q" func = "quit" [/key]
|
||||
[key] mod = {"Super"} key = "1" func = "tag_set" cmd = "1" [/key]
|
||||
[key] mod = {"Super"} key = "2" func = "tag_set" cmd = "2" [/key]
|
||||
[key] mod = {"Super"} key = "3" func = "tag_set" cmd = "3" [/key]
|
||||
[key] mod = {"Super"} key = "s" func = "tag_next" [/key]
|
||||
[key] mod = {"Super"} key = "a" func = "tag_prev" [/key]
|
||||
[key] mod = {"Super"} key = "z" func = "tag" cmd = "tag2" [/key]
|
||||
|
||||
[key] mod = {"Super"} key = "q" func = "client_close" [/key]
|
||||
|
||||
# Focus next / prev client
|
||||
[key] mod = { "Alt" } key = "Tab" func = "client_focus_next" [/key][key] mod = { "Alt", "Shift" } key = "Tab" func = "client_focus_prev" [/key]
|
||||
|
||||
# Focus next client with direction
|
||||
[key] mod = {"Alt"} key = "h" func = "client_focus_left" [/key]
|
||||
[key] mod = {"Alt"} key = "l" func = "client_focus_right" [/key]
|
||||
[key] mod = {"Alt"} key = "k" func = "client_focus_top" [/key]
|
||||
[key] mod = {"Alt"} key = "j" func = "client_focus_bottom" [/key]
|
||||
|
||||
# swap next client with direction:
|
||||
[key] mod = {"Control", "Shift"} key = "h" func = "client_swap_left" [/key]
|
||||
[key] mod = {"Control", "Shift"} key = "l" func = "client_swap_right" [/key]
|
||||
[key] mod = {"Control", "Shift"} key = "k" func = "client_swap_top" [/key]
|
||||
[key] mod = {"Control", "Shift"} key = "j" func = "client_swap_bottom" [/key]
|
||||
|
||||
# Resize selected tiled client with direction
|
||||
[key] mod = {"Super"} key = "h" func = "client_resize_left" cmd = "20" [/key]
|
||||
[key] mod = {"Super"} key = "l" func = "client_resize_left" cmd = "-20" [/key]
|
||||
[key] mod = {"Super"} key = "k" func = "client_resize_top" cmd = "20" [/key]
|
||||
[key] mod = {"Super"} key = "j" func = "client_resize_top" cmd = "-20" [/key]
|
||||
[key] mod = {"Super", "Control"} key = "h" func = "client_resize_right" cmd = "-20" [/key]
|
||||
[key] mod = {"Super", "Control"} key = "l" func = "client_resize_right" cmd = "20" [/key]
|
||||
[key] mod = {"Super", "Control"} key = "k" func = "client_resize_bottom" cmd = "-20" [/key]
|
||||
[key] mod = {"Super", "Control"} key = "j" func = "client_resize_bottom" cmd = "20" [/key]
|
||||
|
||||
# Layout manipulation
|
||||
[key] mod = {"Super"} key = "m" func = "layout_vmirror" [/key]
|
||||
[key] mod = {"Super", "Shift"} key = "m" func = "layout_hmirror" [/key]
|
||||
[key] mod = {"Super"} key = "r" func = "layout_rotate_right" [/key]
|
||||
[key] mod = {"Super", "Shift"} key = "r" func = "layout_rotate_left" [/key]
|
||||
|
||||
[/keys]
|
||||
Loading…
x
Reference in New Issue
Block a user