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 minFiniWindow(CompPlugin * p, CompWindow * w)
{
MIN_WINDOW(w);
mw->ignoreDamage = TRUE;
while (mw->unmapCnt--)
unmapWindow(w);
mw->ignoreDamage = FALSE;
if (mw->region)
XDestroyRegion(mw->region);
free(mw);
}
static void
fadeWindowStop(CompWindow *w)
{
FADE_WINDOW(w);
while (fw->unmapCnt)
{
unmapWindow(w);
fw->unmapCnt--;
}
while (fw->destroyCnt)
{
destroyWindow(w);
fw->destroyCnt--;
}
}
static void
minHandleEvent (XEvent *event)
{
CompWindow *w;
MIN_DISPLAY (&display);
switch (event->type) {
case MapNotify:
w = findWindowAtDisplay (event->xmap.window);
if (w)
{
MIN_WINDOW (w);
if (mw->adjust)
mw->state = mw->newState;
if (mw->region)
w->height = 0;
mw->ignoreDamage = TRUE;
while (mw->unmapCnt)
{
unmapWindow (w);
mw->unmapCnt--;
}
mw->ignoreDamage = FALSE;
}
break;
case UnmapNotify:
w = findWindowAtDisplay (event->xunmap.window);
if (w)
{
MIN_SCREEN (w->screen);
if (w->pendingUnmaps && onCurrentDesktop (w)) /* Normal -> Iconic */
{
MIN_WINDOW (w);
if (w->shaded)
{
if (!mw->region)
mw->region = XCreateRegion ();
if (mw->region && ms->shadeStep)
{
XSubtractRegion (w->region, &emptyRegion, mw->region);
XOffsetRegion (mw->region, -w->attrib.x,
w->attrib.height +
w->attrib.border_width * 2 -
w->height - w->attrib.y);
mw->shade = w->height;
mw->adjust = FALSE;
ms->moreAdjust = TRUE;
mw->unmapCnt++;
w->unmapRefCnt++;
addWindowDamage (w);
}
}
else if (!w->invisible && matchEval (&ms->match, w))
{
if (w->iconGeometrySet)
{
mw->newState = IconicState;
mw->xScale = w->paint.xScale;
mw->yScale = w->paint.yScale;
mw->tx = w->attrib.x - w->serverX;
mw->ty = w->attrib.y - w->serverY;
if (mw->region)
{
XDestroyRegion (mw->region);
mw->region = NULL;
}
mw->shade = MAXSHORT;
mw->adjust = TRUE;
ms->moreAdjust = TRUE;
mw->unmapCnt++;
w->unmapRefCnt++;
addWindowDamage (w);
}
}
}
else /* X -> Withdrawn */
{
MIN_WINDOW (w);
if (mw->adjust)
{
mw->adjust = FALSE;
mw->xScale = mw->yScale = 1.0f;
mw->tx = mw->ty = 0.0f;
mw->xVelocity = mw->yVelocity = 0.0f;
mw->xScaleVelocity = mw->yScaleVelocity = 1.0f;
mw->shade = MAXSHORT;
if (mw->region)
{
XDestroyRegion (mw->region);
mw->region = NULL;
}
}
mw->state = NormalState;
}
}
default:
break;
}
UNWRAP (md, &display, handleEvent);
(*display.handleEvent) (event);
WRAP (md, &display, handleEvent, minHandleEvent);
switch (event->type) {
case MapRequest:
w = findWindowAtDisplay (event->xmaprequest.window);
if (w && w->hints && w->hints->initial_state == IconicState)
{
MIN_WINDOW (w);
mw->newState = mw->state = IconicState;
}
break;
default:
break;
}
}
static void
minPreparePaintScreen (CompScreen *s,
int msSinceLastPaint)
{
MIN_SCREEN (s);
if (ms->moreAdjust)
{
CompWindow *w;
int steps, h;
float amount, chunk;
const BananaValue *
option_speed = bananaGetOption (bananaIndex, "speed", s->screenNum);
amount = msSinceLastPaint * 0.05f * option_speed->f;
const BananaValue *
option_timestep = bananaGetOption (bananaIndex,
"timestep",
s->screenNum);
steps = amount / (0.5f * option_timestep->f);
if (!steps) steps = 1;
chunk = amount / (float) steps;
while (steps--)
{
ms->moreAdjust = 0;
for (w = s->windows; w; w = w->next)
{
MIN_WINDOW (w);
if (mw->adjust)
{
mw->adjust = adjustMinVelocity (w);
ms->moreAdjust |= mw->adjust;
mw->tx += mw->xVelocity * chunk;
mw->ty += mw->yVelocity * chunk;
mw->xScale += mw->xScaleVelocity * chunk;
mw->yScale += mw->yScaleVelocity * chunk;
if (!mw->adjust)
{
mw->state = mw->newState;
mw->ignoreDamage = TRUE;
while (mw->unmapCnt)
{
unmapWindow (w);
mw->unmapCnt--;
}
mw->ignoreDamage = FALSE;
}
}
else if (mw->region && w->damaged)
{
if (w->shaded)
{
if (mw->shade > 0)
{
mw->shade -= (chunk * ms->shadeStep) + 1;
if (mw->shade > 0)
{
ms->moreAdjust = TRUE;
}
else
{
mw->shade = 0;
mw->ignoreDamage = TRUE;
while (mw->unmapCnt)
{
unmapWindow (w);
mw->unmapCnt--;
}
mw->ignoreDamage = FALSE;
}
}
}
else
{
h = w->attrib.height + w->attrib.border_width * 2;
if (mw->shade < h)
{
mw->shade += (chunk * ms->shadeStep) + 1;
if (mw->shade < h)
{
ms->moreAdjust = TRUE;
}
else
{
mw->shade = MAXSHORT;
minSetShade (w, h);
XDestroyRegion (mw->region);
mw->region = NULL;
addWindowDamage (w);
}
}
}
}
}
if (!ms->moreAdjust)
break;
}
if (ms->moreAdjust)
{
for (w = s->windows; w; w = w->next)
{
MIN_WINDOW (w);
if (mw->adjust)
{
addWindowDamage (w);
}
else if (mw->region && w->damaged)
{
h = w->attrib.height + w->attrib.border_width * 2;
if (mw->shade && mw->shade < h)
{
minSetShade (w, mw->shade);
addWindowDamage (w);
}
}
}
}
}
UNWRAP (ms, s, preparePaintScreen);
(*s->preparePaintScreen) (s, msSinceLastPaint);
WRAP (ms, s, preparePaintScreen, minPreparePaintScreen);
}
void XImlib2Caption::mouseOffEffect()
{
if (captionOnHover)
unmapWindow();
}
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;
}
