static Bool
minPaintWindow (CompWindow *w,
const WindowPaintAttrib *attrib,
const CompTransform *transform,
Region region,
unsigned int mask)
{
CompScreen *s = w->screen;
Bool status;
MIN_SCREEN (s);
MIN_WINDOW (w);
if (mw->adjust)
{
FragmentAttrib fragment;
CompTransform wTransform = *transform;
if (mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK)
return FALSE;
UNWRAP (ms, s, paintWindow);
status = (*s->paintWindow) (w, attrib, transform, region,
mask | PAINT_WINDOW_NO_CORE_INSTANCE_MASK);
WRAP (ms, s, paintWindow, minPaintWindow);
initFragmentAttrib (&fragment, &w->lastPaint);
if (w->alpha || fragment.opacity != OPAQUE)
mask |= PAINT_WINDOW_TRANSLUCENT_MASK;
matrixTranslate (&wTransform, w->attrib.x, w->attrib.y, 0.0f);
matrixScale (&wTransform, mw->xScale, mw->yScale, 1.0f);
matrixTranslate (&wTransform,
mw->tx / mw->xScale - w->attrib.x,
mw->ty / mw->yScale - w->attrib.y,
0.0f);
glPushMatrix ();
glLoadMatrixf (wTransform.m);
(*s->drawWindow) (w, &wTransform, &fragment, region,
mask | PAINT_WINDOW_TRANSFORMED_MASK);
glPopMatrix ();
}
else
{
/* no core instance from windows that have been animated */
if (mw->state == IconicState)
mask |= PAINT_WINDOW_NO_CORE_INSTANCE_MASK;
UNWRAP (ms, s, paintWindow);
status = (*s->paintWindow) (w, attrib, transform, region, mask);
WRAP (ms, s, paintWindow, minPaintWindow);
}
return status;
}
static Bool
staticInitWindow (CompPlugin *p,
CompWindow *w)
{
StaticWindow *sw;
STATIC_SCREEN (w->screen);
sw = malloc (sizeof (StaticWindow));
if (!sw)
return FALSE;
initFragmentAttrib (&sw->fragment, &w->paint);
w->base.privates[ss->windowPrivateIndex].ptr = sw;
return TRUE;
}
/*
* groupPaintThumb - taken from switcher and modified for tab bar
*
*/
static void
groupPaintThumb (GroupSelection *group,
GroupTabBarSlot *slot,
const CompTransform *transform,
int targetOpacity)
{
CompWindow *w = slot->window;
CompScreen *s = w->screen;
AddWindowGeometryProc oldAddWindowGeometry;
WindowPaintAttrib wAttrib = w->paint;
int tw, th;
tw = slot->region->extents.x2 - slot->region->extents.x1;
th = slot->region->extents.y2 - slot->region->extents.y1;
/* Wrap drawWindowGeometry to make sure the general
drawWindowGeometry function is used */
oldAddWindowGeometry = s->addWindowGeometry;
s->addWindowGeometry = addWindowGeometry;
const BananaValue *
option_fade_time = bananaGetOption (bananaIndex,
"fade_time",
s->screenNum);
/* animate fade */
if (group && group->tabBar->state == PaintFadeIn)
{
wAttrib.opacity -= wAttrib.opacity * group->tabBar->animationTime /
(option_fade_time->f * 1000);
}
else if (group && group->tabBar->state == PaintFadeOut)
{
wAttrib.opacity = wAttrib.opacity * group->tabBar->animationTime /
(option_fade_time->f * 1000);
}
wAttrib.opacity = wAttrib.opacity * targetOpacity / OPAQUE;
if (w->mapNum)
{
FragmentAttrib fragment;
CompTransform wTransform = *transform;
int width, height;
int vx, vy;
width = w->width + w->output.left + w->output.right;
height = w->height + w->output.top + w->output.bottom;
if (width > tw)
wAttrib.xScale = (float) tw / width;
else
wAttrib.xScale = 1.0f;
if (height > th)
wAttrib.yScale = (float) tw / height;
else
wAttrib.yScale = 1.0f;
if (wAttrib.xScale < wAttrib.yScale)
wAttrib.yScale = wAttrib.xScale;
else
wAttrib.xScale = wAttrib.yScale;
/* FIXME: do some more work on the highlight on hover feature
// Highlight on hover
if (group && group->tabBar && group->tabBar->hoveredSlot == slot) {
wAttrib.saturation = 0;
wAttrib.brightness /= 1.25f;
}*/
groupGetDrawOffsetForSlot (slot, &vx, &vy);
wAttrib.xTranslate = (slot->region->extents.x1 +
slot->region->extents.x2) / 2 + vx;
wAttrib.yTranslate = slot->region->extents.y1 + vy;
initFragmentAttrib (&fragment, &wAttrib);
matrixTranslate (&wTransform,
wAttrib.xTranslate, wAttrib.yTranslate, 0.0f);
matrixScale (&wTransform, wAttrib.xScale, wAttrib.yScale, 1.0f);
matrixTranslate (&wTransform, -(WIN_X (w) + WIN_WIDTH (w) / 2),
-(WIN_Y (w) - w->output.top), 0.0f);
glPushMatrix ();
glLoadMatrixf (wTransform.m);
(*s->drawWindow)(w, &wTransform, &fragment, &infiniteRegion,
PAINT_WINDOW_TRANSFORMED_MASK |
PAINT_WINDOW_TRANSLUCENT_MASK);
glPopMatrix ();
}
s->addWindowGeometry = oldAddWindowGeometry;
}
/*
* groupPaintTabBar
*
*/
static void
groupPaintTabBar (GroupSelection *group,
const WindowPaintAttrib *wAttrib,
const CompTransform *transform,
unsigned int mask,
Region clipRegion)
{
CompWindow *topTab;
CompScreen *s = group->screen;
GroupTabBar *bar = group->tabBar;
int count;
REGION box;
GROUP_SCREEN (s);
if (HAS_TOP_WIN (group))
topTab = TOP_TAB (group);
else
topTab = PREV_TOP_TAB (group);
#define PAINT_BG 0
#define PAINT_SEL 1
#define PAINT_THUMBS 2
#define PAINT_TEXT 3
#define PAINT_MAX 4
box.rects = &box.extents;
box.numRects = 1;
const BananaValue *
option_fade_time = bananaGetOption (bananaIndex,
"fade_time",
s->screenNum);
const BananaValue *
option_mipmaps = bananaGetOption (bananaIndex,
"mipmaps",
s->screenNum);
const BananaValue *
option_fade_text_time = bananaGetOption (bananaIndex,
"fade_text_time",
s->screenNum);
for (count = 0; count < PAINT_MAX; count++)
{
int alpha = OPAQUE;
float wScale = 1.0f, hScale = 1.0f;
GroupCairoLayer *layer = NULL;
if (bar->state == PaintFadeIn)
alpha -= alpha * bar->animationTime / (option_fade_time->f * 1000);
else if (bar->state == PaintFadeOut)
alpha = alpha * bar->animationTime / (option_fade_time->f * 1000);
switch (count) {
case PAINT_BG:
{
int newWidth;
layer = bar->bgLayer;
/* handle the repaint of the background */
newWidth = bar->region->extents.x2 - bar->region->extents.x1;
if (layer && (newWidth > layer->texWidth))
newWidth = layer->texWidth;
wScale = (double) (bar->region->extents.x2 -
bar->region->extents.x1) / (double) newWidth;
/* FIXME: maybe move this over to groupResizeTabBarRegion -
the only problem is that we would have 2 redraws if
there is an animation */
if (newWidth != bar->oldWidth || bar->bgAnimation)
groupRenderTabBarBackground (group);
bar->oldWidth = newWidth;
box.extents = bar->region->extents;
}
break;
case PAINT_SEL:
if (group->topTab != gs->draggedSlot)
{
layer = bar->selectionLayer;
box.extents = group->topTab->region->extents;
}
break;
case PAINT_THUMBS:
{
GLenum oldTextureFilter;
GroupTabBarSlot *slot;
oldTextureFilter = display.textureFilter;
if (option_mipmaps->b)
display.textureFilter = GL_LINEAR_MIPMAP_LINEAR;
for (slot = bar->slots; slot; slot = slot->next)
{
if (slot != gs->draggedSlot || !gs->dragged)
groupPaintThumb (group, slot, transform,
wAttrib->opacity);
}
display.textureFilter = oldTextureFilter;
}
break;
case PAINT_TEXT:
if (bar->textLayer && (bar->textLayer->state != PaintOff))
{
layer = bar->textLayer;
box.extents.x1 = bar->region->extents.x1 + 5;
box.extents.x2 = bar->region->extents.x1 +
bar->textLayer->texWidth + 5;
box.extents.y1 = bar->region->extents.y2 -
bar->textLayer->texHeight - 5;
box.extents.y2 = bar->region->extents.y2 - 5;
if (box.extents.x2 > bar->region->extents.x2)
box.extents.x2 = bar->region->extents.x2;
/* recalculate the alpha again for text fade... */
if (layer->state == PaintFadeIn)
alpha -= alpha * layer->animationTime /
(option_fade_text_time->f * 1000);
else if (layer->state == PaintFadeOut)
alpha = alpha * layer->animationTime /
(option_fade_text_time->f * 1000);
}
break;
}
if (layer)
{
CompMatrix matrix = layer->texture.matrix;
/* remove the old x1 and y1 so we have a relative value */
box.extents.x2 -= box.extents.x1;
box.extents.y2 -= box.extents.y1;
box.extents.x1 = (box.extents.x1 - topTab->attrib.x) / wScale +
topTab->attrib.x;
box.extents.y1 = (box.extents.y1 - topTab->attrib.y) / hScale +
topTab->attrib.y;
/* now add the new x1 and y1 so we have a absolute value again,
also we don't want to stretch the texture... */
if (box.extents.x2 * wScale < layer->texWidth)
box.extents.x2 += box.extents.x1;
else
box.extents.x2 = box.extents.x1 + layer->texWidth;
if (box.extents.y2 * hScale < layer->texHeight)
box.extents.y2 += box.extents.y1;
else
box.extents.y2 = box.extents.y1 + layer->texHeight;
matrix.x0 -= box.extents.x1 * matrix.xx;
matrix.y0 -= box.extents.y1 * matrix.yy;
topTab->vCount = topTab->indexCount = 0;
addWindowGeometry (topTab, &matrix, 1, &box, clipRegion);
if (topTab->vCount)
{
FragmentAttrib fragment;
CompTransform wTransform = *transform;
matrixTranslate (&wTransform,
WIN_X (topTab), WIN_Y (topTab), 0.0f);
matrixScale (&wTransform, wScale, hScale, 1.0f);
matrixTranslate (&wTransform,
wAttrib->xTranslate / wScale - WIN_X (topTab),
wAttrib->yTranslate / hScale - WIN_Y (topTab),
0.0f);
glPushMatrix ();
glLoadMatrixf (wTransform.m);
alpha = alpha * ((float)wAttrib->opacity / OPAQUE);
initFragmentAttrib (&fragment, wAttrib);
fragment.opacity = alpha;
(*s->drawWindowTexture)(topTab, &layer->texture,
&fragment, mask |
PAINT_WINDOW_BLEND_MASK |
PAINT_WINDOW_TRANSFORMED_MASK |
PAINT_WINDOW_TRANSLUCENT_MASK);
glPopMatrix ();
}
}
}
}
static void
scalePaintDecoration (CompWindow *w,
const WindowPaintAttrib *attrib,
const CompTransform *transform,
Region region,
unsigned int mask)
{
CompScreen *s = w->screen;
SCALE_SCREEN (s);
if (ss->opt[SCALE_SCREEN_OPTION_ICON].value.i != SCALE_ICON_NONE)
{
WindowPaintAttrib sAttrib = *attrib;
CompIcon *icon;
SCALE_WINDOW (w);
icon = getWindowIcon (w, 96, 96);
if (!icon)
icon = w->screen->defaultIcon;
if (icon && (icon->texture.name || iconToTexture (w->screen, icon)))
{
REGION iconReg;
float scale;
float x, y;
int width, height;
int scaledWinWidth, scaledWinHeight;
float ds;
scaledWinWidth = w->width * sw->scale;
scaledWinHeight = w->height * sw->scale;
switch (ss->opt[SCALE_SCREEN_OPTION_ICON].value.i) {
case SCALE_ICON_NONE:
case SCALE_ICON_EMBLEM:
scale = 1.0f;
break;
case SCALE_ICON_BIG:
default:
sAttrib.opacity /= 3;
scale = MIN (((float) scaledWinWidth / icon->width),
((float) scaledWinHeight / icon->height));
break;
}
width = icon->width * scale;
height = icon->height * scale;
switch (ss->opt[SCALE_SCREEN_OPTION_ICON].value.i) {
case SCALE_ICON_NONE:
case SCALE_ICON_EMBLEM:
x = w->attrib.x + scaledWinWidth - icon->width;
y = w->attrib.y + scaledWinHeight - icon->height;
break;
case SCALE_ICON_BIG:
default:
x = w->attrib.x + scaledWinWidth / 2 - width / 2;
y = w->attrib.y + scaledWinHeight / 2 - height / 2;
break;
}
x += sw->tx;
y += sw->ty;
if (sw->slot)
{
sw->delta =
fabs (sw->slot->x1 - w->attrib.x) +
fabs (sw->slot->y1 - w->attrib.y) +
fabs (1.0f - sw->slot->scale) * 500.0f;
}
if (sw->delta)
{
float o;
ds =
fabs (sw->tx) +
fabs (sw->ty) +
fabs (1.0f - sw->scale) * 500.0f;
if (ds > sw->delta)
ds = sw->delta;
o = ds / sw->delta;
if (sw->slot)
{
if (o < sw->lastThumbOpacity)
o = sw->lastThumbOpacity;
}
else
{
if (o > sw->lastThumbOpacity)
o = 0.0f;
}
sw->lastThumbOpacity = o;
sAttrib.opacity = sAttrib.opacity * o;
}
mask |= PAINT_WINDOW_BLEND_MASK;
iconReg.rects = &iconReg.extents;
iconReg.numRects = 1;
iconReg.extents.x1 = 0;
iconReg.extents.y1 = 0;
iconReg.extents.x2 = iconReg.extents.x1 + width;
iconReg.extents.y2 = iconReg.extents.y1 + height;
w->vCount = w->indexCount = 0;
if (iconReg.extents.x1 < iconReg.extents.x2 &&
iconReg.extents.y1 < iconReg.extents.y2)
(*w->screen->addWindowGeometry) (w,
&icon->texture.matrix, 1,
&iconReg, &iconReg);
if (w->vCount)
{
FragmentAttrib fragment;
CompTransform wTransform = *transform;
initFragmentAttrib (&fragment, &sAttrib);
matrixScale (&wTransform, scale, scale, 1.0f);
matrixTranslate (&wTransform, x / scale, y / scale, 0.0f);
glPushMatrix ();
glLoadMatrixf (wTransform.m);
(*w->screen->drawWindowTexture) (w,
&icon->texture, &fragment,
mask);
glPopMatrix ();
}
}
}
}
static void
thumbPaintThumb (CompScreen *s,
Thumbnail *t,
const CompTransform *transform)
{
AddWindowGeometryProc oldAddWindowGeometry;
CompWindow *w = t->win;
int wx = t->x;
int wy = t->y;
float width = t->width;
float height = t->height;
WindowPaintAttrib sAttrib;
unsigned int mask = PAINT_WINDOW_TRANSFORMED_MASK |
PAINT_WINDOW_TRANSLUCENT_MASK;
THUMB_SCREEN (s);
if (!w)
return;
sAttrib = w->paint;
if (t->textData)
height += t->textData->height + TEXT_DISTANCE;
/* Wrap drawWindowGeometry to make sure the general
drawWindowGeometry function is used */
oldAddWindowGeometry = s->addWindowGeometry;
s->addWindowGeometry = addWindowGeometry;
if (w->texture->pixmap)
{
int off = t->offset;
GLenum filter = display.textureFilter;
FragmentAttrib fragment;
CompTransform wTransform = *transform;
glEnable (GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glDisableClientState (GL_TEXTURE_COORD_ARRAY);
const BananaValue *
option_window_like = bananaGetOption (bananaIndex,
"window_like",
s->screenNum);
if (option_window_like->b)
{
glColor4f (1.0, 1.0, 1.0, t->opacity);
enableTexture (s, &ts->windowTexture, COMP_TEXTURE_FILTER_GOOD);
}
else
{
unsigned short color[] = { 0, 0, 0, 0 };
const BananaValue *
option_thumb_color = bananaGetOption (bananaIndex,
"thumb_color",
s->screenNum);
stringToColor (option_thumb_color->s, color);
glColor4us (color[0],
color[1],
color[2],
color[3] * t->opacity);
enableTexture (s, &ts->glowTexture, COMP_TEXTURE_FILTER_GOOD);
}
glBegin (GL_QUADS);
glTexCoord2f (1, 0);
glVertex2f (wx, wy);
glVertex2f (wx, wy + height);
glVertex2f (wx + width, wy + height);
glVertex2f (wx + width, wy);
glTexCoord2f (0, 1);
glVertex2f (wx - off, wy - off);
glTexCoord2f (0, 0);
glVertex2f (wx - off, wy);
glTexCoord2f (1, 0);
glVertex2f (wx, wy);
glTexCoord2f (1, 1);
glVertex2f (wx, wy - off);
glTexCoord2f (1, 1);
glVertex2f (wx + width, wy - off);
glTexCoord2f (1, 0);
glVertex2f (wx + width, wy);
glTexCoord2f (0, 0);
glVertex2f (wx + width + off, wy);
glTexCoord2f (0, 1);
glVertex2f (wx + width + off, wy - off);
glTexCoord2f (0, 0);
glVertex2f (wx - off, wy + height);
glTexCoord2f (0, 1);
glVertex2f (wx - off, wy + height + off);
glTexCoord2f (1, 1);
glVertex2f (wx, wy + height + off);
glTexCoord2f (1, 0);
glVertex2f (wx, wy + height);
glTexCoord2f (1, 0);
glVertex2f (wx + width, wy + height);
glTexCoord2f (1, 1);
glVertex2f (wx + width, wy + height + off);
glTexCoord2f (0, 1);
glVertex2f (wx + width + off, wy + height + off);
glTexCoord2f (0, 0);
glVertex2f (wx + width + off, wy + height);
glTexCoord2f (1, 1);
glVertex2f (wx, wy - off);
glTexCoord2f (1, 0);
glVertex2f (wx, wy);
glTexCoord2f (1, 0);
glVertex2f (wx + width, wy);
glTexCoord2f (1, 1);
glVertex2f (wx + width, wy - off);
glTexCoord2f (1, 0);
glVertex2f (wx, wy + height);
glTexCoord2f (1, 1);
glVertex2f (wx, wy + height + off);
glTexCoord2f (1, 1);
glVertex2f (wx + width, wy + height + off);
glTexCoord2f (1, 0);
glVertex2f (wx + width, wy + height);
glTexCoord2f (0, 0);
glVertex2f (wx - off, wy);
glTexCoord2f (0, 0);
glVertex2f (wx - off, wy + height);
glTexCoord2f (1, 0);
glVertex2f (wx, wy + height);
glTexCoord2f (1, 0);
glVertex2f (wx, wy);
glTexCoord2f (1, 0);
glVertex2f (wx + width, wy);
glTexCoord2f (1, 0);
glVertex2f (wx + width, wy + height);
glTexCoord2f (0, 0);
glVertex2f (wx + width + off, wy + height);
glTexCoord2f (0, 0);
glVertex2f (wx + width + off, wy);
glEnd ();
if (option_window_like->b)
{
disableTexture (s, &ts->windowTexture);
}
else
{
disableTexture (s, &ts->glowTexture);
}
glColor4usv (defaultColor);
glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
if (t->textData)
{
float ox = 0.0;
if (t->textData->width < width)
ox = (width - (int)t->textData->width) / 2.0;
textDrawText (s, t->textData, wx + ox, wy + height, t->opacity);
}
glEnableClientState (GL_TEXTURE_COORD_ARRAY);
glDisable (GL_BLEND);
screenTexEnvMode (s, GL_REPLACE);
glColor4usv (defaultColor);
sAttrib.opacity *= t->opacity;
sAttrib.yScale = t->scale;
sAttrib.xScale = t->scale;
sAttrib.xTranslate = wx - w->attrib.x + w->input.left * sAttrib.xScale;
sAttrib.yTranslate = wy - w->attrib.y + w->input.top * sAttrib.yScale;
const BananaValue *
option_mipmap = bananaGetOption (bananaIndex,
"mipmap",
s->screenNum);
if (option_mipmap->b)
display.textureFilter = GL_LINEAR_MIPMAP_LINEAR;
initFragmentAttrib (&fragment, &sAttrib);
matrixTranslate (&wTransform, w->attrib.x, w->attrib.y, 0.0f);
matrixScale (&wTransform, sAttrib.xScale, sAttrib.yScale, 1.0f);
matrixTranslate (&wTransform,
sAttrib.xTranslate / sAttrib.xScale - w->attrib.x,
sAttrib.yTranslate / sAttrib.yScale - w->attrib.y,
0.0f);
glPushMatrix ();
glLoadMatrixf (wTransform.m);
(*s->drawWindow) (w, &wTransform, &fragment, &infiniteRegion, mask);
glPopMatrix ();
display.textureFilter = filter;
}
s->addWindowGeometry = oldAddWindowGeometry;
}
static Bool
ringPaintWindow (CompWindow *w,
const WindowPaintAttrib *attrib,
const CompTransform *transform,
Region region,
unsigned int mask)
{
CompScreen *s = w->screen;
Bool status;
RING_SCREEN (s);
if (rs->state != RingStateNone)
{
WindowPaintAttrib sAttrib = *attrib;
Bool scaled = FALSE;
RING_WINDOW (w);
if (w->mapNum)
{
if (!w->texture->pixmap && !w->bindFailed)
bindWindow (w);
}
if (rw->adjust || rw->slot)
{
scaled = rw->adjust || (rw->slot && rs->paintingSwitcher);
mask |= PAINT_WINDOW_NO_CORE_INSTANCE_MASK;
}
else if (rs->state != RingStateIn)
{
if (ringGetDarkenBack (s))
{
/* modify brightness of the other windows */
sAttrib.brightness = sAttrib.brightness / 2;
}
}
UNWRAP (rs, s, paintWindow);
status = (*s->paintWindow) (w, &sAttrib, transform, region, mask);
WRAP (rs, s, paintWindow, ringPaintWindow);
if (scaled && w->texture->pixmap)
{
FragmentAttrib fragment;
CompTransform wTransform = *transform;
if (mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK)
return FALSE;
initFragmentAttrib (&fragment, &w->lastPaint);
if (rw->slot)
{
fragment.brightness = (float) fragment.brightness *
rw->slot->depthBrightness;
if (w != rs->selectedWindow)
fragment.opacity = (float)fragment.opacity *
ringGetInactiveOpacity (s) / 100;
}
if (w->alpha || fragment.opacity != OPAQUE)
mask |= PAINT_WINDOW_TRANSLUCENT_MASK;
matrixTranslate (&wTransform, w->attrib.x, w->attrib.y, 0.0f);
matrixScale (&wTransform, rw->scale, rw->scale, 1.0f);
matrixTranslate (&wTransform,
rw->tx / rw->scale - w->attrib.x,
rw->ty / rw->scale - w->attrib.y,
0.0f);
glPushMatrix ();
glLoadMatrixf (wTransform.m);
(*s->drawWindow) (w, &wTransform, &fragment, region,
mask | PAINT_WINDOW_TRANSFORMED_MASK);
glPopMatrix ();
}
if (scaled && (rs->state != RingStateIn) &&
((ringGetOverlayIcon (s) != OverlayIconNone) ||
!w->texture->pixmap))
{
CompIcon *icon;
icon = getWindowIcon (w, MAX_ICON_SIZE, MAX_ICON_SIZE);
if (!icon)
icon = w->screen->defaultIcon;
if (icon && (icon->texture.name || iconToTexture (w->screen, icon)))
{
REGION iconReg;
CompMatrix matrix;
float scale;
float x, y;
int width, height;
int scaledWinWidth, scaledWinHeight;
RingOverlayIconEnum iconOverlay;
scaledWinWidth = w->attrib.width * rw->scale;
scaledWinHeight = w->attrib.height * rw->scale;
if (!w->texture->pixmap)
iconOverlay = OverlayIconBig;
else
iconOverlay = ringGetOverlayIcon (s);
switch (iconOverlay) {
case OverlayIconNone:
case OverlayIconEmblem:
scale = (rw->slot) ? rw->slot->depthScale : 1.0f;
scale = MIN ((scale * ICON_SIZE / icon->width),
(scale * ICON_SIZE / icon->height));
break;
case OverlayIconBig:
default:
if (w->texture->pixmap)
{
/* only change opacity if not painting an
icon for a minimized window */
sAttrib.opacity /= 3;
scale = MIN (((float) scaledWinWidth / icon->width),
((float) scaledWinHeight / icon->height));
}
else
{
scale =
0.8f * ((rw->slot) ? rw->slot->depthScale : 1.0f);
scale = MIN ((scale * ringGetThumbWidth (s) /
icon->width),
(scale * ringGetThumbHeight (s) /
icon->height));
}
break;
}
width = icon->width * scale;
height = icon->height * scale;
switch (iconOverlay) {
case OverlayIconNone:
case OverlayIconEmblem:
x = w->attrib.x + scaledWinWidth - width;
y = w->attrib.y + scaledWinHeight - height;
break;
case OverlayIconBig:
default:
x = w->attrib.x + scaledWinWidth / 2 - width / 2;
y = w->attrib.y + scaledWinHeight / 2 - height / 2;
break;
}
x += rw->tx;
y += rw->ty;
mask |=
PAINT_WINDOW_BLEND_MASK | PAINT_WINDOW_TRANSFORMED_MASK;
iconReg.rects = &iconReg.extents;
iconReg.numRects = 1;
iconReg.extents.x1 = w->attrib.x;
iconReg.extents.y1 = w->attrib.y;
iconReg.extents.x2 = w->attrib.x + icon->width;
iconReg.extents.y2 = w->attrib.y + icon->height;
matrix = icon->texture.matrix;
matrix.x0 -= (w->attrib.x * icon->texture.matrix.xx);
matrix.y0 -= (w->attrib.y * icon->texture.matrix.yy);
w->vCount = w->indexCount = 0;
(*w->screen->addWindowGeometry) (w, &matrix, 1,
&iconReg, &infiniteRegion);
if (w->vCount)
{
FragmentAttrib fragment;
CompTransform wTransform = *transform;
if (!w->texture->pixmap)
sAttrib.opacity = w->paint.opacity;
initFragmentAttrib (&fragment, &sAttrib);
if (rw->slot)
fragment.brightness = (float) fragment.brightness *
rw->slot->depthBrightness;
matrixTranslate (&wTransform,
w->attrib.x, w->attrib.y, 0.0f);
matrixScale (&wTransform, scale, scale, 1.0f);
matrixTranslate (&wTransform,
(x - w->attrib.x) / scale - w->attrib.x,
(y - w->attrib.y) / scale - w->attrib.y,
0.0f);
glPushMatrix ();
glLoadMatrixf (wTransform.m);
(*w->screen->drawWindowTexture) (w, &icon->texture,
&fragment, mask);
glPopMatrix ();
}
}
}
}
else
{
UNWRAP (rs, s, paintWindow);
status = (*s->paintWindow) (w, attrib, transform, region, mask);
WRAP (rs, s, paintWindow, ringPaintWindow);
}
return status;
}
