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
fadeSetScreenOption (CompScreen *screen,
char *name,
CompOptionValue *value)
{
CompOption *o;
int index;
FADE_SCREEN (screen);
o = compFindOption (fs->opt, NUM_OPTIONS (fs), name, &index);
if (!o)
return FALSE;
switch (index) {
case FADE_SCREEN_OPTION_FADE_SPEED:
if (compSetFloatOption (o, value))
{
fs->fadeTime = 1000.0f / o->value.f;
return TRUE;
}
default:
break;
}
return FALSE;
}
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 CompOption *
fadeGetScreenOptions (CompScreen *screen,
int *count)
{
FADE_SCREEN (screen);
*count = NUM_OPTIONS (fs);
return fs->opt;
}
/* 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
fadeFiniScreen (CompPlugin *p,
CompScreen *s)
{
FADE_SCREEN (s);
freeWindowPrivateIndex (s, fs->windowPrivateIndex);
UNWRAP (fs, s, preparePaintScreen);
UNWRAP (fs, s, paintWindow);
UNWRAP (fs, s, damageWindowRect);
free (fs);
}
static void
fadePreparePaintScreen(CompScreen *s,
int msSinceLastPaint)
{
CompWindow *w;
int steps;
FADE_SCREEN(s);
switch (fs->opt[FADE_SCREEN_OPTION_FADE_MODE].value.i)
{
case FADE_MODE_CONSTANTSPEED:
steps = (msSinceLastPaint * OPAQUE) / fs->fadeTime;
if (steps < 12)
steps = 12;
for (w = s->windows; w; w = w->next)
{
FadeWindow *fw = GET_FADE_WINDOW(w, fs);
fw->steps = steps;
fw->fadeTime = 0;
}
break;
case FADE_MODE_CONSTANTTIME:
for (w = s->windows; w; w = w->next)
{
FadeWindow *fw = GET_FADE_WINDOW(w, fs);
if (fw->fadeTime)
{
fw->steps = 1;
fw->fadeTime -= msSinceLastPaint;
if (fw->fadeTime < 0)
fw->fadeTime = 0;
}
else
{
fw->steps = 0;
}
}
break;
}
UNWRAP(fs, s, preparePaintScreen);
(*s->preparePaintScreen)(s, msSinceLastPaint);
WRAP(fs, s, preparePaintScreen, fadePreparePaintScreen);
}
static void
fadePreparePaintScreen (CompScreen *s,
int msSinceLastPaint)
{
FADE_SCREEN (s);
fs->steps = (msSinceLastPaint * OPAQUE) / fs->fadeTime;
if (fs->steps < 256)
fs->steps = 256;
UNWRAP (fs, s, preparePaintScreen);
(*s->preparePaintScreen) (s, msSinceLastPaint);
WRAP (fs, s, preparePaintScreen, fadePreparePaintScreen);
}
static void
fadeWindowResizeNotify(CompWindow *w,
int dx,
int dy,
int dwidth,
int dheight)
{
FADE_SCREEN(w->screen);
if (!w->mapNum)
fadeWindowStop(w);
UNWRAP(fs, w->screen, windowResizeNotify);
(*w->screen->windowResizeNotify)(w, dx, dy, dwidth, dheight);
WRAP(fs, w->screen, windowResizeNotify, fadeWindowResizeNotify);
}
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 Bool
fadeInitWindow(CompPlugin *p,
CompWindow *w)
{
FadeWindow *fw;
FADE_SCREEN(w->screen);
fw = malloc(sizeof (FadeWindow));
if (!fw)
return FALSE;
fw->opacity = w->paint.opacity;
fw->brightness = w->paint.brightness;
fw->saturation = w->paint.saturation;
fw->targetOpacity = fw->opacity;
fw->targetBrightness = fw->brightness;
fw->targetSaturation = fw->saturation;
fw->opacityDiff = 0;
fw->brightnessDiff = 0;
fw->saturationDiff = 0;
fw->dModal = 0;
fw->destroyCnt = 0;
fw->unmapCnt = 0;
fw->shaded = w->shaded;
fw->fadeOut = FALSE;
fw->alive = w->alive;
fw->steps = 0;
fw->fadeTime = 0;
w->base.privates[fs->windowPrivateIndex].ptr = fw;
if (w->attrib.map_state == IsViewable)
{
if (w->state & CompWindowStateDisplayModalMask)
fadeAddDisplayModal(w->screen->display, w);
}
return TRUE;
}
static void
fadeFiniScreen(CompPlugin *p,
CompScreen *s)
{
FADE_SCREEN(s);
matchFini(&fs->match);
freeWindowPrivateIndex(s, fs->windowPrivateIndex);
UNWRAP(fs, s, preparePaintScreen);
UNWRAP(fs, s, paintWindow);
UNWRAP(fs, s, damageWindowRect);
UNWRAP(fs, s, focusWindow);
UNWRAP(fs, s, windowResizeNotify);
compFiniScreenOptions(s, fs->opt, FADE_SCREEN_OPTION_NUM);
free(fs);
}
static Bool
fadeInitWindow (CompPlugin *p,
CompWindow *w)
{
FadeWindow *fw;
FADE_SCREEN (w->screen);
fw = malloc (sizeof (FadeWindow));
if (!fw)
return FALSE;
fw->opacity = OPAQUE;
fw->direction = 0;
fw->destroyed = 0;
w->privates[fs->windowPrivateIndex].ptr = fw;
return TRUE;
}
static Bool
fadeSetScreenOption(CompPlugin *plugin,
CompScreen *screen,
const char *name,
CompOptionValue *value)
{
CompOption *o;
int index;
FADE_SCREEN(screen);
o = compFindOption(fs->opt, NUM_OPTIONS(fs), name, &index);
if (!o)
return FALSE;
switch (index)
{
case FADE_SCREEN_OPTION_FADE_SPEED:
if (compSetFloatOption(o, value))
{
fs->fadeTime = 1000.0f / o->value.f;
return TRUE;
}
break;
case FADE_SCREEN_OPTION_WINDOW_MATCH:
if (compSetMatchOption(o, value))
{
fadeUpdateWindowFadeMatch(screen->display, &o->value, &fs->match);
return TRUE;
}
break;
default:
if (compSetOption(o, value))
return TRUE;
break;
}
return FALSE;
}
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;
}
