static Bool
fadeInitScreen (CompPlugin *p,
CompScreen *s)
{
FadeScreen *fs;
FADE_DISPLAY (s->display);
fs = malloc (sizeof (FadeScreen));
if (!fs)
return FALSE;
fs->windowPrivateIndex = allocateWindowPrivateIndex (s);
if (fs->windowPrivateIndex < 0)
{
free (fs);
return FALSE;
}
fs->steps = 0;
fs->fadeTime = 1000.0f / FADE_SPEED_DEFAULT;
fadeScreenInitOptions (fs);
WRAP (fs, s, preparePaintScreen, fadePreparePaintScreen);
WRAP (fs, s, paintWindow, fadePaintWindow);
WRAP (fs, s, damageWindowRect, fadeDamageWindowRect);
s->privates[fd->screenPrivateIndex].ptr = fs;
return TRUE;
}
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 void
fadeFiniDisplay (CompPlugin *p,
CompDisplay *d)
{
FADE_DISPLAY (d);
freeScreenPrivateIndex (d, fd->screenPrivateIndex);
UNWRAP (fd, d, handleEvent);
free (fd);
}
/* Returns whether this window should be faded
* on open and close events. */
static Bool
isFadeWinForOpenClose(CompWindow *w)
{
FADE_DISPLAY(w->screen->display);
FADE_SCREEN(w->screen);
if (fs->opt[FADE_SCREEN_OPTION_MINIMIZE_OPEN_CLOSE].value.b &&
!fd->suppressMinimizeOpenClose)
{
return TRUE;
}
return matchEval(&fd->alwaysFadeWindowMatch, w);
}
static void
fadeMatchExpHandlerChanged(CompDisplay *d)
{
CompScreen *s;
FADE_DISPLAY(d);
for (s = d->screens; s; s = s->next)
matchUpdate(d, &GET_FADE_SCREEN(s, fd)->match);
UNWRAP(fd, d, matchExpHandlerChanged);
(*d->matchExpHandlerChanged)(d);
WRAP(fd, d, matchExpHandlerChanged, fadeMatchExpHandlerChanged);
}
static void
fadeFiniDisplay(CompPlugin *p,
CompDisplay *d)
{
FADE_DISPLAY(d);
freeScreenPrivateIndex(d, fd->screenPrivateIndex);
matchFini(&fd->alwaysFadeWindowMatch);
UNWRAP(fd, d, handleEvent);
UNWRAP(fd, d, matchExpHandlerChanged);
free(fd);
}
static Bool
fadeInitScreen(CompPlugin *p,
CompScreen *s)
{
FadeScreen *fs;
FADE_DISPLAY(s->display);
fs = malloc(sizeof (FadeScreen));
if (!fs)
return FALSE;
if (!compInitScreenOptionsFromMetadata(s,
&fadeMetadata,
fadeScreenOptionInfo,
fs->opt,
FADE_SCREEN_OPTION_NUM))
{
free(fs);
return FALSE;
}
fs->windowPrivateIndex = allocateWindowPrivateIndex(s);
if (fs->windowPrivateIndex < 0)
{
compFiniScreenOptions(s, fs->opt, FADE_SCREEN_OPTION_NUM);
free(fs);
return FALSE;
}
fs->fadeTime = 1000.0f / fs->opt[FADE_SCREEN_OPTION_FADE_SPEED].value.f;
matchInit(&fs->match);
fadeUpdateWindowFadeMatch(s->display,
&fs->opt[FADE_SCREEN_OPTION_WINDOW_MATCH].value,
&fs->match);
WRAP(fs, s, preparePaintScreen, fadePreparePaintScreen);
WRAP(fs, s, paintWindow, fadePaintWindow);
WRAP(fs, s, damageWindowRect, fadeDamageWindowRect);
WRAP(fs, s, focusWindow, fadeFocusWindow);
WRAP(fs, s, windowResizeNotify, fadeWindowResizeNotify);
s->base.privates[fd->screenPrivateIndex].ptr = fs;
return TRUE;
}
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;
}
