/** Update a window's colormap.
* A call to this function indicates that the colormap(s) for the given
* client changed. This will change the active colormap(s) if the given
* client is active.
*/
void UpdateClientColormap(ClientNode *np)
{
Assert(np);
if(np == activeClient) {
ColormapNode *cp = np->colormaps;
char wasInstalled = 0;
while(cp) {
XWindowAttributes attr;
if(JXGetWindowAttributes(display, cp->window, &attr)) {
if(attr.colormap != None) {
if(attr.colormap == np->cmap) {
wasInstalled = 1;
}
JXInstallColormap(display, attr.colormap);
}
}
cp = cp->next;
}
if(!wasInstalled && np->cmap != None) {
JXInstallColormap(display, np->cmap);
}
}
}
/** Determine if this is a window to be swallowed, if it is, swallow it. */
int CheckSwallowMap(const XMapEvent *event) {
SwallowNode *np;
XClassHint hint;
XWindowAttributes attr;
for(np = swallowNodes; np; np = np->next) {
if(np->cp->window != None) {
continue;
}
Assert(np->cp->tray->window != None);
if(JXGetClassHint(display, event->window, &hint)) {
if(!strcmp(hint.res_name, np->name)) {
/* Swallow the window. */
JXSelectInput(display, event->window,
StructureNotifyMask | ResizeRedirectMask);
JXAddToSaveSet(display, event->window);
JXSetWindowBorder(display, event->window, colors[COLOR_TRAY_BG]);
JXReparentWindow(display, event->window,
np->cp->tray->window, 0, 0);
JXMapRaised(display, event->window);
JXFree(hint.res_name);
JXFree(hint.res_class);
np->cp->window = event->window;
/* Update the size. */
JXGetWindowAttributes(display, event->window, &attr);
np->border = attr.border_width;
if(!np->userWidth) {
np->cp->requestedWidth = attr.width + 2 * np->border;
}
if(!np->userHeight) {
np->cp->requestedHeight = attr.height + 2 * np->border;
}
ResizeTray(np->cp->tray);
return 1;
} else {
JXFree(hint.res_name);
JXFree(hint.res_class);
}
}
}
return 0;
}
/** Load windows that are already mapped. */
void StartupClients(void)
{
XWindowAttributes attr;
Window rootReturn, parentReturn, *childrenReturn;
unsigned int childrenCount;
unsigned int x;
clientCount = 0;
activeClient = NULL;
currentDesktop = 0;
/* Clear out the client lists. */
for(x = 0; x < LAYER_COUNT; x++) {
nodes[x] = NULL;
nodeTail[x] = NULL;
}
/* Query client windows. */
JXQueryTree(display, rootWindow, &rootReturn, &parentReturn,
&childrenReturn, &childrenCount);
/* Add each client. */
for(x = 0; x < childrenCount; x++) {
if(JXGetWindowAttributes(display, childrenReturn[x], &attr)) {
if(attr.override_redirect == False && attr.map_state == IsViewable) {
AddClientWindow(childrenReturn[x], 1, 1);
}
}
}
JXFree(childrenReturn);
LoadFocus();
RequireTaskUpdate();
RequirePagerUpdate();
}
/** Add a window to management. */
ClientNode *AddClientWindow(Window w, char alreadyMapped, char notOwner)
{
XWindowAttributes attr;
ClientNode *np;
Assert(w != None);
/* Get window attributes. */
if(JXGetWindowAttributes(display, w, &attr) == 0) {
return NULL;
}
/* Determine if we should care about this window. */
if(attr.override_redirect == True) {
return NULL;
}
if(attr.class == InputOnly) {
return NULL;
}
/* Prepare a client node for this window. */
np = Allocate(sizeof(ClientNode));
memset(np, 0, sizeof(ClientNode));
np->window = w;
np->owner = None;
np->state.desktop = currentDesktop;
np->x = attr.x;
np->y = attr.y;
np->width = attr.width;
np->height = attr.height;
np->cmap = attr.colormap;
np->state.status = STAT_NONE;
np->state.maxFlags = MAX_NONE;
np->state.layer = LAYER_NORMAL;
np->state.defaultLayer = LAYER_NORMAL;
np->state.border = BORDER_DEFAULT;
np->borderAction = BA_NONE;
ReadClientInfo(np, alreadyMapped);
if(!notOwner) {
np->state.border = BORDER_OUTLINE | BORDER_TITLE | BORDER_MOVE;
np->state.status |= STAT_WMDIALOG | STAT_STICKY;
np->state.layer = LAYER_ABOVE;
np->state.defaultLayer = LAYER_ABOVE;
}
ApplyGroups(np);
if(np->icon == NULL) {
LoadIcon(np);
}
/* We now know the layer, so insert */
np->prev = NULL;
np->next = nodes[np->state.layer];
if(np->next) {
np->next->prev = np;
} else {
nodeTail[np->state.layer] = np;
}
nodes[np->state.layer] = np;
SetDefaultCursor(np->window);
ReparentClient(np, notOwner);
PlaceClient(np, alreadyMapped);
if(!((np->state.status & STAT_FULLSCREEN) || np->state.maxFlags)) {
int north, south, east, west;
GetBorderSize(&np->state, &north, &south, &east, &west);
if(np->parent != None) {
JXMoveResizeWindow(display, np->parent, np->x - west, np->y - north,
np->width + east + west,
np->height + north + south);
JXMoveResizeWindow(display, np->window, west, north,
np->width, np->height);
} else {
JXMoveResizeWindow(display, np->window, np->x, np->y,
np->width, np->height);
}
}
/* If one of these fails we are SOL, so who cares. */
XSaveContext(display, np->window, clientContext, (void*)np);
if(np->parent != None) {
XSaveContext(display, np->parent, frameContext, (void*)np);
}
if(np->state.status & STAT_MAPPED) {
JXMapWindow(display, np->window);
if(np->parent != None) {
JXMapWindow(display, np->parent);
}
}
clientCount += 1;
if(!alreadyMapped) {
RaiseClient(np);
}
if(np->state.status & STAT_OPACITY) {
SetOpacity(np, np->state.opacity, 1);
} else {
SetOpacity(np, settings.inactiveClientOpacity, 1);
}
if(np->state.status & STAT_STICKY) {
SetCardinalAtom(np->window, ATOM_NET_WM_DESKTOP, ~0UL);
} else {
SetCardinalAtom(np->window, ATOM_NET_WM_DESKTOP, np->state.desktop);
}
/* Shade the client if requested. */
if(np->state.status & STAT_SHADED) {
np->state.status &= ~STAT_SHADED;
ShadeClient(np);
}
/* Minimize the client if requested. */
if(np->state.status & STAT_MINIMIZED) {
np->state.status &= ~STAT_MINIMIZED;
MinimizeClient(np, 0);
}
/* Maximize the client if requested. */
if(np->state.maxFlags) {
const MaxFlags flags = np->state.maxFlags;
np->state.maxFlags = MAX_NONE;
MaximizeClient(np, flags);
}
if(np->state.status & STAT_URGENT) {
RegisterCallback(URGENCY_DELAY, SignalUrgent, np);
}
/* Update task bars. */
AddClientToTaskBar(np);
/* Make sure we're still in sync */
WriteState(np);
SendConfigureEvent(np);
/* Hide the client if we're not on the right desktop. */
if(np->state.desktop != currentDesktop
&& !(np->state.status & STAT_STICKY)) {
HideClient(np);
}
ReadClientStrut(np);
/* Focus transients if their parent has focus. */
if(np->owner != None) {
if(activeClient && np->owner == activeClient->window) {
FocusClient(np);
}
}
/* Make the client fullscreen if requested. */
if(np->state.status & STAT_FULLSCREEN) {
np->state.status &= ~STAT_FULLSCREEN;
SetClientFullScreen(np, 1);
}
ResetBorder(np);
return np;
}
