/** Maximize a client window. */
void MaximizeClient(ClientNode *np, MaxFlags flags)
{
/* Return if we don't have a client. */
if(np == NULL) {
return;
}
/* Don't allow maximization of full-screen clients. */
if(np->state.status & STAT_FULLSCREEN) {
return;
}
if(!(np->state.border & BORDER_MAX)) {
return;
}
if(np->state.status & STAT_SHADED) {
UnshadeClient(np);
}
RaiseClient(np);
FocusClient(np);
if(np->state.maxFlags) {
/* Undo existing maximization. */
np->x = np->oldx;
np->y = np->oldy;
np->width = np->oldWidth;
np->height = np->oldHeight;
np->state.maxFlags = MAX_NONE;
}
if(flags != MAX_NONE) {
/* Maximize if requested. */
PlaceMaximizedClient(np, flags);
}
WriteState(np);
ResetBorder(np);
DrawBorder(np);
SendConfigureEvent(np);
RequirePagerUpdate();
}
/** Window menu action callback. */
void RunWindowCommand(const MenuAction *action)
{
switch(action->type) {
case MA_STICK:
if(client->state.status & STAT_STICKY) {
SetClientSticky(client, 0);
} else {
SetClientSticky(client, 1);
}
break;
case MA_MAXIMIZE:
if(client->state.maxFlags) {
MaximizeClient(client, MAX_NONE);
} else {
MaximizeClient(client, MAX_VERT | MAX_HORIZ);
}
break;
case MA_MAXIMIZE_H:
MaximizeClient(client, MAX_HORIZ);
break;
case MA_MAXIMIZE_V:
MaximizeClient(client, MAX_VERT);
break;
case MA_MINIMIZE:
MinimizeClient(client, 1);
break;
case MA_RESTORE:
RestoreClient(client, 1);
break;
case MA_CLOSE:
DeleteClient(client);
break;
case MA_SENDTO:
case MA_DESKTOP:
SetClientDesktop(client, action->data.i);
break;
case MA_SHADE:
if(client->state.status & STAT_SHADED) {
UnshadeClient(client);
} else {
ShadeClient(client);
}
break;
case MA_MOVE:
MoveClientKeyboard(client);
break;
case MA_RESIZE:
ResizeClientKeyboard(client);
break;
case MA_KILL:
KillClient(client);
break;
case MA_LAYER:
SetClientLayer(client, action->data.i);
break;
default:
Debug("unknown window command: %d", action->type);
break;
}
}
/** Window menu action callback. */
void RunWindowCommand(MenuAction *action, unsigned button)
{
ClientNode *client = action->context;
switch(action->type) {
case MA_STICK:
if(client->state.status & STAT_STICKY) {
SetClientSticky(client, 0);
} else {
SetClientSticky(client, 1);
}
break;
case MA_MAXIMIZE:
if((client->state.maxFlags & MAX_HORIZ)
&& (client->state.maxFlags & MAX_VERT)
&& !(client->state.status & STAT_MINIMIZED)) {
MaximizeClient(client, MAX_NONE);
} else {
MaximizeClient(client, MAX_VERT | MAX_HORIZ);
}
break;
case MA_MAXIMIZE_H:
if((client->state.maxFlags & MAX_HORIZ)
&& !(client->state.maxFlags & MAX_VERT)
&& !(client->state.status & STAT_MINIMIZED)) {
MaximizeClient(client, MAX_NONE);
} else {
MaximizeClient(client, MAX_HORIZ);
}
break;
case MA_MAXIMIZE_V:
if((client->state.maxFlags & MAX_VERT)
&& !(client->state.maxFlags & MAX_HORIZ)
&& !(client->state.status & STAT_MINIMIZED)) {
MaximizeClient(client, MAX_NONE);
} else {
MaximizeClient(client, MAX_VERT);
}
break;
case MA_MINIMIZE:
MinimizeClient(client, 1);
break;
case MA_RESTORE:
RestoreClient(client, 1);
break;
case MA_CLOSE:
DeleteClient(client);
break;
case MA_SENDTO:
case MA_DESKTOP:
SetClientDesktop(client, action->value);
break;
case MA_SHADE:
if(client->state.status & STAT_SHADED) {
UnshadeClient(client);
} else {
ShadeClient(client);
}
break;
case MA_MOVE:
MoveClientKeyboard(client);
break;
case MA_RESIZE:
ResizeClientKeyboard(client);
break;
case MA_KILL:
KillClient(client);
break;
case MA_LAYER:
SetClientLayer(client, action->value);
break;
default:
break;
}
}
/** Handle a client message. */
void HandleClientMessage(const XClientMessageEvent *event)
{
ClientNode *np;
#ifdef DEBUG
char *atomName;
#endif
np = FindClientByWindow(event->window);
if(np) {
if(event->message_type == atoms[ATOM_WM_CHANGE_STATE]) {
if(np->controller) {
(np->controller)(0);
}
switch(event->data.l[0]) {
case WithdrawnState:
SetClientWithdrawn(np);
break;
case IconicState:
MinimizeClient(np, 1);
break;
case NormalState:
RestoreClient(np, 1);
break;
default:
break;
}
} else if(event->message_type == atoms[ATOM_NET_ACTIVE_WINDOW]) {
RestoreClient(np, 1);
UnshadeClient(np);
FocusClient(np);
} else if(event->message_type == atoms[ATOM_NET_WM_DESKTOP]) {
if(event->data.l[0] == ~0L) {
SetClientSticky(np, 1);
} else {
if(np->controller) {
(np->controller)(0);
}
if( event->data.l[0] >= 0
&& event->data.l[0] < (long)settings.desktopCount) {
np->state.status &= ~STAT_STICKY;
SetClientDesktop(np, event->data.l[0]);
}
}
} else if(event->message_type == atoms[ATOM_NET_CLOSE_WINDOW]) {
DeleteClient(np);
} else if(event->message_type == atoms[ATOM_NET_MOVERESIZE_WINDOW]) {
HandleNetMoveResize(event, np);
} else if(event->message_type == atoms[ATOM_NET_WM_MOVERESIZE]) {
HandleNetWMMoveResize(event, np);
} else if(event->message_type == atoms[ATOM_NET_RESTACK_WINDOW]) {
HandleNetRestack(event, np);
} else if(event->message_type == atoms[ATOM_NET_WM_STATE]) {
HandleNetWMState(event, np);
} else {
#ifdef DEBUG
atomName = JXGetAtomName(display, event->message_type);
Debug("Unknown ClientMessage to client: %s", atomName);
JXFree(atomName);
#endif
}
} else if(event->window == rootWindow) {
if(event->message_type == atoms[ATOM_JWM_RESTART]) {
Restart();
} else if(event->message_type == atoms[ATOM_JWM_EXIT]) {
Exit();
} else if(event->message_type == atoms[ATOM_JWM_RELOAD]) {
ReloadMenu();
} else if(event->message_type == atoms[ATOM_NET_CURRENT_DESKTOP]) {
ChangeDesktop(event->data.l[0]);
} else if(event->message_type == atoms[ATOM_NET_SHOWING_DESKTOP]) {
ShowDesktop();
} else {
#ifdef DEBUG
atomName = JXGetAtomName(display, event->message_type);
Debug("Unknown ClientMessage to root: %s", atomName);
JXFree(atomName);
#endif
}
} else if(event->message_type == atoms[ATOM_NET_REQUEST_FRAME_EXTENTS]) {
HandleFrameExtentsRequest(event);
} else if(event->message_type == atoms[ATOM_NET_SYSTEM_TRAY_OPCODE]) {
HandleDockEvent(event);
} else {
#ifdef DEBUG
atomName = JXGetAtomName(display, event->message_type);
Debug("ClientMessage to unknown window (0x%x): %s",
event->window, atomName);
JXFree(atomName);
#endif
}
}
/** Process a key press event. */
void HandleKeyPress(const XKeyEvent *event)
{
ClientNode *np;
KeyType key;
SetMousePosition(event->x_root, event->y_root, event->window);
key = GetKey(event);
np = GetActiveClient();
switch(key & 0xFF) {
case KEY_EXEC:
RunKeyCommand(event);
break;
case KEY_DESKTOP:
ChangeDesktop((key >> 8) - 1);
break;
case KEY_RDESKTOP:
RightDesktop();
break;
case KEY_LDESKTOP:
LeftDesktop();
break;
case KEY_UDESKTOP:
AboveDesktop();
break;
case KEY_DDESKTOP:
BelowDesktop();
break;
case KEY_SHOWDESK:
ShowDesktop();
break;
case KEY_SHOWTRAY:
ShowAllTrays();
break;
case KEY_NEXT:
StartWindowWalk();
FocusNext();
break;
case KEY_NEXTSTACK:
StartWindowStackWalk();
WalkWindowStack(1);
break;
case KEY_PREV:
StartWindowWalk();
FocusPrevious();
break;
case KEY_PREVSTACK:
StartWindowStackWalk();
WalkWindowStack(0);
break;
case KEY_CLOSE:
if(np) {
DeleteClient(np);
}
break;
case KEY_SHADE:
if(np) {
if(np->state.status & STAT_SHADED) {
UnshadeClient(np);
} else {
ShadeClient(np);
}
}
break;
case KEY_STICK:
if(np) {
if(np->state.status & STAT_STICKY) {
SetClientSticky(np, 0);
} else {
SetClientSticky(np, 1);
}
}
break;
case KEY_MOVE:
if(np) {
MoveClientKeyboard(np);
}
break;
case KEY_RESIZE:
if(np) {
ResizeClientKeyboard(np);
}
break;
case KEY_MIN:
if(np) {
MinimizeClient(np, 1);
}
break;
case KEY_MAX:
if(np) {
if(np->state.maxFlags) {
MaximizeClient(np, MAX_NONE);
} else {
MaximizeClient(np, MAX_HORIZ | MAX_VERT);
}
}
break;
case KEY_MAXTOP:
ToggleMaximized(np, MAX_TOP | MAX_HORIZ);
break;
case KEY_MAXBOTTOM:
ToggleMaximized(np, MAX_BOTTOM | MAX_HORIZ);
break;
case KEY_MAXLEFT:
ToggleMaximized(np, MAX_LEFT | MAX_VERT);
break;
case KEY_MAXRIGHT:
ToggleMaximized(np, MAX_RIGHT | MAX_VERT);
break;
case KEY_MAXV:
ToggleMaximized(np, MAX_VERT);
break;
case KEY_MAXH:
ToggleMaximized(np, MAX_HORIZ);
break;
case KEY_ROOT:
ShowKeyMenu(event);
break;
case KEY_WIN:
if(np) {
RaiseClient(np);
ShowWindowMenu(np, np->x, np->y, 1);
}
break;
case KEY_RESTART:
Restart();
break;
case KEY_EXIT:
Exit();
break;
case KEY_FULLSCREEN:
if(np) {
if(np->state.status & STAT_FULLSCREEN) {
SetClientFullScreen(np, 0);
} else {
SetClientFullScreen(np, 1);
}
}
break;
case KEY_SENDR:
if(np) {
SetClientDesktop(np, GetRightDesktop(np->state.desktop));
}
break;
case KEY_SENDL:
if(np) {
SetClientDesktop(np, GetLeftDesktop(np->state.desktop));
}
break;
case KEY_SENDU:
if(np) {
SetClientDesktop(np, GetAboveDesktop(np->state.desktop));
}
break;
case KEY_SENDD:
if(np) {
SetClientDesktop(np, GetBelowDesktop(np->state.desktop));
}
break;
default:
break;
}
DiscardEnterEvents();
}
/** Take the appropriate action for a click on a client border. */
void DispatchBorderButtonEvent(const XButtonEvent *event,
ClientNode *np)
{
static Time lastClickTime = 0;
static int lastX = 0, lastY = 0;
static char doubleClickActive = 0;
BorderActionType action;
int bsize;
/* Middle click starts a move unless it's over the maximize button. */
action = GetBorderActionType(np, event->x, event->y);
if(event->button == Button2 && action != BA_MAXIMIZE) {
MoveClient(np, event->x, event->y);
return;
}
/* Determine the size of the border. */
if(np->state.border & BORDER_OUTLINE) {
bsize = settings.borderWidth;
} else {
bsize = 0;
}
/* Other buttons are context sensitive. */
switch(action & 0x0F) {
case BA_RESIZE: /* Border */
if(event->type == ButtonPress) {
if(event->button == Button1) {
ResizeClient(np, action, event->x, event->y);
} else if(event->button == Button3) {
const int x = np->x + event->x - bsize;
const int y = np->y + event->y - settings.titleHeight - bsize;
ShowWindowMenu(np, x, y, 0);
}
}
break;
case BA_MOVE: /* Title bar */
if(event->button == Button1) {
if(event->type == ButtonPress) {
if(doubleClickActive
&& event->time != lastClickTime
&& event->time - lastClickTime <= settings.doubleClickSpeed
&& abs(event->x - lastX) <= settings.doubleClickDelta
&& abs(event->y - lastY) <= settings.doubleClickDelta) {
MaximizeClientDefault(np);
doubleClickActive = 0;
} else {
if(MoveClient(np, event->x, event->y)) {
doubleClickActive = 0;
} else {
doubleClickActive = 1;
lastClickTime = event->time;
lastX = event->x;
lastY = event->y;
}
}
}
} else if(event->button == Button3) {
const int x = np->x + event->x - bsize;
const int y = np->y + event->y - settings.titleHeight - bsize;
ShowWindowMenu(np, x, y, 0);
} else if(event->button == Button4) {
ShadeClient(np);
} else if(event->button == Button5) {
UnshadeClient(np);
}
break;
case BA_MENU: /* Menu button */
if(event->button == Button4) {
ShadeClient(np);
} else if(event->button == Button5) {
UnshadeClient(np);
} else if(event->type == ButtonPress) {
const int x = np->x + event->x - bsize;
const int y = np->y + event->y - settings.titleHeight - bsize;
ShowWindowMenu(np, x, y, 0);
}
break;
case BA_CLOSE: /* Close button */
if(event->type == ButtonRelease
&& (event->button == Button1 || event->button == Button3)) {
DeleteClient(np);
}
break;
case BA_MAXIMIZE: /* Maximize button */
if(event->type == ButtonRelease) {
switch(event->button) {
case Button1:
MaximizeClientDefault(np);
break;
case Button2:
MaximizeClient(np, np->state.maxFlags ^ MAX_VERT);
break;
case Button3:
MaximizeClient(np, np->state.maxFlags ^ MAX_HORIZ);
break;
default:
break;
}
}
break;
case BA_MINIMIZE: /* Minimize button */
if(event->type == ButtonRelease) {
if(event->button == Button3) {
if(np->state.status & STAT_SHADED) {
UnshadeClient(np);
} else {
ShadeClient(np);
}
} else if(event->button == Button1) {
MinimizeClient(np, 1);
}
}
break;
default:
break;
}
DiscardEnterEvents();
}
/** Handle a _NET_WM_STATE request. */
void HandleNetWMState(const XClientMessageEvent *event, ClientNode *np)
{
unsigned int x;
MaxFlags maxFlags;
char actionStick;
char actionShade;
char actionFullScreen;
char actionMinimize;
char actionNolist;
char actionNopager;
char actionBelow;
char actionAbove;
/* Up to two actions to be applied together. */
maxFlags = MAX_NONE;
actionStick = 0;
actionShade = 0;
actionFullScreen = 0;
actionMinimize = 0;
actionNolist = 0;
actionNopager = 0;
actionBelow = 0;
actionAbove = 0;
for(x = 1; x <= 2; x++) {
if(event->data.l[x]
== (long)atoms[ATOM_NET_WM_STATE_STICKY]) {
actionStick = 1;
} else if(event->data.l[x]
== (long)atoms[ATOM_NET_WM_STATE_MAXIMIZED_VERT]) {
maxFlags |= MAX_VERT;
} else if(event->data.l[x]
== (long)atoms[ATOM_NET_WM_STATE_MAXIMIZED_HORZ]) {
maxFlags |= MAX_HORIZ;
} else if(event->data.l[x]
== (long)atoms[ATOM_NET_WM_STATE_SHADED]) {
actionShade = 1;
} else if(event->data.l[x]
== (long)atoms[ATOM_NET_WM_STATE_FULLSCREEN]) {
actionFullScreen = 1;
} else if(event->data.l[x]
== (long)atoms[ATOM_NET_WM_STATE_HIDDEN]) {
actionMinimize = 1;
} else if(event->data.l[x]
== (long)atoms[ATOM_NET_WM_STATE_SKIP_TASKBAR]) {
actionNolist = 1;
} else if(event->data.l[x]
== (long)atoms[ATOM_NET_WM_STATE_SKIP_PAGER]) {
actionNopager = 1;
} else if(event->data.l[x]
== (long)atoms[ATOM_NET_WM_STATE_BELOW]) {
actionBelow = 1;
} else if(event->data.l[x]
== (long)atoms[ATOM_NET_WM_STATE_ABOVE]) {
actionAbove = 1;
}
}
switch(event->data.l[0]) {
case 0: /* Remove */
if(actionStick) {
SetClientSticky(np, 0);
}
if(maxFlags != MAX_NONE && np->state.maxFlags) {
MaximizeClient(np, np->state.maxFlags & ~maxFlags);
}
if(actionShade) {
UnshadeClient(np);
}
if(actionFullScreen) {
SetClientFullScreen(np, 0);
}
if(actionMinimize) {
RestoreClient(np, 0);
}
if(actionNolist) {
np->state.status &= ~STAT_NOLIST;
RequireTaskUpdate();
}
if(actionNopager) {
np->state.status &= ~STAT_NOPAGER;
RequirePagerUpdate();
}
if(actionBelow && np->state.layer == LAYER_BELOW) {
SetClientLayer(np, np->state.defaultLayer);
}
if(actionAbove && np->state.layer == LAYER_ABOVE) {
SetClientLayer(np, np->state.defaultLayer);
}
break;
case 1: /* Add */
if(actionStick) {
SetClientSticky(np, 1);
}
if(maxFlags != MAX_NONE) {
MaximizeClient(np, np->state.maxFlags | maxFlags);
}
if(actionShade) {
ShadeClient(np);
}
if(actionFullScreen) {
SetClientFullScreen(np, 1);
}
if(actionMinimize) {
MinimizeClient(np, 1);
}
if(actionNolist) {
np->state.status |= STAT_NOLIST;
RequireTaskUpdate();
}
if(actionNopager) {
np->state.status |= STAT_NOPAGER;
RequirePagerUpdate();
}
if(actionBelow) {
SetClientLayer(np, LAYER_BELOW);
}
if(actionAbove) {
SetClientLayer(np, LAYER_ABOVE);
}
break;
case 2: /* Toggle */
if(actionStick) {
if(np->state.status & STAT_STICKY) {
SetClientSticky(np, 0);
} else {
SetClientSticky(np, 1);
}
}
if(maxFlags) {
MaximizeClient(np, np->state.maxFlags ^ maxFlags);
}
if(actionShade) {
if(np->state.status & STAT_SHADED) {
UnshadeClient(np);
} else {
ShadeClient(np);
}
}
if(actionFullScreen) {
if(np->state.status & STAT_FULLSCREEN) {
SetClientFullScreen(np, 0);
} else {
SetClientFullScreen(np, 1);
}
}
if(actionBelow) {
if(np->state.layer == LAYER_BELOW) {
SetClientLayer(np, np->state.defaultLayer);
} else {
SetClientLayer(np, LAYER_BELOW);
}
}
if(actionAbove) {
if(np->state.layer == LAYER_ABOVE) {
SetClientLayer(np, np->state.defaultLayer);
} else {
SetClientLayer(np, LAYER_ABOVE);
}
}
/* Note that we don't handle toggling of hidden per EWMH
* recommendations. */
if(actionNolist) {
np->state.status ^= STAT_NOLIST;
RequireTaskUpdate();
}
if(actionNopager) {
np->state.status ^= STAT_NOPAGER;
RequirePagerUpdate();
}
break;
default:
Debug("bad _NET_WM_STATE action: %ld", event->data.l[0]);
break;
}
/* Update _NET_WM_STATE if needed.
* The state update is handled elsewhere for the other actions.
*/
if(actionNolist | actionNopager | actionAbove | actionBelow) {
WriteState(np);
}
}
/** Set a client's full screen state. */
void SetClientFullScreen(ClientNode *np, char fullScreen)
{
XEvent event;
int north, south, east, west;
BoundingBox box;
const ScreenType *sp;
Assert(np);
/* Make sure there's something to do. */
if(!fullScreen == !(np->state.status & STAT_FULLSCREEN)) {
return;
}
if(!(np->state.border & BORDER_FULLSCREEN)) {
return;
}
if(np->state.status & STAT_SHADED) {
UnshadeClient(np);
}
if(fullScreen) {
np->state.status |= STAT_FULLSCREEN;
if(!(np->state.maxFlags)) {
np->oldx = np->x;
np->oldy = np->y;
np->oldWidth = np->width;
np->oldHeight = np->height;
}
sp = GetCurrentScreen(np->x, np->y);
GetScreenBounds(sp, &box);
GetBorderSize(&np->state, &north, &south, &east, &west);
box.x += west;
box.y += north;
box.width -= east + west;
box.height -= north + south;
np->x = box.x;
np->y = box.y;
np->width = box.width;
np->height = box.height;
ResetBorder(np);
} else {
np->state.status &= ~STAT_FULLSCREEN;
np->x = np->oldx;
np->y = np->oldy;
np->width = np->oldWidth;
np->height = np->oldHeight;
ConstrainSize(np);
ConstrainPosition(np);
if(np->state.maxFlags != MAX_NONE) {
PlaceMaximizedClient(np, np->state.maxFlags);
}
ResetBorder(np);
event.type = MapRequest;
event.xmaprequest.send_event = True;
event.xmaprequest.display = display;
event.xmaprequest.parent = np->parent;
event.xmaprequest.window = np->window;
JXSendEvent(display, rootWindow, False,
SubstructureRedirectMask, &event);
}
WriteState(np);
SendConfigureEvent(np);
RequireRestack();
}
/** Process a key press event. */
void HandleKeyPress(const XKeyEvent *event)
{
ClientNode *np;
KeyType key;
key = GetKey(event);
np = GetActiveClient();
switch(key & 0xFF) {
case KEY_EXEC:
RunKeyCommand(event);
break;
case KEY_DESKTOP:
ChangeDesktop((key >> 8) - 1);
break;
case KEY_RDESKTOP:
RightDesktop();
break;
case KEY_LDESKTOP:
LeftDesktop();
break;
case KEY_UDESKTOP:
AboveDesktop();
break;
case KEY_DDESKTOP:
BelowDesktop();
break;
case KEY_SHOWDESK:
ShowDesktop();
break;
case KEY_SHOWTRAY:
ShowAllTrays();
break;
case KEY_NEXT:
StartWindowWalk();
FocusNext();
break;
case KEY_NEXTSTACK:
StartWindowStackWalk();
WalkWindowStack(1);
break;
case KEY_PREV:
StartWindowWalk();
FocusPrevious();
break;
case KEY_PREVSTACK:
StartWindowStackWalk();
WalkWindowStack(0);
break;
case KEY_CLOSE:
if(np) {
DeleteClient(np);
}
break;
case KEY_SHADE:
if(np) {
if(np->state.status & STAT_SHADED) {
UnshadeClient(np);
} else {
ShadeClient(np);
}
}
break;
case KEY_STICK:
if(np) {
if(np->state.status & STAT_STICKY) {
SetClientSticky(np, 0);
} else {
SetClientSticky(np, 1);
}
}
break;
case KEY_MOVE:
if(np) {
MoveClientKeyboard(np);
}
break;
case KEY_RESIZE:
if(np) {
ResizeClientKeyboard(np);
}
break;
case KEY_MIN:
if(np) {
MinimizeClient(np, 1);
}
break;
case KEY_MAX:
if(np) {
MaximizeClient(np, 1, 1);
}
break;
case KEY_ROOT:
ShowKeyMenu(event);
break;
case KEY_WIN:
if(np) {
ShowWindowMenu(np, np->x, np->y);
}
break;
case KEY_RESTART:
Restart();
break;
case KEY_EXIT:
Exit();
break;
case KEY_FULLSCREEN:
if(np) {
if(np->state.status & STAT_FULLSCREEN) {
SetClientFullScreen(np, 0);
} else {
SetClientFullScreen(np, 1);
}
}
break;
case KEY_SENDR:
if(np) {
SetClientDesktop(np, GetRightDesktop(np->state.desktop));
}
break;
case KEY_SENDL:
if(np) {
SetClientDesktop(np, GetLeftDesktop(np->state.desktop));
}
break;
case KEY_SENDU:
if(np) {
SetClientDesktop(np, GetAboveDesktop(np->state.desktop));
}
break;
case KEY_SENDD:
if(np) {
SetClientDesktop(np, GetBelowDesktop(np->state.desktop));
}
break;
default:
break;
}
}
/** Handle a _NET_WM_STATE request. */
void HandleNetWMState(const XClientMessageEvent *event, ClientNode *np) {
int actionMaxH;
int actionMaxV;
int actionStick;
int actionShade;
int actionFullScreen;
int actionMinimize;
int actionNolist;
int x;
/* Up to two actions to be applied together, figure it out. */
actionMaxH = 0;
actionMaxV = 0;
actionStick = 0;
actionShade = 0;
actionFullScreen = 0;
actionMinimize = 0;
actionNolist = 0;
for(x = 1; x <= 2; x++) {
if(event->data.l[x]
== (long)atoms[ATOM_NET_WM_STATE_STICKY]) {
actionStick = 1;
} else if(event->data.l[x]
== (long)atoms[ATOM_NET_WM_STATE_MAXIMIZED_VERT]) {
actionMaxV = 1;
} else if(event->data.l[x]
== (long)atoms[ATOM_NET_WM_STATE_MAXIMIZED_HORZ]) {
actionMaxH = 1;
} else if(event->data.l[x]
== (long)atoms[ATOM_NET_WM_STATE_SHADED]) {
actionShade = 1;
} else if(event->data.l[x]
== (long)atoms[ATOM_NET_WM_STATE_FULLSCREEN]) {
actionFullScreen = 1;
} else if(event->data.l[x]
== (long)atoms[ATOM_NET_WM_STATE_HIDDEN]) {
actionMinimize = 1;
} else if(event->data.l[x]
== (long)atoms[ATOM_NET_WM_STATE_SKIP_TASKBAR]) {
actionNolist = 1;
}
}
switch(event->data.l[0]) {
case 0: /* Remove */
if(actionStick) {
SetClientSticky(np, 0);
}
if(actionMaxH || actionMaxV) {
if(np->state.status & (STAT_HMAX | STAT_VMAX)) {
MaximizeClient(np, 0, 0);
}
}
if(actionShade) {
UnshadeClient(np);
}
if(actionFullScreen) {
SetClientFullScreen(np, 0);
}
if(actionMinimize) {
RestoreClient(np, 0);
}
if(actionNolist) {
np->state.status &= ~STAT_NOLIST;
UpdateTaskBar();
}
break;
case 1: /* Add */
if(actionStick) {
SetClientSticky(np, 1);
}
if(!(np->state.status & (STAT_HMAX | STAT_VMAX))) {
MaximizeClient(np, actionMaxH, actionMaxV);
}
if(actionShade) {
ShadeClient(np);
}
if(actionFullScreen) {
SetClientFullScreen(np, 1);
}
if(actionMinimize) {
MinimizeClient(np);
}
if(actionNolist) {
np->state.status |= STAT_NOLIST;
UpdateTaskBar();
}
break;
case 2: /* Toggle */
if(actionStick) {
if(np->state.status & STAT_STICKY) {
SetClientSticky(np, 0);
} else {
SetClientSticky(np, 1);
}
}
if(actionMaxH || actionMaxV) {
MaximizeClient(np, actionMaxH, actionMaxV);
}
if(actionShade) {
if(np->state.status & STAT_SHADED) {
UnshadeClient(np);
} else {
ShadeClient(np);
}
}
if(actionFullScreen) {
if(np->state.status & STAT_FULLSCREEN) {
SetClientFullScreen(np, 0);
} else {
SetClientFullScreen(np, 1);
}
}
/* Note that we don't handle toggling of hidden per EWMH
* recommendations. */
if(actionNolist) {
np->state.status ^= STAT_NOLIST;
UpdateTaskBar();
}
break;
default:
Debug("bad _NET_WM_STATE action: %ld", event->data.l[0]);
break;
}
}
/** Process a button event. */
void HandleButtonEvent(const XButtonEvent *event) {
int x, y;
ClientNode *np;
int north, south, east, west;
np = FindClientByParent(event->window);
if(np) {
RaiseClient(np);
if(focusModel == FOCUS_CLICK) {
FocusClient(np);
}
switch(event->button) {
case Button1:
DispatchBorderButtonEvent(event, np);
break;
case Button2:
MoveClient(np, event->x, event->y);
break;
case Button3:
GetBorderSize(np, &north, &south, &east, &west);
x = event->x + np->x - west;
y = event->y + np->y - north;
ShowWindowMenu(np, x, y);
break;
case Button4:
ShadeClient(np);
break;
case Button5:
UnshadeClient(np);
break;
default:
break;
}
} else if(event->window == rootWindow && event->type == ButtonPress) {
if(!ShowRootMenu(event->button, event->x, event->y)) {
if(event->button == 4) {
LeftDesktop();
} else if(event->button == 5) {
RightDesktop();
}
}
} else {
np = FindClientByWindow(event->window);
if(np) {
switch(event->button) {
case Button1:
case Button2:
RaiseClient(np);
if(focusModel == FOCUS_CLICK) {
FocusClient(np);
}
if(event->state & Mod1Mask) {
GetBorderSize(np, &north, &south, &east, &west);
MoveClient(np, event->x + west, event->y + north);
}
break;
case Button3:
if(event->state & Mod1Mask) {
GetBorderSize(np, &north, &south, &east, &west);
ResizeClient(np, BA_RESIZE | BA_RESIZE_E | BA_RESIZE_S,
event->x + west, event->y + north);
} else {
RaiseClient(np);
if(focusModel == FOCUS_CLICK) {
FocusClient(np);
}
}
break;
default:
break;
}
JXAllowEvents(display, ReplayPointer, CurrentTime);
}
}
UpdatePager();
}