mirrors/wmii
1
0
Fork 0
mirror of https://github.com/0intro/wmii synced 2024-11-22 13:52:17 +03:00
Code Issues Packages Projects Releases Wiki Activity

More info from /tag/*/ctl.

Browse Source
This commit is contained in:
Kris Maglione 2007-06-17 13:30:10 -04:00
parent d7c68da518
commit 13e3c32a79
10 changed files with 283 additions and 193 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
cmd/wmii/area.c
View File

@ -20,6 +20,28 @@ area_selclient(Area *a) {
return nil;
}
uint
area_idx(Area *a) {
View *v;
Area *ap;
uint i;
v = a->view;
for(i = 0, ap = v->area; a != ap; ap = ap->next)
i++;
return i;
}
char*
area_name(Area *a) {
static char buf[16];
if(a->floating)
return "~";
snprintf(buf, sizeof(buf), "%d", area_idx(a));
return buf;
}
Area *
create_area(View *v, Area *pos, uint w) {
static ushort id = 1;
@ -234,11 +256,13 @@ detach_from_area(Frame *f) {
cp = win2client(c->trans);
if(cp && cp->frame) {
a = cp->sel->area;
if(a->view == v)
if(a->view == v) {
focus_area(a);
return;
}
}
}
else if(v->area->next->frame)
if(v->area->next->frame)
focus_area(v->area->next);
}else
assert(a->sel);

7
cmd/wmii/column.c
View File

@ -30,6 +30,13 @@ str2colmode(const char *str) {
return -1;
}
char*
colmode2str(int i) {
if(i < nelem(modes))
return modes[i];
return nil;
}
static Divide*
getdiv(Divide **dp) {
WinAttr wa;

15
cmd/wmii/event.c
View File

@ -134,7 +134,6 @@ focusin(XEvent *e) {
XFocusChangeEvent *ev;
Window *w;
Client *c;
XEvent me;
ev = &e->xfocus;
/* Yes, we're focusing in on nothing, here. */
@ -162,13 +161,9 @@ focusin(XEvent *e) {
handle(w, focusin, ev);
else if(ev->mode == NotifyGrab) {
if(ev->window == scr.root.w)
if(XCheckMaskEvent(display, KeyPressMask, &me)) {
/* wmii has grabbed focus */
screen->hasgrab = &c_root;
dispatch_event(&me);
}
screen->hasgrab = &c_root;
/* Some unmanaged window has grabbed focus */
if((c = screen->focus)) {
else if((c = screen->focus)) {
print_focus(&c_magic, "<magic>");
screen->focus = &c_magic;
if(c->sel)
@ -179,6 +174,7 @@ focusin(XEvent *e) {
static void
focusout(XEvent *e) {
XEvent me;
XFocusChangeEvent *ev;
Window *w;
@ -192,7 +188,10 @@ focusout(XEvent *e) {
if(ev->mode == NotifyUngrab)
screen->hasgrab = nil;
if((w = findwin(ev->window)))
if((ev->mode == NotifyGrab)
&& XCheckMaskEvent(display, KeyPressMask, &me))
dispatch_event(&me);
else if((w = findwin(ev->window)))
handle(w, focusout, ev);
}

5
cmd/wmii/fns.h
View File

@ -3,6 +3,8 @@
*/
/* area.c */
char *area_name(Area *a);
uint area_idx(Area *a);
Area *create_area(View*, Area *pos, uint w);
void destroy_area(Area*);
Area *area_of_id(View*, ushort id);
@ -60,6 +62,7 @@ void arrange_column(Area*, Bool dirty);
void resize_column(Area*, int w);
void resize_colframe(Frame*, Rectangle*);
int str2colmode(const char *str);
char *colmode2str(int i);
Area *new_column(View*, Area *pos, uint w);
/* event.c */
@ -69,6 +72,7 @@ uint flushevents(long even_mask, Bool dispatch);
void print_focus(Client *c, char *to);
/* frame.c */
uint frame_idx(Frame *f);
Frame *create_frame(Client*, View*);
void remove_frame(Frame*);
void insert_frame(Frame *pos, Frame*);
@ -157,6 +161,7 @@ Client *view_selclient(View*);
char *message_view(View *v, Message *m);
void restack_view(View*);
uchar *view_index(View*);
uchar *view_ctl(View *v);
void destroy_view(View*);
void update_views(void);
uint newcolw(View*, int i);

11
cmd/wmii/frame.c
View File

@ -7,6 +7,17 @@
#include "dat.h"
#include "fns.h"
uint
frame_idx(Frame *f) {
Frame *fp;
uint i;
fp = f->area->frame;
for(i = 1; fp != f; fp = fp->anext)
i++;
return i;
}
Frame *
create_frame(Client *c, View *v) {
static ushort id = 1;

10
cmd/wmii/fs.c
View File

@ -639,10 +639,6 @@ fs_read(Ixp9Req *r) {
write_buf(r, f->p.client->name, strlen(f->p.client->name));
respond(r, nil);
return;
case FsFTctl:
write_buf(r, f->p.view->name, strlen(f->p.view->name));
respond(r, nil);
return;
case FsFBar:
write_buf(r, f->p.bar->buf, strlen(f->p.bar->buf));
respond(r, nil);
@ -669,6 +665,12 @@ fs_read(Ixp9Req *r) {
write_buf(r, buf, n);
respond(r, nil);
return;
case FsFTctl:
buf = (char*)view_ctl(f->p.view);
n = strlen(buf);
write_buf(r, buf, n);
respond(r, nil);
return;
case FsFEvent:
respond_event(r);
return;

3
cmd/wmii/key.c
View File

@ -182,9 +182,8 @@ kpress_seq(XWindow w, Key *done) {
if((done->mod == mod) && (done->key == key))
emulate_key_press(mod, key); /* double key */
else {
if(!found) {
if(!found)
XBell(display, 0);
} /* grabbed but not found */
else if(!found->tnext && !found->next)
write_event("Key %s\n", found->name);
else

59
cmd/wmii/view.c
View File

@ -331,45 +331,68 @@ rects_of_view(View *v, uint *num, Frame *ignore) {
/* XXX: This will need cleanup */
uchar *
view_index(View *v) {
Rectangle *r;
Frame *f;
Area *a;
char *buf;
uint i, n;
int len;
char *buf, *end;
uint i;
len = sizeof(buffer);
buf = buffer;
for((a=v->area), (i=0); a && len > 0; (a=a->next), i++) {
end = buffer+sizeof(buffer);
for((a=v->area), (i=0); a && buf < end-1; (a=a->next), i++) {
if(a->floating)
n = snprintf(buf, len, "# ~ %d %d\n",
buf += snprintf(buf, end-buf, "# ~ %d %d\n",
Dx(a->r), Dy(a->r));
else
n = snprintf(buf, len, "# %d %d %d\n",
buf += snprintf(buf, end-buf, "# %d %d %d\n",
i, a->r.min.x, Dx(a->r));
buf += n;
len -= n;
for(f=a->frame; f && len > 0; f=f->anext) {
Rectangle *r = &f->r;
for(f=a->frame; f && buf < end-1; f=f->anext) {
r = &f->r;
if(a->floating)
n = snprintf(buf, len, "~ 0x%x %d %d %d %d %s\n",
buf += snprintf(buf, end-buf, "~ 0x%x %d %d %d %d %s\n",
(uint)f->client->w.w,
r->min.x, r->min.y, Dx(*r), Dy(*r),
r->min.x, r->min.y,
Dx(*r), Dy(*r),
f->client->props);
else
n = snprintf(buf, len, "%d 0x%x %d %d %s\n",
buf += snprintf(buf, end-buf, "%d 0x%x %d %d %s\n",
i, (uint)f->client->w.w,
r->min.y, Dy(*r),
f->client->props);
if(len - n < 0)
return (uchar*)buffer;
buf += n;
len -= n;
}
}
return (uchar*)buffer;
}
uchar *
view_ctl(View *v) {
Area *a;
char *buf, *end;
uint i;
buf = buffer;
end = buffer+sizeof(buffer);
buf += snprintf(buf, end-buf, "%s\n", v->name);
/* select <area>[ <frame>] */
buf += snprintf(buf, end-buf, "select %s", area_name(v->sel));
if(v->sel->sel)
buf += snprintf(buf, end-buf, " %d", frame_idx(v->sel->sel));
buf += snprintf(buf, end-buf, "\n");
/* select client <client> */
if(v->sel->sel)
buf += snprintf(buf, end-buf, "select client 0x%x\n", clientwin(v->sel->sel->client));
for(a = v->area->next, i = 1; a && buf < end-1; a = a->next, i++) {
buf += snprintf(buf, end-buf, "colmode %d %s\n",
i, colmode2str(a->mode));
}
return (uchar*)buffer;
}
void
update_views(void) {
View *n, *v, *old;

176
man/wmii.1
View File

@ -1,5 +1,5 @@
'\" t
.\" Manual page created with latex2man on Mon Jun 11 12:08:17 EDT 2007
.\" Manual page created with latex2man on Mon Jun 11 15:48:33 EDT 2007
.\" NOTE: This file is generated, DO NOT EDIT.
.de Vb
.ft CW
@ -28,130 +28,137 @@ wmii
.PP
wmii
is a dynamic window manager for X11. In contrast to
static window management the user rarely has to think about how to
organize windows, no matter what he is doing or how many
applications are used at the same time. The window manager adapts
to the current environment and fits to the needs of the user, rather
than forcing him to use a preset, fixed layout and trying to
shoehorn all windows and applications into it.
static window management the user rarely has to think about how
to organize windows, no matter what he is doing or how many
applications are used at the same time. The window manager
adapts to the current environment and fits to the needs of the
user, rather than forcing him to use a preset, fixed layout and
trying to shoehorn all windows and applications into it.
.PP
wmii
supports classic and tiled window management with
extended keyboard and mouse control. The classic window management
arranges windows in a floating layer in which windows can be moved
and resized freely. The tiled window management is based on columns
which split up the screen horizontally. Each column handles
arbitrary windows and arranges them vertically in a nonoverlapping
way. They can then be moved and resized between and within columns
at will.
extended keyboard and mouse control. The classic window
management arranges windows in a floating layer in which windows
can be moved and resized freely. The tiled window management is
based on columns which split up the screen horizontally. Each
column handles arbitrary windows and arranges them vertically in
a nonoverlapping way. They can then be moved and resized
between and within columns at will.
.PP
wmii
provides a virtual filesystem which represents the
internal state similar to the procfs of Unix operating systems.
Modifying this virtual filesystem results in changing the state of
the window manager. The virtual filesystem service can be accessed
through 9Pcapable client programs, like \fIwmiir\fP(1)\&.
This
allows simple and powerful remote control of the core window
manager.
Modifying this virtual filesystem results in changing the state
of the window manager. The virtual filesystem service can be
accessed through 9Pcapable client programs, like
\fIwmiir\fP(1)\&.
This allows simple and powerful remote control
of the core window manager.
.PP
wmii
basically consists of clients, columns, views, and the
bar, which are described in detail in the \fBTerminology\fP
basically consists of clients, columns, views, and
the bar, which are described in detail in the
\fBTerminology\fP
section.
.PP
.SS TERMINOLOGY
.PP
.TP
Display
A running X server instance consisting of input devices
and screens.
A running X server instance consisting of input
devices and screens.
.TP
Screen
A physical or virtual (Xinerama or \fIXnest\fP(1))
screen
of an X display. A screen displays a bar window and a view at a time.
screen of an X display. A screen displays a bar window
and a view at a time.
.TP
Window
A (rectangular) drawable X object which is displayed on a
screen, usually an application window.
A (rectangular) drawable X object which is
displayed on a screen, usually an application window.
.TP
Client
An application window surrounded by a frame window containing
a border and a titlebar.
An application window surrounded by a frame window
containing a border and a titlebar.
.TP
Floating layer
A screen layer of wmii
on top of all other
layers, where clients are arranged in a classic (floating) way.
They can be resized or moved freely.
on top of
all other layers, where clients are arranged in a
classic (floating) way. They can be resized or moved
freely.
.TP
Managed layer
A screen layer of wmii
behind the floating layer,
where clients are arranged in a nonoverlapping (managed) way. Here,
the window manager dynamically assigns each client a size and position.
The managed layer consists of columns.
behind the
floating layer, where clients are arranged in a
nonoverlapping (managed) way. Here, the window
manager dynamically assigns each client a size and
position. The managed layer consists of columns.
.TP
Tag
Alphanumeric strings which can be assigned to a client. This provides
a mechanism to group clients with similar properties. Clients can have one
tag, e.g. \fIwork\fP,
Alphanumeric strings which can be assigned to a
client. This provides a mechanism to group clients with
similar properties. Clients can have one tag, e.g.
\fIwork\fP,
or several tags, e.g. \fIwork+mail\fP\&.
.PP
Tags are separated with the \fI+\fP
character.
.TP
View
A set of clients containing a specific tag, quite similiar to a
workspace in other window managers. It consists of the floating and
managed layers.
A set of clients containing a specific tag, quite
similiar to a workspace in other window managers. It
consists of the floating and managed layers.
.TP
Column
A column is a screen area which arranges clients vertically in a
non\-overlapping way. Columns provide three different modes, which
arrange clients with equal size, stacked, or maximized respectively.
Clients can be moved and resized between and within columns freely.
A column is a screen area which arranges clients
vertically in a non\-overlapping way. Columns provide
three different modes, which arrange clients with equal
size, stacked, or maximized respectively. Clients can
be moved and resized between and within columns freely.
.TP
Bar
The bar at the bottom of the screen displays a label for each view and
allows the creation of arbitrary userdefined labels.
The bar at the bottom of the screen displays a label
for each view and allows the creation of arbitrary
userdefined labels.
.TP
Event
An event is a message which can be read from a special file in the
filesystem of wmii,
such as a mouse button press, a key press, or
a message written by a different 9P\-client.
An event is a message which can be read from a
special file in the filesystem of wmii,
such as a
mouse button press, a key press, or a message written by
a different 9P\-client.
.PP
.SS BASIC WINDOW MANAGEMENT
.PP
Running a raw wmii
process without a \fIwmiirc\fP(1)
script
provides basic window management capabilities already. However, to
use it effectively, remote control through its filesystem interface
is necessary. By default it is only usable with the mouse in
conjunction with the \fIMod1 (Alt)\fP
modifier key. Other
interactions, such as customizing the style, killing or retagging
clients, and grabbing keys, cannot be achieved without accessing the
filesystem.
script provides basic window management capabilities already.
However, to use it effectively, remote control through its
filesystem interface is necessary. By default it is only usable
with the mouse in conjunction with the \fIMod1 (Alt)\fP
modifier key. Other interactions, such as customizing the style,
killing or retagging clients, and grabbing keys, cannot be
achieved without accessing the filesystem.
.PP
The filesystem can be accessed by connecting to the \fIaddress\fP
The filesystem can be accessed by connecting to the
\fIaddress\fP
of wmii
with any 9P\-capable client, such as \fIwmiir\fP(1)
with any 9P\-capable client, such
as \fIwmiir\fP(1)
.PP
.SS ACTIONS
.PP
An action is a shell script in the default setup, but it can
actually be any executable file. It is executed usually by
selecting it from the actions menu. You can customize an action by
copying it from the global action directory
selecting it from the actions menu. You can customize an action
by copying it from the global action directory
CONFPREFIX/wmii\-3.5
to $HOME/.wmii\-3.5
and then
editing the copy to fit your needs. Of course you can also create
your own actions there; make sure that they are executable.
editing the copy to fit your needs. Of course you can also
create your own actions there; make sure that they are
executable.
.PP
Here is a list of the default actions:
.PP
@ -346,9 +353,9 @@ If you feel the need to change the default configuration, then
customize (as described above) the wmiirc
action. This
action is executed at the end of the wmii
script and does all
the work of setting up the window manager, the key bindings, the bar
labels, etc.
script and does
all the work of setting up the window manager, the key bindings,
the bar labels, etc.
.PP
.SH FILESYSTEM
.PP
@ -556,15 +563,16 @@ Returns a clients class and label as:
tags
Set or read a client\&'s tags. Tags are seperated by
\fI+\fP
or {\-}. Tags begining with \fI+\fP
are added,
while those begining with \fI\-\fP
are removed. If the
tag string written begins with \fI+\fP
or \fI\-\fP,
the
written tags are added to or removed from the client\&'s
set, otherwise, the set is overwritten.
or \fI\-\fP\&.
Tags begining with \fI+\fP
are
added, while those begining with \fI\-\fP
are removed.
If the tag string written begins with \fI+\fP
or
\fI\-\fP,
the written tags are added to or removed from
the client\&'s set, otherwise, the set is overwritten.
.PP
.SS The /tag/ Hierarchy
.PP
@ -648,13 +656,15 @@ them.
.PP
.TP
/tmp/ns.USER.{DISPLAY%\&.0}/wmii
The wmii socket file which provides a 9P service.
The wmii socket file
which provides a 9P service.
.TP
CONFPREFIX/wmii\-3.5
Global action directory.
.TP
$HOME/.wmii\-3.5
User\-specific action directory. Actions are first searched here.
User\-specific action directory. Actions
are first searched here.
.PP
.SH ENVIRONMENT
.PP

162
man/wmii.tex
View File

@ -11,94 +11,102 @@
\subsection{Overview}
\Prog{wmii} is a dynamic window manager for X11. In contrast to
static window management the user rarely has to think about how to
organize windows, no matter what he is doing or how many
applications are used at the same time. The window manager adapts
to the current environment and fits to the needs of the user, rather
than forcing him to use a preset, fixed layout and trying to
shoehorn all windows and applications into it.
static window management the user rarely has to think about how
to organize windows, no matter what he is doing or how many
applications are used at the same time. The window manager
adapts to the current environment and fits to the needs of the
user, rather than forcing him to use a preset, fixed layout and
trying to shoehorn all windows and applications into it.
\Prog{wmii} supports classic and tiled window management with
extended keyboard and mouse control. The classic window management
arranges windows in a floating layer in which windows can be moved
and resized freely. The tiled window management is based on columns
which split up the screen horizontally. Each column handles
arbitrary windows and arranges them vertically in a non\-overlapping
way. They can then be moved and resized between and within columns
at will.
extended keyboard and mouse control. The classic window
management arranges windows in a floating layer in which windows
can be moved and resized freely. The tiled window management is
based on columns which split up the screen horizontally. Each
column handles arbitrary windows and arranges them vertically in
a non\-overlapping way. They can then be moved and resized
between and within columns at will.
\Prog{wmii} provides a virtual filesystem which represents the
internal state similar to the procfs of Unix operating systems.
Modifying this virtual filesystem results in changing the state of
the window manager. The virtual filesystem service can be accessed
through 9P\-capable client programs, like \Cmd{wmiir}{1}. This
allows simple and powerful remote control of the core window
manager.
Modifying this virtual filesystem results in changing the state
of the window manager. The virtual filesystem service can be
accessed through 9P\-capable client programs, like
\Cmd{wmiir}{1}. This allows simple and powerful remote control
of the core window manager.
\Prog{wmii} basically consists of clients, columns, views, and the
bar, which are described in detail in the \textbf{Terminology}
section.
\Prog{wmii} basically consists of clients, columns, views, and
the bar, which are described in detail in the
\textbf{Terminology} section.
\subsection{Terminology}
\begin{description}
\item[Display] A running X server instance consisting of input devices
and screens.
\item[Screen] A physical or virtual (Xinerama or \Cmd{Xnest}{1}) screen
of an X display. A screen displays a bar window and a view at a time.
\item[Window] A (rectangular) drawable X object which is displayed on a
screen, usually an application window.
\item[Client] An application window surrounded by a frame window containing
a border and a titlebar.
\item[Floating layer] A screen layer of \Prog{wmii} on top of all other
layers, where clients are arranged in a classic (floating) way.
They can be resized or moved freely.
\item[Managed layer] A screen layer of \Prog{wmii} behind the floating layer,
where clients are arranged in a non\-overlapping (managed) way. Here,
the window manager dynamically assigns each client a size and position.
The managed layer consists of columns.
\item[Tag] Alphanumeric strings which can be assigned to a client. This provides
a mechanism to group clients with similar properties. Clients can have one
tag, e.g. \emph{work}, or several tags, e.g. \emph{work+mail}.
\item[Display] A running X server instance consisting of input
devices and screens.
\item[Screen] A physical or virtual (Xinerama or \Cmd{Xnest}{1})
screen of an X display. A screen displays a bar window
and a view at a time.
\item[Window] A (rectangular) drawable X object which is
displayed on a screen, usually an application window.
\item[Client] An application window surrounded by a frame window
containing a border and a titlebar.
\item[Floating layer] A screen layer of \Prog{wmii} on top of
all other layers, where clients are arranged in a
classic (floating) way. They can be resized or moved
freely.
\item[Managed layer] A screen layer of \Prog{wmii} behind the
floating layer, where clients are arranged in a
non\-overlapping (managed) way. Here, the window
manager dynamically assigns each client a size and
position. The managed layer consists of columns.
\item[Tag] Alphanumeric strings which can be assigned to a
client. This provides a mechanism to group clients with
similar properties. Clients can have one tag, e.g.
\emph{work}, or several tags, e.g. \emph{work+mail}.
Tags are separated with the \emph{+} character.
\item[View] A set of clients containing a specific tag, quite similiar to a
workspace in other window managers. It consists of the floating and
managed layers.
\item[Column] A column is a screen area which arranges clients vertically in a
non-overlapping way. Columns provide three different modes, which
arrange clients with equal size, stacked, or maximized respectively.
Clients can be moved and resized between and within columns freely.
\item[Bar] The bar at the bottom of the screen displays a label for each view and
allows the creation of arbitrary user\-defined labels.
\item[Event] An event is a message which can be read from a special file in the
filesystem of \Prog{wmii}, such as a mouse button press, a key press, or
a message written by a different 9P-client.
\item[View] A set of clients containing a specific tag, quite
similiar to a workspace in other window managers. It
consists of the floating and managed layers.
\item[Column] A column is a screen area which arranges clients
vertically in a non-overlapping way. Columns provide
three different modes, which arrange clients with equal
size, stacked, or maximized respectively. Clients can
be moved and resized between and within columns freely.
\item[Bar] The bar at the bottom of the screen displays a label
for each view and allows the creation of arbitrary
user\-defined labels.
\item[Event] An event is a message which can be read from a
special file in the filesystem of \Prog{wmii}, such as a
mouse button press, a key press, or a message written by
a different 9P-client.
\end{description}
\subsection{Basic window management}
Running a raw \Prog{wmii} process without a \Cmd{wmiirc}{1} script
provides basic window management capabilities already. However, to
use it effectively, remote control through its filesystem interface
is necessary. By default it is only usable with the mouse in
conjunction with the \emph{Mod1 (Alt)} modifier key. Other
interactions, such as customizing the style, killing or retagging
clients, and grabbing keys, cannot be achieved without accessing the
filesystem.
Running a raw \Prog{wmii} process without a \Cmd{wmiirc}{1}
script provides basic window management capabilities already.
However, to use it effectively, remote control through its
filesystem interface is necessary. By default it is only usable
with the mouse in conjunction with the \emph{Mod1 (Alt)}
modifier key. Other interactions, such as customizing the style,
killing or retagging clients, and grabbing keys, cannot be
achieved without accessing the filesystem.
The filesystem can be accessed by connecting to the \emph{address}
of \Prog{wmii} with any 9P-capable client, such as \Cmd{wmiir}{1}
The filesystem can be accessed by connecting to the
\emph{address} of \Prog{wmii} with any 9P-capable client, such
as \Cmd{wmiir}{1}
\subsection{Actions}
An action is a shell script in the default setup, but it can
actually be any executable file. It is executed usually by
selecting it from the actions menu. You can customize an action by
copying it from the global action directory
selecting it from the actions menu. You can customize an action
by copying it from the global action directory
\File{CONFPREFIX/wmii-3.5} to \File{\$HOME/.wmii-3.5} and then
editing the copy to fit your needs. Of course you can also create
your own actions there; make sure that they are executable.
editing the copy to fit your needs. Of course you can also
create your own actions there; make sure that they are
executable.
Here is a list of the default actions:
@ -159,9 +167,9 @@ Mod-Enter & \Prog{Execute} an \Prog{xterm} \\
If you feel the need to change the default configuration, then
customize (as described above) the \Prog{wmiirc} action. This
action is executed at the end of the \Prog{wmii} script and does all
the work of setting up the window manager, the key bindings, the bar
labels, etc.
action is executed at the end of the \Prog{wmii} script and does
all the work of setting up the window manager, the key bindings,
the bar labels, etc.
\section{Filesystem}
@ -279,11 +287,11 @@ represents the currently selected client.
\item[props] Returns a clients class and label as:
\emph{name}:\emph{class}:\emph{label}
\item[tags] Set or read a client's tags. Tags are seperated by
\emph{+} or {-}. Tags begining with \emph{+} are added,
while those begining with \emph{-} are removed. If the
tag string written begins with \emph{+} or \emph{-}, the
written tags are added to or removed from the client's
set, otherwise, the set is overwritten.
\emph{+} or \emph{-}. Tags begining with \emph{+} are
added, while those begining with \emph{-} are removed.
If the tag string written begins with \emph{+} or
\emph{-}, the written tags are added to or removed from
the client's set, otherwise, the set is overwritten.
\end{description}
\subsubsection{The /tag/ Hierarchy}
@ -335,9 +343,11 @@ them.
\section{FILES}
\begin{description}
\item[/tmp/ns.$USER.${DISPLAY\%.0}/wmii] The wmii socket file which provides a 9P service.
\item[/tmp/ns.$USER.${DISPLAY\%.0}/wmii] The wmii socket file
which provides a 9P service.
\item[CONFPREFIX/wmii-3.5] Global action directory.
\item[\$HOME/.wmii-3.5] User-specific action directory. Actions are first searched here.
\item[\$HOME/.wmii-3.5] User-specific action directory. Actions
are first searched here.
\end{description}
\section{ENVIRONMENT}