static void waterHandleMotionEvent(CompDisplay * d, Window root)
{
CompScreen *s;
s = findScreenAtDisplay(d, root);
if (s) {
WATER_SCREEN(s);
if (ws->grabIndex) {
XPoint p[2];
p[0].x = waterLastPointerX;
p[0].y = waterLastPointerY;
p[1].x = waterLastPointerX = pointerX;
p[1].y = waterLastPointerY = pointerY;
waterVertices(s, GL_LINES, p, 2, 0.2f);
damageScreen(s);
}
}
}
static void
fadeAddDisplayModal(CompDisplay *d,
CompWindow *w)
{
FADE_DISPLAY(d);
FADE_WINDOW(w);
if (!(w->state & CompWindowStateDisplayModalMask))
return;
if (fw->dModal)
return;
fw->dModal = 1;
fd->displayModals++;
if (fd->displayModals == 1)
{
CompScreen *s;
for (s = d->screens; s; s = s->next)
damageScreen(s);
}
}
static Bool
snowToggle (CompDisplay *d,
CompAction *action,
CompActionState state,
CompOption *option,
int nOption)
{
CompScreen *s;
Window xid;
xid = getIntOptionNamed (option, nOption, "root", 0);
s = findScreenAtDisplay (d, xid);
if (s)
{
SNOW_SCREEN (s);
ss->active = !ss->active;
if (!ss->active)
damageScreen (s);
}
return TRUE;
}
static void waterHandleEvent(CompDisplay * d, XEvent * event)
{
CompScreen *s;
WATER_DISPLAY(d);
switch (event->type) {
case ButtonPress:
s = findScreenAtDisplay(d, event->xbutton.root);
if (s) {
WATER_SCREEN(s);
if (ws->grabIndex) {
XPoint p;
p.x = pointerX;
p.y = pointerY;
waterVertices(s, GL_POINTS, &p, 1, 0.8f);
damageScreen(s);
}
}
break;
case EnterNotify:
case LeaveNotify:
waterHandleMotionEvent(d, event->xcrossing.root);
break;
case MotionNotify:
waterHandleMotionEvent(d, event->xmotion.root);
default:
break;
}
UNWRAP(wd, d, handleEvent);
(*d->handleEvent) (d, event);
WRAP(wd, d, handleEvent, waterHandleEvent);
}
static void
shotHandleMotionEvent (CompScreen *s,
int xRoot,
int yRoot)
{
SHOT_SCREEN (s);
/* update screenshot rectangle size */
if (ss->grabIndex)
{
REGION reg;
reg.rects = ®.extents;
reg.numRects = 1;
reg.extents.x1 = MIN (ss->x1, ss->x2) - 1;
reg.extents.y1 = MIN (ss->y1, ss->y2) - 1;
reg.extents.x2 = MAX (ss->x1, ss->x2) + 1;
reg.extents.y2 = MAX (ss->y1, ss->y2) + 1;
damageScreenRegion (s, ®);
ss->x2 = xRoot;
ss->y2 = yRoot;
reg.extents.x1 = MIN (ss->x1, ss->x2) - 1;
reg.extents.y1 = MIN (ss->y1, ss->y2) - 1;
reg.extents.x2 = MAX (ss->x1, ss->x2) + 1;
reg.extents.y2 = MAX (ss->y1, ss->y2) + 1;
damageScreenRegion (s, ®);
damageScreen (s);
}
}
static void
fadeHandleEvent(CompDisplay *d,
XEvent *event)
{
CompWindow *w;
FADE_DISPLAY(d);
switch (event->type)
{
case DestroyNotify:
w = findWindowAtDisplay(d, event->xdestroywindow.window);
if (w)
{
FADE_SCREEN(w->screen);
if (w->texture->pixmap && isFadeWinForOpenClose(w) &&
matchEval(&fs->match, w))
{
FADE_WINDOW(w);
if (fw->opacity == 0xffff)
fw->opacity = 0xfffe;
fw->destroyCnt++;
w->destroyRefCnt++;
fw->fadeOut = TRUE;
addWindowDamage(w);
}
fadeRemoveDisplayModal(d, w);
}
break;
case UnmapNotify:
w = findWindowAtDisplay(d, event->xunmap.window);
if (w)
{
FADE_SCREEN(w->screen);
FADE_WINDOW(w);
fw->shaded = w->shaded;
if (fs->opt[FADE_SCREEN_OPTION_MINIMIZE_OPEN_CLOSE].value.b &&
!fd->suppressMinimizeOpenClose &&
!fw->shaded && w->texture->pixmap &&
matchEval(&fs->match, w))
{
if (fw->opacity == 0xffff)
fw->opacity = 0xfffe;
fw->unmapCnt++;
w->unmapRefCnt++;
fw->fadeOut = TRUE;
addWindowDamage(w);
}
fadeRemoveDisplayModal(d, w);
}
break;
case MapNotify:
w = findWindowAtDisplay(d, event->xmap.window);
if (w)
{
FADE_SCREEN(w->screen);
if (fs->opt[FADE_SCREEN_OPTION_MINIMIZE_OPEN_CLOSE].value.b &&
!fd->suppressMinimizeOpenClose)
{
fadeWindowStop(w);
}
if (w->state & CompWindowStateDisplayModalMask)
fadeAddDisplayModal(d, w);
}
break;
default:
if (event->type == d->xkbEvent)
{
XkbAnyEvent *xkbEvent = (XkbAnyEvent *)event;
if (xkbEvent->xkb_type == XkbBellNotify)
{
XkbBellNotifyEvent *xkbBellEvent = (XkbBellNotifyEvent *)
xkbEvent;
w = findWindowAtDisplay(d, xkbBellEvent->window);
if (!w)
w = findWindowAtDisplay(d, d->activeWindow);
if (w)
{
CompScreen *s = w->screen;
FADE_SCREEN(s);
if (fs->opt[FADE_SCREEN_OPTION_VISUAL_BELL].value.b)
{
int option;
option = FADE_SCREEN_OPTION_FULLSCREEN_VISUAL_BELL;
if (fs->opt[option].value.b)
{
for (w = s->windows; w; w = w->next)
{
if (w->destroyed)
continue;
if (w->attrib.map_state != IsViewable)
continue;
if (w->damaged)
{
FADE_WINDOW(w);
fw->brightness = w->paint.brightness / 2;
}
}
damageScreen(s);
}
else
{
FADE_WINDOW(w);
fw->brightness = w->paint.brightness / 2;
addWindowDamage(w);
}
}
}
}
}
break;
}
UNWRAP(fd, d, handleEvent);
(*d->handleEvent)(d, event);
WRAP(fd, d, handleEvent, fadeHandleEvent);
switch (event->type)
{
case PropertyNotify:
if (event->xproperty.atom == d->winStateAtom)
{
w = findWindowAtDisplay(d, event->xproperty.window);
if (w && w->attrib.map_state == IsViewable)
{
if (w->state & CompWindowStateDisplayModalMask)
fadeAddDisplayModal(d, w);
else
fadeRemoveDisplayModal(d, w);
}
}
break;
case ClientMessage:
if (event->xclient.message_type == d->wmProtocolsAtom &&
event->xclient.data.l[0] == d->wmPingAtom)
{
w = findWindowAtDisplay(d, event->xclient.data.l[2]);
if (w)
{
FADE_WINDOW(w);
if (w->alive != fw->alive)
{
addWindowDamage(w);
fw->alive = w->alive;
}
}
}
}
}
static void
zoomHandleMotionEvent(CompScreen *s,
int xRoot,
int yRoot)
{
ZOOM_SCREEN(s);
if (zs->grabIndex)
{
int output = zs->zoomOutput;
ZoomBox box;
float scale, oWidth = s->outputDev[output].width;
zoomGetCurrentZoom(s, output, &box);
if (zs->zoomed & (1 << output))
scale = oWidth / (box.x2 - box.x1);
else
scale = 1.0f;
if (zs->panGrabIndex)
{
float dx, dy;
dx = (xRoot - lastPointerX) / scale;
dy = (yRoot - lastPointerY) / scale;
box.x1 -= dx;
box.y1 -= dy;
box.x2 -= dx;
box.y2 -= dy;
if (box.x1 < s->outputDev[output].region.extents.x1)
{
box.x2 += s->outputDev[output].region.extents.x1 - box.x1;
box.x1 = s->outputDev[output].region.extents.x1;
}
else if (box.x2 > s->outputDev[output].region.extents.x2)
{
box.x1 -= box.x2 - s->outputDev[output].region.extents.x2;
box.x2 = s->outputDev[output].region.extents.x2;
}
if (box.y1 < s->outputDev[output].region.extents.y1)
{
box.y2 += s->outputDev[output].region.extents.y1 - box.y1;
box.y1 = s->outputDev[output].region.extents.y1;
}
else if (box.y2 > s->outputDev[output].region.extents.y2)
{
box.y1 -= box.y2 - s->outputDev[output].region.extents.y2;
box.y2 = s->outputDev[output].region.extents.y2;
}
zs->current[output] = box;
damageScreen(s);
}
else
{
int x1, y1;
if (zs->zoomed & (1 << output))
{
x1 = box.x1;
y1 = box.y1;
}
else
{
x1 = s->outputDev[output].region.extents.x1;
y1 = s->outputDev[output].region.extents.y1;
}
zs->x2 = x1 +
((xRoot - s->outputDev[output].region.extents.x1) /
scale + 0.5f);
zs->y2 = y1 +
((yRoot - s->outputDev[output].region.extents.y1) /
scale + 0.5f);
damageScreen(s);
}
}
}
static Bool
zoomInitiate(CompDisplay *d,
CompAction *action,
CompActionState state,
CompOption *option,
int nOption)
{
CompScreen *s;
Window xid;
xid = getIntOptionNamed(option, nOption, "root", 0);
s = findScreenAtDisplay(d, xid);
if (s)
{
int output, x1, y1;
float scale;
ZOOM_SCREEN(s);
if (otherScreenGrabExist(s, "zoom", NULL))
return FALSE;
if (!zs->grabIndex)
zs->grabIndex = pushScreenGrab(s, None, "zoom");
if (state & CompActionStateInitButton)
action->state |= CompActionStateTermButton;
/* start selection zoom rectangle */
output = outputDeviceForPoint(s, pointerX, pointerY);
if (zs->zoomed & (1 << output))
{
ZoomBox box;
float oWidth;
zoomGetCurrentZoom(s, output, &box);
oWidth = s->outputDev[output].width;
scale = oWidth / (box.x2 - box.x1);
x1 = box.x1;
y1 = box.y1;
}
else
{
scale = 1.0f;
x1 = s->outputDev[output].region.extents.x1;
y1 = s->outputDev[output].region.extents.y1;
}
zs->x1 = zs->x2 = x1 +
((pointerX - s->outputDev[output].region.extents.x1) /
scale + 0.5f);
zs->y1 = zs->y2 = y1 +
((pointerY - s->outputDev[output].region.extents.y1) /
scale + 0.5f);
zs->zoomOutput = output;
zs->grab = TRUE;
damageScreen(s);
return TRUE;
}
return FALSE;
}
static void
zoomInitiateForSelection(CompScreen *s,
int output)
{
int tmp;
ZOOM_SCREEN(s);
if (zs->x1 > zs->x2)
{
tmp = zs->x1;
zs->x1 = zs->x2;
zs->x2 = tmp;
}
if (zs->y1 > zs->y2)
{
tmp = zs->y1;
zs->y1 = zs->y2;
zs->y2 = tmp;
}
if (zs->x1 < zs->x2 && zs->y1 < zs->y2)
{
float oWidth, oHeight;
float xScale, yScale, scale;
BoxRec box;
int cx, cy;
int width, height;
oWidth = s->outputDev[output].width;
oHeight = s->outputDev[output].height;
cx = (int)((zs->x1 + zs->x2) / 2.0f + 0.5f);
cy = (int)((zs->y1 + zs->y2) / 2.0f + 0.5f);
width = zs->x2 - zs->x1;
height = zs->y2 - zs->y1;
xScale = oWidth / width;
yScale = oHeight / height;
scale = MAX(MIN(xScale, yScale), 1.0f);
box.x1 = cx - (oWidth / scale) / 2.0f;
box.y1 = cy - (oHeight / scale) / 2.0f;
box.x2 = cx + (oWidth / scale) / 2.0f;
box.y2 = cy + (oHeight / scale) / 2.0f;
if (box.x1 < s->outputDev[output].region.extents.x1)
{
box.x2 += s->outputDev[output].region.extents.x1 - box.x1;
box.x1 = s->outputDev[output].region.extents.x1;
}
else if (box.x2 > s->outputDev[output].region.extents.x2)
{
box.x1 -= box.x2 - s->outputDev[output].region.extents.x2;
box.x2 = s->outputDev[output].region.extents.x2;
}
if (box.y1 < s->outputDev[output].region.extents.y1)
{
box.y2 += s->outputDev[output].region.extents.y1 - box.y1;
box.y1 = s->outputDev[output].region.extents.y1;
}
else if (box.y2 > s->outputDev[output].region.extents.y2)
{
box.y1 -= box.y2 - s->outputDev[output].region.extents.y2;
box.y2 = s->outputDev[output].region.extents.y2;
}
if (zs->zoomed & (1 << output))
{
zoomGetCurrentZoom(s, output, &zs->last[output]);
}
else
{
zs->last[output].x1 = s->outputDev[output].region.extents.x1;
zs->last[output].y1 = s->outputDev[output].region.extents.y1;
zs->last[output].x2 = s->outputDev[output].region.extents.x2;
zs->last[output].y2 = s->outputDev[output].region.extents.y2;
}
zs->current[output].x1 = box.x1;
zs->current[output].y1 = box.y1;
zs->current[output].x2 = box.x2;
zs->current[output].y2 = box.y2;
zs->scale = 0.0f;
zs->adjust = TRUE;
zs->zoomOutput = output;
zs->zoomed |= (1 << output);
damageScreen(s);
}
}
/*
* groupHandleButtonReleaseEvent
*
*/
static void
groupHandleButtonReleaseEvent (CompScreen *s,
XEvent *event)
{
GroupSelection *group;
int vx, vy;
Region newRegion;
Bool inserted = FALSE;
Bool wasInTabBar = FALSE;
GROUP_SCREEN (s);
if (event->xbutton.button != 1)
return;
if (!gs->draggedSlot)
return;
if (!gs->dragged)
{
groupChangeTab (gs->draggedSlot, RotateUncertain);
gs->draggedSlot = NULL;
if (gs->grabState == ScreenGrabTabDrag)
groupGrabScreen (s, ScreenGrabNone);
return;
}
GROUP_WINDOW (gs->draggedSlot->window);
newRegion = XCreateRegion ();
if (!newRegion)
return;
XUnionRegion (newRegion, gs->draggedSlot->region, newRegion);
groupGetDrawOffsetForSlot (gs->draggedSlot, &vx, &vy);
XOffsetRegion (newRegion, vx, vy);
for (group = gs->groups; group; group = group->next)
{
Bool inTabBar;
Region clip, buf;
GroupTabBarSlot *slot;
if (!group->tabBar || !HAS_TOP_WIN (group))
continue;
/* create clipping region */
clip = groupGetClippingRegion (TOP_TAB (group));
if (!clip)
continue;
buf = XCreateRegion ();
if (!buf)
{
XDestroyRegion (clip);
continue;
}
XIntersectRegion (newRegion, group->tabBar->region, buf);
XSubtractRegion (buf, clip, buf);
XDestroyRegion (clip);
inTabBar = !XEmptyRegion (buf);
XDestroyRegion (buf);
if (!inTabBar)
continue;
wasInTabBar = TRUE;
for (slot = group->tabBar->slots; slot; slot = slot->next)
{
GroupTabBarSlot *tmpDraggedSlot;
GroupSelection *tmpGroup;
Region slotRegion, buf;
XRectangle rect;
Bool inSlot;
if (slot == gs->draggedSlot)
continue;
slotRegion = XCreateRegion ();
if (!slotRegion)
continue;
if (slot->prev && slot->prev != gs->draggedSlot)
{
rect.x = slot->prev->region->extents.x2;
}
else if (slot->prev && slot->prev == gs->draggedSlot &&
gs->draggedSlot->prev)
{
rect.x = gs->draggedSlot->prev->region->extents.x2;
}
else
rect.x = group->tabBar->region->extents.x1;
rect.y = slot->region->extents.y1;
if (slot->next && slot->next != gs->draggedSlot)
{
rect.width = slot->next->region->extents.x1 - rect.x;
}
else if (slot->next && slot->next == gs->draggedSlot &&
gs->draggedSlot->next)
{
rect.width = gs->draggedSlot->next->region->extents.x1 - rect.x;
}
else
rect.width = group->tabBar->region->extents.x2;
rect.height = slot->region->extents.y2 - slot->region->extents.y1;
XUnionRectWithRegion (&rect, slotRegion, slotRegion);
buf = XCreateRegion ();
if (!buf)
continue;
XIntersectRegion (newRegion, slotRegion, buf);
inSlot = !XEmptyRegion (buf);
XDestroyRegion (buf);
XDestroyRegion (slotRegion);
if (!inSlot)
continue;
tmpDraggedSlot = gs->draggedSlot;
if (group != gw->group)
{
CompWindow *w = gs->draggedSlot->window;
GroupSelection *tmpGroup = gw->group;
int oldPosX = WIN_CENTER_X (w);
int oldPosY = WIN_CENTER_Y (w);
/* if the dragged window is not the top tab,
move it onscreen */
if (tmpGroup->topTab && !IS_TOP_TAB (w, tmpGroup))
{
CompWindow *tw = TOP_TAB (tmpGroup);
oldPosX = WIN_CENTER_X (tw) + gw->mainTabOffset.x;
oldPosY = WIN_CENTER_Y (tw) + gw->mainTabOffset.y;
groupSetWindowVisibility (w, TRUE);
}
/* Change the group. */
groupDeleteGroupWindow (gs->draggedSlot->window);
groupAddWindowToGroup (gs->draggedSlot->window, group, 0);
/* we saved the original center position in oldPosX/Y before -
now we should apply that to the new main tab offset */
if (HAS_TOP_WIN (group))
{
CompWindow *tw = TOP_TAB (group);
gw->mainTabOffset.x = oldPosX - WIN_CENTER_X (tw);
gw->mainTabOffset.y = oldPosY - WIN_CENTER_Y (tw);
}
}
else
groupUnhookTabBarSlot (group->tabBar, gs->draggedSlot, TRUE);
gs->draggedSlot = NULL;
gs->dragged = FALSE;
inserted = TRUE;
if ((tmpDraggedSlot->region->extents.x1 +
tmpDraggedSlot->region->extents.x2 + (2 * vx)) / 2 >
(slot->region->extents.x1 + slot->region->extents.x2) / 2)
{
groupInsertTabBarSlotAfter (group->tabBar,
tmpDraggedSlot, slot);
}
else
groupInsertTabBarSlotBefore (group->tabBar,
tmpDraggedSlot, slot);
groupDamageTabBarRegion (group);
/* Hide tab-bars. */
for (tmpGroup = gs->groups; tmpGroup; tmpGroup = tmpGroup->next)
{
if (group == tmpGroup)
groupTabSetVisibility (tmpGroup, TRUE, 0);
else
groupTabSetVisibility (tmpGroup, FALSE, PERMANENT);
}
break;
}
if (inserted)
break;
}
XDestroyRegion (newRegion);
if (!inserted)
{
CompWindow *draggedSlotWindow = gs->draggedSlot->window;
GroupSelection *tmpGroup;
for (tmpGroup = gs->groups; tmpGroup; tmpGroup = tmpGroup->next)
groupTabSetVisibility (tmpGroup, FALSE, PERMANENT);
gs->draggedSlot = NULL;
gs->dragged = FALSE;
const BananaValue *
option_dnd_ungroup_window = bananaGetOption (bananaIndex,
"dnd_ungroup_window",
s->screenNum);
if (option_dnd_ungroup_window->b && !wasInTabBar)
{
groupRemoveWindowFromGroup (draggedSlotWindow);
}
else if (gw->group && gw->group->topTab)
{
groupRecalcTabBarPos (gw->group,
(gw->group->tabBar->region->extents.x1 +
gw->group->tabBar->region->extents.x2) / 2,
gw->group->tabBar->region->extents.x1,
gw->group->tabBar->region->extents.x2);
}
/* to remove the painted slot */
damageScreen (s);
}
if (gs->grabState == ScreenGrabTabDrag)
groupGrabScreen (s, ScreenGrabNone);
if (gs->dragHoverTimeoutHandle)
{
compRemoveTimeout (gs->dragHoverTimeoutHandle);
gs->dragHoverTimeoutHandle = 0;
}
}
static void
elementsDisplayOptionChanged (CompDisplay *d,
CompOption *opt,
ElementsDisplayOptions num)
{
E_DISPLAY (d);
switch (num)
{
case ElementsDisplayOptionToggleAutumnCheck:
{
Bool useKeys = FALSE;
CompScreen *s;
for (s = d->screens; s; s = s->next)
{
E_SCREEN (s);
useKeys = eScreen->useKeys;
if (!useKeys)
{
eScreen->isActive[0] = elementsGetToggleAutumnCheck(s->display);
damageScreen (s);
eScreen->needUpdate = TRUE;
}
}
if (!useKeys)
createAll( d );
}
break;
case ElementsDisplayOptionToggleFirefliesCheck:
{
Bool useKeys = FALSE;
CompScreen *s;
for (s = d->screens; s; s = s->next)
{
E_SCREEN (s);
useKeys = eScreen->useKeys;
if (!useKeys)
{
eScreen->isActive[1] = elementsGetToggleFirefliesCheck(s->display);
damageScreen (s);
eScreen->needUpdate = TRUE;
}
}
if (!useKeys)
createAll( d );
}
break;
case ElementsDisplayOptionToggleSnowCheck:
{
Bool useKeys = FALSE;
CompScreen *s;
for (s = d->screens; s; s = s->next)
{
E_SCREEN (s);
useKeys = eScreen->useKeys;
if (!useKeys)
{
eScreen->isActive[2] = elementsGetToggleSnowCheck(s->display);
damageScreen (s);
eScreen->needUpdate = TRUE;
}
}
if (!useKeys)
createAll( d );
}
break;
case ElementsDisplayOptionToggleStarsCheck:
{
Bool useKeys = FALSE;
CompScreen *s;
for (s = d->screens; s; s = s->next)
{
E_SCREEN (s);
useKeys = eScreen->useKeys;
if (!useKeys)
{
eScreen->isActive[3] = elementsGetToggleStarsCheck(s->display);
damageScreen (s);
eScreen->needUpdate = TRUE;
}
}
if (!useKeys)
createAll( d );
}
break;
case ElementsDisplayOptionToggleBubblesCheck:
{
Bool useKeys = FALSE;
CompScreen *s;
for (s = d->screens; s; s = s->next)
{
E_SCREEN (s);
useKeys = eScreen->useKeys;
if (!useKeys)
{
eScreen->isActive[4] = elementsGetToggleBubblesCheck(s->display);
damageScreen (s);
eScreen->needUpdate = TRUE;
}
}
if (!useKeys)
createAll( d );
}
break;
case ElementsDisplayOptionToggle:
{
CompScreen *s;
for (s = d->screens; s; s = s->next)
{
E_SCREEN (s);
eScreen->useKeys = elementsGetToggle(d);
if (!eScreen->useKeys)
{
eScreen->isActive[0] = elementsGetToggleAutumnCheck(s->display);
eScreen->isActive[1] = elementsGetToggleFirefliesCheck(s->display);
eScreen->isActive[2] = elementsGetToggleSnowCheck(s->display);
eScreen->isActive[3] = elementsGetToggleStarsCheck(s->display);
eScreen->isActive[4] = elementsGetToggleBubblesCheck(s->display);
createAll( d);
}
damageScreen (s);
}
}
break;
case ElementsDisplayOptionLeafSize:
{
CompScreen *s;
for (s = d->screens; s; s = s->next)
{
E_SCREEN (s);
eScreen->needUpdate = TRUE;
updateElementTextures (s, FALSE);
}
}
break;
case ElementsDisplayOptionBubblesSize:
{
CompScreen *s;
for (s = d->screens; s; s = s->next)
{
E_SCREEN (s);
eScreen->needUpdate = TRUE;
updateElementTextures (s, FALSE);
}
}
break;
case ElementsDisplayOptionSnowSize:
{
CompScreen *s;
for (s = d->screens; s; s = s->next)
{
E_SCREEN (s);
eScreen->needUpdate = TRUE;
updateElementTextures (s, FALSE);
}
}
break;
case ElementsDisplayOptionSnowSway:
{
createAll( d );
}
break;
case ElementsDisplayOptionStarsSize:
{
CompScreen *s;
for (s = d->screens; s; s = s->next)
{
E_SCREEN (s);
eScreen->needUpdate = TRUE;
updateElementTextures (s, FALSE);
}
}
break;
case ElementsDisplayOptionFireflySize:
{
CompScreen *s;
for (s = d->screens; s; s = s->next)
{
E_SCREEN (s);
eScreen->needUpdate = TRUE;
updateElementTextures (s, FALSE);
}
}
break;
case ElementsDisplayOptionNumLeaves:
{
createAll( d );
}
break;
case ElementsDisplayOptionNumBubbles:
{
createAll( d );
}
break;
case ElementsDisplayOptionAutumnSway:
{
createAll( d );
}
break;
case ElementsDisplayOptionNumFireflies:
{
createAll( d );
}
break;
case ElementsDisplayOptionNumSnowflakes:
{
createAll( d );
}
break;
case ElementsDisplayOptionNumStars:
{
createAll( d );
}
break;
case ElementsDisplayOptionLeafTextures:
{
CompScreen *s;
CompOption *texAutOpt;
texAutOpt = elementsGetLeafTexturesOption (d);
ed->texFiles[0] = texAutOpt->value.list.value;
ed->numTex[0] = texAutOpt->value.list.nValue;
for (s = d->screens; s; s = s->next)
updateElementTextures (s, TRUE);
}
break;
case ElementsDisplayOptionBubblesTextures:
{
CompScreen *s;
CompOption *texBubblesOpt;
texBubblesOpt = elementsGetBubblesTexturesOption (d);
ed->texFiles[4] = texBubblesOpt->value.list.value;
ed->numTex[4] = texBubblesOpt->value.list.nValue;
for (s = d->screens; s; s = s->next)
updateElementTextures (s, TRUE);
}
break;
case ElementsDisplayOptionFirefliesTextures:
{
CompScreen *s;
CompOption *texFfOpt;
texFfOpt = elementsGetFirefliesTexturesOption (d);
ed->texFiles[1] = texFfOpt->value.list.value;
ed->numTex[1] = texFfOpt->value.list.nValue;
for (s = d->screens; s; s = s->next)
updateElementTextures (s, TRUE);
}
break;
case ElementsDisplayOptionSnowTextures:
{
CompScreen *s;
CompOption *texSnowOpt;
texSnowOpt = elementsGetSnowTexturesOption (d);
ed->texFiles[2] = texSnowOpt->value.list.value;
ed->numTex[2] = texSnowOpt->value.list.nValue;
for (s = d->screens; s; s = s->next)
updateElementTextures (s, TRUE);
}
break;
case ElementsDisplayOptionStarsTextures:
{
CompScreen *s;
CompOption *texStarsOpt;
texStarsOpt = elementsGetStarsTexturesOption (d);
ed->texFiles[3] = texStarsOpt->value.list.value;
ed->numTex[3] = texStarsOpt->value.list.nValue;
for (s = d->screens; s; s = s->next)
updateElementTextures (s, TRUE);
}
break;
default:
break;
}
}
static void
ringHandleEvent (CompDisplay *d,
XEvent *event)
{
CompScreen *s;
CompWindow *w = NULL;
switch (event->type) {
case DestroyNotify:
/* We need to get the CompWindow * for event->xdestroywindow.window
here because in the (*d->handleEvent) call below, that CompWindow's
id will become 1, so findWindowAtDisplay won't be able to find the
CompWindow after that. */
w = findWindowAtDisplay (d, event->xdestroywindow.window);
break;
}
RING_DISPLAY (d);
UNWRAP (rd, d, handleEvent);
(*d->handleEvent) (d, event);
WRAP (rd, d, handleEvent, ringHandleEvent);
switch (event->type) {
case PropertyNotify:
if (event->xproperty.atom == XA_WM_NAME)
{
CompWindow *w;
w = findWindowAtDisplay (d, event->xproperty.window);
if (w)
{
RING_SCREEN (w->screen);
if (rs->grabIndex && (w == rs->selectedWindow))
{
ringRenderWindowTitle (w->screen);
damageScreen (w->screen);
}
}
}
break;
case ButtonPress:
if (event->xbutton.button == Button1)
{
s = findScreenAtDisplay (d, event->xbutton.root);
if (s)
{
RING_SCREEN (s);
if (rs->grabIndex)
ringWindowSelectAt (s,
event->xbutton.x_root,
event->xbutton.y_root,
TRUE);
}
}
break;
case MotionNotify:
s = findScreenAtDisplay (d, event->xmotion.root);
if (s)
{
RING_SCREEN (s);
if (rs->grabIndex)
ringWindowSelectAt (s,
event->xmotion.x_root,
event->xmotion.y_root,
FALSE);
}
case UnmapNotify:
w = findWindowAtDisplay (d, event->xunmap.window);
ringWindowRemove (d, w);
break;
case DestroyNotify:
ringWindowRemove (d, w);
break;
}
}
static void
ringWindowRemove (CompDisplay *d,
CompWindow *w)
{
if (w)
{
Bool inList = FALSE;
int j, i = 0;
CompWindow *selected;
RING_SCREEN (w->screen);
if (rs->state == RingStateNone)
return;
if (isRingWin (w))
return;
selected = rs->selectedWindow;
while (i < rs->nWindows)
{
if (w == rs->windows[i])
{
inList = TRUE;
if (w == selected)
{
if (i < (rs->nWindows - 1))
selected = rs->windows[i + 1];
else
selected = rs->windows[0];
rs->selectedWindow = selected;
ringRenderWindowTitle (w->screen);
}
rs->nWindows--;
for (j = i; j < rs->nWindows; j++)
rs->windows[j] = rs->windows[j + 1];
}
else
{
i++;
}
}
if (!inList)
return;
if (rs->nWindows == 0)
{
CompOption o;
o.type = CompOptionTypeInt;
o.name = "root";
o.value.i = w->screen->root;
ringTerminate (d, NULL, 0, &o, 1);
return;
}
// Let the window list be updated to avoid crash
// when a window is closed while ending (RingStateIn).
if (!rs->grabIndex && rs->state != RingStateIn)
return;
if (ringUpdateWindowList (w->screen))
{
rs->moreAdjust = TRUE;
rs->state = RingStateOut;
damageScreen (w->screen);
}
}
}
static void
ringWindowSelectAt (CompScreen *s,
int x,
int y,
Bool terminate)
{
int i;
CompWindow *selected = NULL;
RING_SCREEN (s);
if (!ringGetSelectWithMouse (s))
return;
/* first find the top-most window the mouse
pointer is over */
for (i = rs->nWindows - 1; i >= 0; i--)
{
if (rs->drawSlots[i].slot && *(rs->drawSlots[i].slot))
{
CompWindow *w = rs->drawSlots[i].w;
RING_WINDOW (w);
if ((x >= (rw->tx + w->attrib.x)) &&
(x <= (rw->tx + w->attrib.x + (w->attrib.width * rw->scale))) &&
(y >= (rw->ty + w->attrib.y)) &&
(y <= (rw->ty + w->attrib.y + (w->attrib.height * rw->scale))))
{
/* we have found one, select it */
selected = w;
break;
}
}
}
if (selected && terminate)
{
CompOption o;
o.type = CompOptionTypeInt;
o.name = "root";
o.value.i = s->root;
rs->selectedWindow = selected;
ringTerminate (s->display, NULL, 0, &o, 1);
}
else if (!terminate && (selected != rs->selectedWindow || !rs->textData))
{
if (!selected)
{
ringFreeWindowTitle (s);
}
else
{
rs->selectedWindow = selected;
ringRenderWindowTitle (s);
}
damageScreen (s);
}
}
static Bool
ringInitiate (CompScreen *s,
CompAction *action,
CompActionState state,
CompOption *option,
int nOption)
{
CompMatch *match;
int count;
RING_SCREEN (s);
if (otherScreenGrabExist (s, "ring", NULL))
return FALSE;
rs->currentMatch = ringGetWindowMatch (s);
match = getMatchOptionNamed (option, nOption, "match", NULL);
if (match)
{
matchFini (&rs->match);
matchInit (&rs->match);
if (matchCopy (&rs->match, match))
{
matchUpdate (s->display, &rs->match);
rs->currentMatch = &rs->match;
}
}
count = ringCountWindows (s);
if (count < 1)
return FALSE;
if (!rs->grabIndex)
{
if (ringGetSelectWithMouse (s))
rs->grabIndex = pushScreenGrab (s, s->normalCursor, "ring");
else
rs->grabIndex = pushScreenGrab (s, s->invisibleCursor, "ring");
}
if (rs->grabIndex)
{
rs->state = RingStateOut;
if (!ringCreateWindowList (s))
return FALSE;
rs->selectedWindow = rs->windows[0];
ringRenderWindowTitle (s);
rs->rotTarget = 0;
rs->moreAdjust = TRUE;
damageScreen (s);
switchActivateEvent (s, TRUE);
}
return TRUE;
}
/*
* groupHandleEvent
*
*/
void
groupHandleEvent (XEvent *event)
{
CompWindow *w;
CompScreen *s;
GROUP_DISPLAY (&display);
switch (event->type) {
case KeyPress:
if (isKeyPressEvent (event, &gd->select_single_key))
groupSelectSingle (display.activeWindow);
else if (isKeyPressEvent (event, &gd->group_key))
groupGroupWindows (event->xkey.root);
else if (isKeyPressEvent (event, &gd->ungroup_key))
groupUnGroupWindows (event->xkey.root);
else if (isKeyPressEvent (event, &gd->remove_key))
groupRemoveWindow (display.activeWindow);
else if (isKeyPressEvent (event, &gd->close_key))
groupCloseWindows (display.activeWindow);
else if (isKeyPressEvent (event, &gd->ignore_key))
groupSetIgnore ();
else if (isKeyPressEvent (event, &gd->tabmode_key))
groupInitTab (display.activeWindow);
else if (isKeyPressEvent (event, &gd->change_tab_left_key))
groupChangeTabLeft (display.activeWindow);
else if (isKeyPressEvent (event, &gd->change_tab_right_key))
groupChangeTabRight (display.activeWindow);
else if (isKeyPressEvent (event, &gd->change_color_key))
groupChangeColor (display.activeWindow);
break;
case KeyRelease:
if (gd->ignore_key.keycode == event->xkey.keycode)
groupUnsetIgnore ();
break;
case MotionNotify:
s = findScreenAtDisplay (event->xmotion.root);
if (s)
groupHandleMotionEvent (s, pointerX, pointerY);
break;
case ButtonPress:
if (isButtonPressEvent (event, &gd->select_button))
groupSelect (event->xbutton.window);
s = findScreenAtDisplay (event->xbutton.root);
if (s)
groupHandleButtonPressEvent (s, event);
break;
case ButtonRelease:
if (gd->select_button.button == event->xbutton.button)
groupSelectTerminate (event->xbutton.root);
s = findScreenAtDisplay (event->xbutton.root);
if (s)
groupHandleButtonReleaseEvent (s, event);
break;
case MapNotify:
w = findWindowAtDisplay (event->xmap.window);
if (w)
{
CompWindow *cw;
for (cw = w->screen->windows; cw; cw = cw->next)
{
if (w->id == cw->frame)
{
GROUP_WINDOW (cw);
if (gw->windowHideInfo)
XUnmapWindow (display.display, cw->frame);
}
}
}
break;
case UnmapNotify:
w = findWindowAtDisplay (event->xunmap.window);
if (w)
{
GROUP_WINDOW (w);
if (w->pendingUnmaps)
{
if (w->shaded)
{
gw->windowState = WindowShaded;
const BananaValue *
option_shade_all = bananaGetOption (bananaIndex,
"shade_all",
w->screen->screenNum);
if (gw->group && option_shade_all->b)
groupShadeWindows (w, gw->group, TRUE);
}
else if (w->minimized)
{
gw->windowState = WindowMinimized;
const BananaValue *
option_minimize_all = bananaGetOption (bananaIndex,
"minimize_all",
w->screen->screenNum);
if (gw->group && option_minimize_all->b)
groupMinimizeWindows (w, gw->group, TRUE);
}
}
if (gw->group)
{
if (gw->group->tabBar && IS_TOP_TAB (w, gw->group))
{
/* on unmap of the top tab, hide the tab bar and the
input prevention window */
groupTabSetVisibility (gw->group, FALSE, PERMANENT);
}
if (!w->pendingUnmaps)
{
/* close event */
if (!(gw->animateState & IS_UNGROUPING))
{
groupDeleteGroupWindow (w);
damageScreen (w->screen);
}
}
}
}
break;
case ClientMessage:
if (event->xclient.message_type == display.winActiveAtom)
{
w = findWindowAtDisplay (event->xclient.window);
if (w)
{
GROUP_WINDOW (w);
if (gw->group && gw->group->tabBar &&
!IS_TOP_TAB (w, gw->group))
{
gw->group->checkFocusAfterTabChange = TRUE;
groupChangeTab (gw->slot, RotateUncertain);
}
}
}
else if (event->xclient.message_type == gd->resizeNotifyAtom)
{
CompWindow *w;
w = findWindowAtDisplay (event->xclient.window);
if (w && gd->resizeInfo && (w == gd->resizeInfo->resizedWindow))
{
GROUP_WINDOW (w);
GROUP_SCREEN (w->screen);
if (gw->group)
{
int i;
XRectangle rect;
rect.x = event->xclient.data.l[0];
rect.y = event->xclient.data.l[1];
rect.width = event->xclient.data.l[2];
rect.height = event->xclient.data.l[3];
for (i = 0; i < gw->group->nWins; i++)
{
CompWindow *cw = gw->group->windows[i];
GroupWindow *gcw;
gcw = GET_GROUP_WINDOW (cw, gs);
if (gcw->resizeGeometry)
{
if (groupUpdateResizeRectangle (cw, &rect, TRUE))
addWindowDamage (cw);
}
}
}
}
}
break;
default:
if (event->type == display.shapeEvent + ShapeNotify)
{
XShapeEvent *se = (XShapeEvent *) event;
if (se->kind == ShapeInput)
{
CompWindow *w;
w = findWindowAtDisplay (se->window);
if (w)
{
GROUP_WINDOW (w);
if (gw->windowHideInfo)
groupClearWindowInputShape (w, gw->windowHideInfo);
}
}
}
break;
}
UNWRAP (gd, &display, handleEvent);
(*display.handleEvent)(event);
WRAP (gd, &display, handleEvent, groupHandleEvent);
switch (event->type) {
case PropertyNotify:
if (event->xproperty.atom == display.wmNameAtom)
{
CompWindow *w;
w = findWindowAtDisplay (event->xproperty.window);
if (w)
{
GROUP_WINDOW (w);
if (gw->group && gw->group->tabBar &&
gw->group->tabBar->textSlot &&
gw->group->tabBar->textSlot->window == w)
{
/* make sure we are using the updated name */
groupRenderWindowTitle (gw->group);
groupDamageTabBarRegion (gw->group);
}
}
}
break;
case EnterNotify:
{
CompWindow *w;
w = findWindowAtDisplay (event->xcrossing.window);
if (w)
{
GROUP_WINDOW (w);
GROUP_SCREEN (w->screen);
if (gs->showDelayTimeoutHandle)
compRemoveTimeout (gs->showDelayTimeoutHandle);
if (w->id != w->screen->grabWindow)
groupUpdateTabBars (w->screen, w->id);
if (gw->group)
{
if (gs->draggedSlot && gs->dragged &&
IS_TOP_TAB (w, gw->group))
{
int hoverTime;
const BananaValue *
option_drag_hover_time = bananaGetOption (bananaIndex,
"drag_hover_time",
w->screen->screenNum);
hoverTime = option_drag_hover_time->f * 1000;
if (gs->dragHoverTimeoutHandle)
compRemoveTimeout (gs->dragHoverTimeoutHandle);
if (hoverTime > 0)
gs->dragHoverTimeoutHandle =
compAddTimeout (hoverTime,
(float) hoverTime * 1.2,
groupDragHoverTimeout, w);
}
}
}
}
break;
case ConfigureNotify:
{
CompWindow *w;
w = findWindowAtDisplay (event->xconfigure.window);
if (w)
{
GROUP_WINDOW (w);
if (gw->group && gw->group->tabBar &&
IS_TOP_TAB (w, gw->group) &&
gw->group->inputPrevention && gw->group->ipwMapped)
{
XWindowChanges xwc;
xwc.stack_mode = Above;
xwc.sibling = w->id;
XConfigureWindow (display.display,
gw->group->inputPrevention,
CWSibling | CWStackMode, &xwc);
}
if (event->xconfigure.above != None)
{
if (gw->group && !gw->group->tabBar &&
(gw->group != gd->lastRestackedGroup))
{
const BananaValue *
option_raise_all = bananaGetOption (bananaIndex,
"raise_all",
w->screen->screenNum);
if (option_raise_all->b)
groupRaiseWindows (w, gw->group);
}
if (w->managed && !w->attrib.override_redirect)
gd->lastRestackedGroup = gw->group;
}
}
}
break;
default:
break;
}
}
static void
colorFilterChangeNotify (const char *optionName,
BananaType optionType,
const BananaValue *optionValue,
int screenNum)
{
FILTER_DISPLAY (&display);
if (strcasecmp (optionName, "toggle_window_key") == 0)
updateKey (optionValue->s, &cfd->toggle_window_key);
else if (strcasecmp (optionName, "toggle_screen_key") == 0)
updateKey (optionValue->s, &cfd->toggle_screen_key);
else if (strcasecmp (optionName, "switch_filter_key") == 0)
updateKey (optionValue->s, &cfd->switch_filter_key);
else if (strcasecmp (optionName, "filter_match") == 0)
{
CompWindow *w;
CompScreen *s = getScreenFromScreenNum (screenNum);
FILTER_SCREEN (s);
//Re-check every window against new match settings
for (w = s->windows; w; w = w->next)
{
FILTER_WINDOW (w);
if (matchEval (&cfs->filter_match, w) &&
cfs->isFiltered && !cfw->isFiltered)
{
colorFilterToggleWindow (w);
}
}
}
else if (strcasecmp (optionName, "exclude_match") == 0)
{
CompWindow *w;
CompScreen *s = getScreenFromScreenNum (screenNum);
FILTER_SCREEN (s);
// Re-check every window against new match settings
for (w = s->windows; w; w = w->next)
{
Bool isExcluded;
FILTER_WINDOW (w);
isExcluded = matchEval (&cfs->exclude_match, w);
if (isExcluded && cfw->isFiltered)
colorFilterToggleWindow (w);
else if (!isExcluded && cfs->isFiltered && !cfw->isFiltered)
colorFilterToggleWindow (w);
}
}
else if (strcasecmp (optionName, "filters") == 0)
{
CompScreen *s = getScreenFromScreenNum (screenNum);
FILTER_SCREEN (s);
/* Just set the filtersLoaded boolean to FALSE, unloadFilters will be
* called in loadFilters */
cfs->filtersLoaded = FALSE;
}
else if (strcasecmp (optionName, "filter_decorations") == 0)
{
CompScreen *s = getScreenFromScreenNum (screenNum);
damageScreen (s);
}
}
static void
snowDisplayOptionChanged (CompDisplay *d,
CompOption *opt,
FirefliesDisplayOptions num)
{
SNOW_DISPLAY (d);
switch (num)
{
case FirefliesDisplayOptionSnowSize:
{
CompScreen *s;
for (s = d->screens; s; s = s->next)
{
SNOW_SCREEN (s);
ss->displayListNeedsUpdate = TRUE;
updateSnowTextures (s);
}
}
break;
case FirefliesDisplayOptionSnowUpdateDelay:
{
CompScreen *s;
for (s = d->screens; s; s = s->next)
{
SNOW_SCREEN (s);
if (ss->timeoutHandle)
compRemoveTimeout (ss->timeoutHandle);
ss->timeoutHandle =
compAddTimeout (firefliesGetSnowUpdateDelay (d),
firefliesGetSnowUpdateDelay (d) * 1.2, stepSnowPositions, s);
}
}
break;
case FirefliesDisplayOptionNumSnowflakes:
{
CompScreen *s;
int i, numFlakes;
SnowFlake *snowFlake;
numFlakes = firefliesGetNumSnowflakes (d);
for (s = d->screens; s; s = s->next)
{
SNOW_SCREEN (s);
ss->allSnowFlakes = realloc (ss->allSnowFlakes,
numFlakes * sizeof (SnowFlake));
snowFlake = ss->allSnowFlakes;
for (i = 0; i < numFlakes; i++)
{
initiateSnowFlake (ss, snowFlake);
setSnowflakeTexture (ss, snowFlake);
snowFlake++;
}
}
}
break;
case FirefliesDisplayOptionSnowTextures:
{
CompScreen *s;
CompOption *texOpt;
texOpt = firefliesGetSnowTexturesOption (d);
sd->snowTexFiles = texOpt->value.list.value;
sd->snowTexNFiles = texOpt->value.list.nValue;
for (s = d->screens; s; s = s->next)
updateSnowTextures (s);
}
break;
case FirefliesDisplayOptionDefaultEnabled:
{
CompScreen *s;
for (s = d->screens; s; s = s->next)
{
SNOW_SCREEN (s);
ss->active = firefliesGetDefaultEnabled(s->display);
ss->displayListNeedsUpdate = TRUE;
damageScreen (s);
}
}
break;
default:
break;
}
}
static void
groupChangeNotify (const char *optionName,
BananaType optionType,
const BananaValue *optionValue,
int screenNum)
{
GROUP_DISPLAY (&display);
if (strcasecmp (optionName, "window_match") == 0)
{
CompScreen *s = getScreenFromScreenNum (screenNum);
GROUP_SCREEN (s);
matchFini (&gs->window_match);
matchInit (&gs->window_match);
matchAddFromString (&gs->window_match, optionValue->s);
matchUpdate (&gs->window_match);
}
else if (strcasecmp (optionName, "tab_base_color") == 0 ||
strcasecmp (optionName, "tab_highlight_color") == 0 ||
strcasecmp (optionName, "tab_border_color") == 0 ||
strcasecmp (optionName, "tab_style") == 0 ||
strcasecmp (optionName, "border_radius") == 0 ||
strcasecmp (optionName, "border_width") == 0)
{
GroupSelection *group;
CompScreen *s = getScreenFromScreenNum (screenNum);
GROUP_SCREEN (s);
for (group = gs->groups; group; group = group->next)
if (group->tabBar)
groupRenderTabBarBackground (group);
}
else if (strcasecmp (optionName, "tabbar_font_size") == 0 ||
strcasecmp (optionName, "tabbar_font_color") == 0)
{
GroupSelection *group;
CompScreen *s = getScreenFromScreenNum (screenNum);
GROUP_SCREEN (s);
for (group = gs->groups; group; group = group->next)
groupRenderWindowTitle (group);
}
else if (strcasecmp (optionName, "thumb_size") == 0 ||
strcasecmp (optionName, "thumb_space") == 0)
{
GroupSelection *group;
CompScreen *s = getScreenFromScreenNum (screenNum);
GROUP_SCREEN (s);
for (group = gs->groups; group; group = group->next)
if (group->tabBar)
{
BoxPtr box = &group->tabBar->region->extents;
groupRecalcTabBarPos (group, (box->x1 + box->x2 ) / 2,
box->x1, box->x2);
}
}
else if (strcasecmp (optionName, "glow") == 0 ||
strcasecmp (optionName, "glow_size") == 0)
{
CompScreen *s = getScreenFromScreenNum (screenNum);
GROUP_SCREEN (s);
CompWindow *w;
for (w = s->windows; w; w = w->next)
{
GROUP_WINDOW (w);
groupComputeGlowQuads (w, &gs->glowTexture.matrix);
if (gw->glowQuads)
{
damageWindowOutputExtents (w);
updateWindowOutputExtents (w);
damageWindowOutputExtents (w);
}
}
}
else if (strcasecmp (optionName, "glow_type") == 0)
{
CompScreen *s = getScreenFromScreenNum (screenNum);
GROUP_SCREEN (s);
int glowType;
GlowTextureProperties *glowProperty;
GROUP_DISPLAY (&display);
const BananaValue *
option_glow_type = bananaGetOption (bananaIndex,
"glow_type",
s->screenNum);
glowType = option_glow_type->i;
glowProperty = &gd->glowTextureProperties[glowType];
finiTexture (s, &gs->glowTexture);
initTexture (s, &gs->glowTexture);
imageDataToTexture (s, &gs->glowTexture,
glowProperty->textureData,
glowProperty->textureSize,
glowProperty->textureSize,
GL_RGBA, GL_UNSIGNED_BYTE);
const BananaValue *
option_glow = bananaGetOption (bananaIndex,
"glow",
s->screenNum);
if (option_glow->b && gs->groups)
{
CompWindow *w;
for (w = s->windows; w; w = w->next)
groupComputeGlowQuads (w, &gs->glowTexture.matrix);
damageScreen (s);
}
}
else if (strcasecmp (optionName, "select_button") == 0)
updateButton (optionValue->s, &gd->select_button);
else if (strcasecmp (optionName, "select_single_key") == 0)
updateKey (optionValue->s, &gd->select_single_key);
else if (strcasecmp (optionName, "group_key") == 0)
updateKey (optionValue->s, &gd->group_key);
else if (strcasecmp (optionName, "ungroup_key") == 0)
updateKey (optionValue->s, &gd->ungroup_key);
else if (strcasecmp (optionName, "remove_key") == 0)
updateKey (optionValue->s, &gd->remove_key);
else if (strcasecmp (optionName, "close_key") == 0)
updateKey (optionValue->s, &gd->close_key);
else if (strcasecmp (optionName, "ignore_key") == 0)
updateKey (optionValue->s, &gd->ignore_key);
else if (strcasecmp (optionName, "tabmode_key") == 0)
updateKey (optionValue->s, &gd->tabmode_key);
else if (strcasecmp (optionName, "change_tab_left_key") == 0)
updateKey (optionValue->s, &gd->change_tab_left_key);
else if (strcasecmp (optionName, "change_tab_right_key") == 0)
updateKey (optionValue->s, &gd->change_tab_right_key);
else if (strcasecmp (optionName, "change_color_key") == 0)
updateKey (optionValue->s, &gd->change_color_key);
else if (strcasecmp (optionName, "autotab_windows") == 0)
{
CompScreen *s = getScreenFromScreenNum (screenNum);
GROUP_SCREEN (s);
int i;
if (gs->autotab && gs->autotabCount != 0)
{
for (i = 0; i <= gs->autotabCount - 1; i++)
matchFini (&gs->autotab[i]);
free (gs->autotab);
}
gs->autotabCount = optionValue->list.nItem;
gs->autotab = malloc (gs->autotabCount * sizeof (CompMatch));
for (i = 0; i <= gs->autotabCount - 1; i++)
{
matchInit (&gs->autotab[i]);
matchAddFromString (&gs->autotab[i], optionValue->list.item[i].s);
matchUpdate (&gs->autotab[i]);
}
}
}
/*
* Damage decorations after the "Filter Decorations" setting got changed
*/
static void
colorFilterDamageDecorations (CompScreen *s, CompOption *opt,
ColorfilterScreenOptions num)
{
damageScreen (s);
}
