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_WINDOW (w);
if (!fw->direction)
fw->opacity = OPAQUE - 1;
fw->direction = -1;
fw->destroyed = 1;
addWindowDamage (w);
return;
}
break;
case UnmapNotify:
w = findWindowAtDisplay (d, event->xunmap.window);
if (w)
{
FADE_WINDOW (w);
if (!fw->direction)
fw->opacity = OPAQUE - 1;
fw->direction = -1;
addWindowDamage (w);
return;
}
break;
case MapNotify:
w = findWindowAtDisplay (d, event->xunmap.window);
if (w)
{
FADE_WINDOW (w);
/* make sure any pending unmap are processed */
if (fw->direction < 0)
unmapWindow (w);
}
default:
break;
}
UNWRAP (fd, d, handleEvent);
(*d->handleEvent) (d, event);
WRAP (fd, d, handleEvent, fadeHandleEvent);
}
static Bool
fadeDamageWindowRect(CompWindow *w,
Bool initial,
BoxPtr rect)
{
Bool status;
FADE_SCREEN(w->screen);
if (initial)
{
FADE_WINDOW(w);
fw->fadeOut = FALSE;
if (fw->shaded)
{
fw->shaded = w->shaded;
}
else if (matchEval(&fs->match, w))
{
if (isFadeWinForOpenClose(w))
{
fw->opacity = 0;
fw->targetOpacity = 0;
}
}
}
UNWRAP(fs, w->screen, damageWindowRect);
status = (*w->screen->damageWindowRect)(w, initial, rect);
WRAP(fs, w->screen, damageWindowRect, fadeDamageWindowRect);
return status;
}
static Bool
fadeDamageWindowRect (CompWindow *w,
Bool initial,
BoxPtr rect)
{
Bool status;
FADE_SCREEN (w->screen);
if (initial)
{
FADE_WINDOW (w);
if (!fw->direction)
fw->opacity = 1;
fw->direction = 1;
}
UNWRAP (fs, w->screen, damageWindowRect);
status = (*w->screen->damageWindowRect) (w, initial, rect);
WRAP (fs, w->screen, damageWindowRect, fadeDamageWindowRect);
return status;
}
static void
fadeFiniWindow (CompPlugin *p,
CompWindow *w)
{
FADE_WINDOW (w);
free (fw);
}
static void
fadeFiniWindow(CompPlugin *p,
CompWindow *w)
{
FADE_WINDOW(w);
fadeRemoveDisplayModal(w->screen->display, w);
fadeWindowStop(w);
free(fw);
}
static Bool
fadeFocusWindow(CompWindow *w)
{
Bool status;
FADE_SCREEN(w->screen);
FADE_WINDOW(w);
if (fw->destroyCnt || fw->unmapCnt)
return FALSE;
UNWRAP(fs, w->screen, focusWindow);
status = (*w->screen->focusWindow)(w);
WRAP(fs, w->screen, focusWindow, fadeFocusWindow);
return status;
}
static void
fadeWindowStop(CompWindow *w)
{
FADE_WINDOW(w);
while (fw->unmapCnt)
{
unmapWindow(w);
fw->unmapCnt--;
}
while (fw->destroyCnt)
{
destroyWindow(w);
fw->destroyCnt--;
}
}
static void
fadeRemoveDisplayModal(CompDisplay *d,
CompWindow *w)
{
FADE_DISPLAY(d);
FADE_WINDOW(w);
if (!fw->dModal)
return;
fw->dModal = 0;
fd->displayModals--;
if (fd->displayModals == 0)
{
CompScreen *s;
for (s = d->screens; s; s = s->next)
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 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 Bool
fadePaintWindow(CompWindow *w,
const WindowPaintAttrib *attrib,
const CompTransform *transform,
Region region,
unsigned int mask)
{
CompScreen *s = w->screen;
Bool status;
FADE_DISPLAY(s->display);
FADE_SCREEN(s);
FADE_WINDOW(w);
if (!w->screen->canDoSlightlySaturated)
fw->saturation = attrib->saturation;
if (!w->alive ||
fw->destroyCnt ||
fw->unmapCnt ||
fw->opacity != attrib->opacity ||
fw->brightness != attrib->brightness ||
fw->saturation != attrib->saturation ||
fd->displayModals)
{
WindowPaintAttrib fAttrib = *attrib;
int mode = fs->opt[FADE_SCREEN_OPTION_FADE_MODE].value.i;
if (!w->alive && fs->opt[FADE_SCREEN_OPTION_DIM_UNRESPONSIVE].value.b)
{
GLuint value;
value = fs->opt[FADE_SCREEN_OPTION_UNRESPONSIVE_BRIGHTNESS].value.i;
if (value != 100)
fAttrib.brightness = fAttrib.brightness * value / 100;
value = fs->opt[FADE_SCREEN_OPTION_UNRESPONSIVE_SATURATION].value.i;
if (value != 100 && s->canDoSlightlySaturated)
fAttrib.saturation = fAttrib.saturation * value / 100;
}
else if (fd->displayModals && !fw->dModal)
{
fAttrib.brightness = 0xa8a8;
fAttrib.saturation = 0;
}
if (fw->fadeOut)
fAttrib.opacity = 0;
if (mode == FADE_MODE_CONSTANTTIME)
{
if (fAttrib.opacity != fw->targetOpacity ||
fAttrib.brightness != fw->targetBrightness ||
fAttrib.saturation != fw->targetSaturation)
{
fw->fadeTime = fs->opt[FADE_SCREEN_OPTION_FADE_TIME].value.i;
fw->steps = 1;
fw->opacityDiff = fAttrib.opacity - fw->opacity;
fw->brightnessDiff = fAttrib.brightness - fw->brightness;
fw->saturationDiff = fAttrib.saturation - fw->saturation;
fw->targetOpacity = fAttrib.opacity;
fw->targetBrightness = fAttrib.brightness;
fw->targetSaturation = fAttrib.saturation;
}
}
if (fw->steps)
{
GLint opacity = OPAQUE;
GLint brightness = BRIGHT;
GLint saturation = COLOR;
if (mode == FADE_MODE_CONSTANTSPEED)
{
opacity = fw->opacity;
if (fAttrib.opacity > fw->opacity)
{
opacity = fw->opacity + fw->steps;
if (opacity > fAttrib.opacity)
opacity = fAttrib.opacity;
}
else if (fAttrib.opacity < fw->opacity)
{
opacity = fw->opacity - fw->steps;
if (opacity < fAttrib.opacity)
opacity = fAttrib.opacity;
}
brightness = fw->brightness;
if (fAttrib.brightness > fw->brightness)
{
brightness = fw->brightness + (fw->steps / 12);
if (brightness > fAttrib.brightness)
brightness = fAttrib.brightness;
}
else if (fAttrib.brightness < fw->brightness)
{
brightness = fw->brightness - (fw->steps / 12);
if (brightness < fAttrib.brightness)
brightness = fAttrib.brightness;
}
saturation = fw->saturation;
if (fAttrib.saturation > fw->saturation)
{
saturation = fw->saturation + (fw->steps / 6);
if (saturation > fAttrib.saturation)
saturation = fAttrib.saturation;
}
else if (fAttrib.saturation < fw->saturation)
{
saturation = fw->saturation - (fw->steps / 6);
if (saturation < fAttrib.saturation)
saturation = fAttrib.saturation;
}
}
else if (mode == FADE_MODE_CONSTANTTIME)
{
int fadeTime = fs->opt[FADE_SCREEN_OPTION_FADE_TIME].value.i;
opacity = fAttrib.opacity -
(fw->opacityDiff * fw->fadeTime / fadeTime);
brightness = fAttrib.brightness -
(fw->brightnessDiff * fw->fadeTime / fadeTime);
saturation = fAttrib.saturation -
(fw->saturationDiff * fw->fadeTime / fadeTime);
}
fw->steps = 0;
if (opacity > 0)
{
fw->opacity = opacity;
fw->brightness = brightness;
fw->saturation = saturation;
if (opacity != fAttrib.opacity ||
brightness != fAttrib.brightness ||
saturation != fAttrib.saturation)
addWindowDamage(w);
}
else
{
fw->opacity = 0;
fadeWindowStop(w);
}
}
fAttrib.opacity = fw->opacity;
fAttrib.brightness = fw->brightness;
fAttrib.saturation = fw->saturation;
UNWRAP(fs, s, paintWindow);
status = (*s->paintWindow)(w, &fAttrib, transform, region, mask);
WRAP(fs, s, paintWindow, fadePaintWindow);
}
else
{
UNWRAP(fs, s, paintWindow);
status = (*s->paintWindow)(w, attrib, transform, region, mask);
WRAP(fs, s, paintWindow, fadePaintWindow);
}
return status;
}
static Bool
fadePaintWindow (CompWindow *w,
const WindowPaintAttrib *attrib,
Region region,
unsigned int mask)
{
CompScreen *s = w->screen;
Bool status;
FADE_SCREEN (s);
FADE_WINDOW (w);
if (fw->opacity < OPAQUE)
{
GLint opacity;
opacity = fw->opacity + fs->steps * fw->direction;
if (opacity > 0)
{
if (opacity < OPAQUE)
{
WindowPaintAttrib fAttrib = *attrib;
fAttrib.opacity = MULTIPLY_USHORT (opacity, attrib->opacity);
UNWRAP (fs, s, paintWindow);
status = (*s->paintWindow) (w, &fAttrib, region, mask);
WRAP (fs, s, paintWindow, fadePaintWindow);
if (status)
{
fw->opacity = opacity;
addWindowDamage (w);
}
}
else
{
UNWRAP (fs, s, paintWindow);
status = (*s->paintWindow) (w, attrib, region, mask);
WRAP (fs, s, paintWindow, fadePaintWindow);
if (status)
{
fw->opacity = OPAQUE;
fw->direction = 0;
}
}
}
else
{
fw->opacity = 0;
fw->direction = 0;
if (fw->destroyed)
destroyWindow (w);
else
unmapWindow (w);
return (mask & PAINT_WINDOW_SOLID_MASK) ? FALSE : TRUE;
}
}
else
{
UNWRAP (fs, s, paintWindow);
status = (*s->paintWindow) (w, attrib, region, mask);
WRAP (fs, s, paintWindow, fadePaintWindow);
}
return status;
}
