static void thumbPaintTransformedOutput (CompScreen *s, const ScreenPaintAttrib *sAttrib, const CompTransform *transform, Region region, CompOutput *output, unsigned int mask) { THUMB_SCREEN (s); UNWRAP (ts, s, paintTransformedOutput); (*s->paintTransformedOutput)(s, sAttrib, transform, region, output, mask); WRAP (ts, s, paintTransformedOutput, thumbPaintTransformedOutput); const BananaValue * option_always_on_top = bananaGetOption (bananaIndex, "always_on_top", s->screenNum); if (option_always_on_top->b && ts->x == s->x && ts->y == s->y) { ts->painted = TRUE; if (ts->oldThumb.opacity > 0.0 && ts->oldThumb.win) { CompTransform sTransform = *transform; (*s->applyScreenTransform)(s, sAttrib, output, &sTransform); transformToScreenSpace (s, output, -sAttrib->zTranslate, &sTransform); glPushMatrix (); glLoadMatrixf (sTransform.m); thumbPaintThumb (s, &ts->oldThumb, &sTransform); glPopMatrix (); } if (ts->thumb.opacity > 0.0 && ts->thumb.win) { CompTransform sTransform = *transform; (*s->applyScreenTransform)(s, sAttrib, output, &sTransform); transformToScreenSpace (s, output, -sAttrib->zTranslate, &sTransform); glPushMatrix (); glLoadMatrixf (sTransform.m); thumbPaintThumb (s, &ts->thumb, &sTransform); glPopMatrix (); } } }
static Bool wizardPaintOutput (CompScreen *s, const ScreenPaintAttrib *sa, const CompTransform *transform, Region region, CompOutput *output, unsigned int mask) { Bool status; CompTransform sTransform; WIZARD_SCREEN (s); UNWRAP (ws, s, paintOutput); status = (*s->paintOutput) (s, sa, transform, region, output, mask); WRAP (ws, s, paintOutput, wizardPaintOutput); if (!ws->ps || !ws->ps->active) return status; matrixGetIdentity (&sTransform); transformToScreenSpace (s, output, -DEFAULT_Z_CAMERA, &sTransform); glPushMatrix (); glLoadMatrixf (sTransform.m); drawParticles (s, ws->ps); glPopMatrix (); glColor4usv (defaultColor); return status; }
static Bool snowPaintOutput (CompScreen *s, const ScreenPaintAttrib *sa, const CompTransform *transform, Region region, CompOutput *output, unsigned int mask) { Bool status; SNOW_SCREEN (s); if (ss->active && !starGetSnowOverWindows (s->display)) mask |= PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS_MASK; UNWRAP (ss, s, paintOutput); status = (*s->paintOutput) (s, sa, transform, region, output, mask); WRAP (ss, s, paintOutput, snowPaintOutput); if (ss->active && starGetSnowOverWindows (s->display)) { CompTransform sTransform = *transform; transformToScreenSpace (s, output, -DEFAULT_Z_CAMERA, &sTransform); glPushMatrix (); glLoadMatrixf (sTransform.m); beginRendering (ss, s); glPopMatrix (); } return status; }
static Bool elementsPaintOutput (CompScreen *s, const ScreenPaintAttrib *sa, const CompTransform *transform, Region region, CompOutput *output, unsigned int mask) { CompDisplay *d = s->display; Bool status; Bool active = elementActive(s); E_SCREEN (s); UNWRAP (eScreen, s, paintOutput); status = (*s->paintOutput) (s, sa, transform, region, output, mask); WRAP (eScreen, s, paintOutput, elementsPaintOutput); if(elementsGetApplyTransform (d)) return status; if (active && elementsGetOverWindows (d)) { CompTransform sTransform = *transform; transformToScreenSpace (s, output, -DEFAULT_Z_CAMERA, &sTransform); glPushMatrix (); glLoadMatrixf (sTransform.m); beginRendering (s); glPopMatrix (); } return status; }
static Bool wsnamesPaintOutput (CompScreen *s, const ScreenPaintAttrib *sAttrib, const CompTransform *transform, Region region, CompOutput *output, unsigned int mask) { Bool status; WSNAMES_SCREEN (s); UNWRAP (ws, s, paintOutput); status = (*s->paintOutput) (s, sAttrib, transform, region, output, mask); WRAP (ws, s, paintOutput, wsnamesPaintOutput); if (ws->textData) { CompTransform sTransform = *transform; transformToScreenSpace (s, output, -DEFAULT_Z_CAMERA, &sTransform); glPushMatrix (); glLoadMatrixf (sTransform.m); wsnamesDrawText (s); glPopMatrix (); } return status; }
static Bool scalefilterPaintOutput (CompScreen *s, const ScreenPaintAttrib *sAttrib, const CompTransform *transform, Region region, CompOutput *output, unsigned int mask) { Bool status; FILTER_SCREEN (s); UNWRAP (fs, s, paintOutput); status = (*s->paintOutput) (s, sAttrib, transform, region, output, mask); WRAP (fs, s, paintOutput, scalefilterPaintOutput); if (status && fs->filterInfo) { if ((output->id == ~0 || output->id == fs->filterInfo->outputDevice) && fs->filterInfo->textPixmap) { CompTransform sTransform = *transform; transformToScreenSpace (s, output, -DEFAULT_Z_CAMERA, &sTransform); glPushMatrix (); glLoadMatrixf (sTransform.m); scalefilterDrawFilterText (s, output); glPopMatrix (); } } return status; }
void paintTransformedOutput (CompScreen *screen, const ScreenPaintAttrib *sAttrib, const CompTransform *transform, Region region, CompOutput *output, unsigned int mask) { CompTransform sTransform = *transform; if (mask & PAINT_SCREEN_CLEAR_MASK) clearTargetOutput (screen->display, GL_COLOR_BUFFER_BIT); screenLighting (screen, TRUE); (*screen->applyScreenTransform) (screen, sAttrib, output, &sTransform); if ((mask & CLIP_PLANE_MASK) == CLIP_PLANE_MASK) { screen->enableOutputClipping (screen, &sTransform, region, output); transformToScreenSpace (screen, output, -sAttrib->zTranslate, &sTransform); glPushMatrix (); glLoadMatrixf (sTransform.m); paintOutputRegion (screen, &sTransform, region, output, mask); glPopMatrix (); screen->disableOutputClipping (screen); } else { transformToScreenSpace (screen, output, -sAttrib->zTranslate, &sTransform); glPushMatrix (); glLoadMatrixf (sTransform.m); paintOutputRegion (screen, &sTransform, region, output, mask); glPopMatrix (); } }
Bool paintOutput (CompScreen *screen, const ScreenPaintAttrib *sAttrib, const CompTransform *transform, Region region, CompOutput *output, unsigned int mask) { CompTransform sTransform = *transform; if (mask & PAINT_SCREEN_REGION_MASK) { if (mask & PAINT_SCREEN_TRANSFORMED_MASK) { if (mask & PAINT_SCREEN_FULL_MASK) { region = &output->region; (*screen->paintTransformedOutput) (screen, sAttrib, &sTransform, region, output, mask); return TRUE; } return FALSE; } /* fall through and redraw region */ } else if (mask & PAINT_SCREEN_FULL_MASK) { (*screen->paintTransformedOutput) (screen, sAttrib, &sTransform, &output->region, output, mask); return TRUE; } else return FALSE; screenLighting (screen, FALSE); transformToScreenSpace (screen, output, -DEFAULT_Z_CAMERA, &sTransform); glPushMatrix (); glLoadMatrixf (sTransform.m); paintOutputRegion (screen, &sTransform, region, output, mask); glPopMatrix (); return TRUE; }
static Bool ringPaintOutput (CompScreen *s, const ScreenPaintAttrib *sAttrib, const CompTransform *transform, Region region, CompOutput *output, unsigned int mask) { Bool status; RING_SCREEN (s); if (rs->state != RingStateNone) mask |= PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS_MASK; UNWRAP (rs, s, paintOutput); status = (*s->paintOutput) (s, sAttrib, transform, region, output, mask); WRAP (rs, s, paintOutput, ringPaintOutput); if (rs->state != RingStateNone) { int i; CompTransform sTransform = *transform; transformToScreenSpace (s, output, -DEFAULT_Z_CAMERA, &sTransform); glPushMatrix (); glLoadMatrixf (sTransform.m); rs->paintingSwitcher = TRUE; for (i = 0; i < rs->nWindows; i++) { if (rs->drawSlots[i].slot && *(rs->drawSlots[i].slot)) { CompWindow *w = rs->drawSlots[i].w; (*s->paintWindow) (w, &w->paint, &sTransform, &infiniteRegion, 0); } } rs->paintingSwitcher = FALSE; if (rs->textData && rs->state != RingStateIn) ringDrawWindowTitle (s); glPopMatrix (); } return status; }
static Bool elementsPaintOutput (CompScreen *s, const ScreenPaintAttrib *sa, const CompTransform *transform, Region region, CompOutput *output, unsigned int mask) { Bool status; E_SCREEN (s); int ii; Bool active = FALSE; for (ii = 0; ii <= 4; ii++) { if (eScreen->isActive[ii]) active = TRUE; } if (active && elementsGetOverWindows (s->display)) mask |= PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS_MASK; UNWRAP (eScreen, s, paintOutput); status = (*s->paintOutput) (s, sa, transform, region, output, mask); WRAP (eScreen, s, paintOutput, elementsPaintOutput); if (active && elementsGetOverWindows (s->display)) { CompTransform sTransform = *transform; transformToScreenSpace (s, output, -DEFAULT_Z_CAMERA, &sTransform); glPushMatrix (); glLoadMatrixf (sTransform.m); beginRendering (eScreen, s); glPopMatrix (); }
static Bool snowPaintOutput (CompScreen *s, const ScreenPaintAttrib *sa, const CompTransform *transform, Region region, CompOutput *output, unsigned int mask) { Bool status; SNOW_SCREEN (s); const BananaValue * option_snow_over_windows = bananaGetOption (bananaIndex, "snow_over_windows", -1); if (ss->active && !option_snow_over_windows->b) mask |= PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS_MASK; UNWRAP (ss, s, paintOutput); status = (*s->paintOutput) (s, sa, transform, region, output, mask); WRAP (ss, s, paintOutput, snowPaintOutput); if (ss->active && option_snow_over_windows->b) { CompTransform sTransform = *transform; transformToScreenSpace (s, output, -DEFAULT_Z_CAMERA, &sTransform); glPushMatrix (); glLoadMatrixf (sTransform.m); beginRendering (ss, s); glPopMatrix (); } return status; }
/* * groupaintTransformedOutput * */ void groupPaintTransformedOutput (CompScreen *s, const ScreenPaintAttrib *sa, const CompTransform *transform, Region region, CompOutput *output, unsigned int mask) { GROUP_SCREEN (s); UNWRAP (gs, s, paintTransformedOutput); (*s->paintTransformedOutput)(s, sa, transform, region, output, mask); WRAP (gs, s, paintTransformedOutput, groupPaintTransformedOutput); if ((gs->vpX == s->x) && (gs->vpY == s->y)) { gs->painted = TRUE; if ((gs->grabState == ScreenGrabTabDrag) && gs->draggedSlot && gs->dragged) { CompTransform wTransform = *transform; (*s->applyScreenTransform)(s, sa, output, &wTransform); transformToScreenSpace (s, output, -sa->zTranslate, &wTransform); glPushMatrix (); glLoadMatrixf (wTransform.m); groupPaintThumb (NULL, gs->draggedSlot, &wTransform, OPAQUE); glPopMatrix (); } else if (gs->grabState == ScreenGrabSelect) { groupPaintSelectionOutline (s, sa, transform, output, TRUE); } } }
static void glPaintRectangle (CompScreen *s, const ScreenPaintAttrib *sAttrib, const CompTransform *transform, CompOutput *output) { float alpha = 0; GRID_SCREEN (s); BoxRec rect; setCurrentRect (s); rect.x1=gs->anim.currentRect.x; rect.y1=gs->anim.currentRect.y; rect.x2=gs->anim.currentRect.x + gs->anim.currentRect.width; rect.y2=gs->anim.currentRect.y + gs->anim.currentRect.height; CompTransform sTransform = *transform; /* rect = desiredSlot;*/ glPushMatrix (); transformToScreenSpace (s, output, -DEFAULT_Z_CAMERA, &sTransform); glLoadMatrixf (sTransform.m); glDisableClientState (GL_TEXTURE_COORD_ARRAY); glEnable (GL_BLEND); /* fill rectangle */ /* TODO: have multiple animations for (iter = animations.begin (); iter != animations.end () && animating; iter++) { */ alpha = ((float) gridGetFillColorAlpha (s->display) / 65535.0f) * gs->anim.opacity; glColor4f (((float) gridGetFillColorRed (s->display) / 65535.0f) * alpha, ((float) gridGetFillColorGreen (s->display) / 65535.0f) * alpha, ((float) gridGetFillColorBlue (s->display) / 65535.0f) * alpha, alpha); glRecti (rect.x1, rect.y2, rect.x2, rect.y1); /* draw outline */ alpha = ((float) gridGetOutlineColorAlpha (s->display) / 65535.0f) * gs->anim.opacity; glColor4f (((float) gridGetOutlineColorRed (s->display) / 65535.0f) * alpha, ((float) gridGetOutlineColorGreen (s->display) / 65535.0f) * alpha, ((float) gridGetOutlineColorBlue (s->display) / 65535.0f) * alpha, alpha); int thickness = gridGetOutlineThickness (s->display); glLineWidth (thickness); glBegin (GL_LINE_LOOP); /* set outline rect smaller to avoid damage issues */ /* TODO: maybe get a better way of doing this */ float half_thickness = thickness * 0.5; glVertex2f (rect.x1 + half_thickness, rect.y1 + half_thickness); glVertex2f (rect.x2 - half_thickness, rect.y1 + half_thickness); glVertex2f (rect.x2 - half_thickness, rect.y2 - half_thickness); glVertex2f (rect.x1 + half_thickness, rect.y2 - half_thickness); glEnd (); /* clean up */ glColor4usv (defaultColor); glDisable (GL_BLEND); glEnableClientState (GL_TEXTURE_COORD_ARRAY); glPopMatrix (); }
static Bool tilePaintOutput (CompScreen *s, const ScreenPaintAttrib *sa, const CompTransform *transform, Region region, CompOutput *output, unsigned int mask) { Bool status; TILE_SCREEN (s); if (ts->grabIndex) mask |= PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS_MASK; UNWRAP (ts, s, paintOutput); status = (*s->paintOutput) (s, sa, transform, region, output, mask); WRAP (ts, s, paintOutput, tilePaintOutput); /* Check if animation is enabled, there is resizing on screen and only outline should be drawn */ if (ts->grabIndex && (output->id == ~0) && (tileGetAnimateType (s->display) == AnimateTypeFilledOutline)) { CompWindow *w; CompTransform sTransform = *transform; float animationDuration = tileGetAnimationDuration (s->display); int x, y, width, height; transformToScreenSpace (s, output, -DEFAULT_Z_CAMERA, &sTransform); glPushMatrix (); glLoadMatrixf (sTransform.m); glLineWidth (4.0f); for (w = s->windows; w; w = w->next) { TILE_WINDOW (w); if (tw->animationType == Animating) { /* Coordinate = start + speed * elapsedTime Coordinate = start + (target - start)/interval * elapsedTime Draw outline */ x = tw->prevCoords.x - w->input.left + (((float)(w->attrib.x - tw->prevCoords.x)) * ts->msResizing / animationDuration); y = tw->prevCoords.y - w->input.top + (((float)(w->attrib.y - tw->prevCoords.y)) * ts->msResizing / animationDuration); width = tw->prevCoords.width + w->input.left + w->input.right + (((float)(w->attrib.width - tw->prevCoords.width)) * ts->msResizing / animationDuration); height = tw->prevCoords.height + w->input.top + w->input.bottom + (((float)(w->attrib.height - tw->prevCoords.height)) * ts->msResizing / animationDuration); glColor3us (tw->outlineColor[0] * 0.66, tw->outlineColor[1] * 0.66, tw->outlineColor[2] * 0.66); glRecti (x, y + height, x + width, y); glColor3usv (tw->outlineColor); glBegin (GL_LINE_LOOP); glVertex3f (x, y, 0.0f); glVertex3f (x + width, y, 0.0f); glVertex3f (x + width, y + height, 0.0f); glVertex3f (x, y + height, 0.0f); glEnd (); glColor4usv (defaultColor); } } glPopMatrix (); glColor4usv (defaultColor); glLineWidth (1.0f); } return status; }
static Bool thumbPaintOutput (CompScreen *s, const ScreenPaintAttrib *sAttrib, const CompTransform *transform, Region region, CompOutput *output, unsigned int mask) { Bool status; unsigned int newMask = mask; THUMB_SCREEN (s); ts->painted = FALSE; ts->x = s->x; ts->y = s->y; if ((ts->oldThumb.opacity > 0.0 && ts->oldThumb.win) || (ts->thumb.opacity > 0.0 && ts->thumb.win)) { newMask |= PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS_MASK; } UNWRAP (ts, s, paintOutput); status = (*s->paintOutput)(s, sAttrib, transform, region, output, newMask); WRAP (ts, s, paintOutput, thumbPaintOutput); const BananaValue * option_always_on_top = bananaGetOption (bananaIndex, "always_on_top", s->screenNum); if (option_always_on_top->b && !ts->painted) { if (ts->oldThumb.opacity > 0.0 && ts->oldThumb.win) { CompTransform sTransform = *transform; transformToScreenSpace (s, output, -DEFAULT_Z_CAMERA, &sTransform); glPushMatrix (); glLoadMatrixf (sTransform.m); thumbPaintThumb (s, &ts->oldThumb, &sTransform); glPopMatrix (); } if (ts->thumb.opacity > 0.0 && ts->thumb.win) { CompTransform sTransform = *transform; transformToScreenSpace (s, output, -DEFAULT_Z_CAMERA, &sTransform); glPushMatrix (); glLoadMatrixf (sTransform.m); thumbPaintThumb (s, &ts->thumb, &sTransform); glPopMatrix (); } } return status; }
/* * groupPaintSelectionOutline * */ static void groupPaintSelectionOutline (CompScreen *s, const ScreenPaintAttrib *sa, const CompTransform *transform, CompOutput *output, Bool transformed) { int x1, x2, y1, y2; GROUP_SCREEN (s); x1 = MIN (gs->x1, gs->x2); y1 = MIN (gs->y1, gs->y2); x2 = MAX (gs->x1, gs->x2); y2 = MAX (gs->y1, gs->y2); const BananaValue * option_fill_color = bananaGetOption (bananaIndex, "fill_color", s->screenNum); const BananaValue * option_line_color = bananaGetOption (bananaIndex, "line_color", s->screenNum); unsigned short fill_color[] = { 0, 0, 0, 0 }; unsigned short line_color[] = { 0, 0, 0, 0 }; stringToColor (option_fill_color->s, fill_color); stringToColor (option_line_color->s, line_color); if (gs->grabState == ScreenGrabSelect) { CompTransform sTransform = *transform; if (transformed) { (*s->applyScreenTransform)(s, sa, output, &sTransform); transformToScreenSpace (s, output, -sa->zTranslate, &sTransform); } else transformToScreenSpace (s, output, -DEFAULT_Z_CAMERA, &sTransform); glPushMatrix (); glLoadMatrixf (sTransform.m); glDisableClientState (GL_TEXTURE_COORD_ARRAY); glEnable (GL_BLEND); glColor4usv (fill_color); glRecti (x1, y2, x2, y1); glColor4usv (line_color); glBegin (GL_LINE_LOOP); glVertex2i (x1, y1); glVertex2i (x2, y1); glVertex2i (x2, y2); glVertex2i (x1, y2); glEnd (); glColor4usv (defaultColor); glDisable (GL_BLEND); glEnableClientState (GL_TEXTURE_COORD_ARRAY); glPopMatrix (); } }
static Bool zoomPaintOutput(CompScreen *s, const ScreenPaintAttrib *sAttrib, const CompTransform *transform, Region region, CompOutput *output, unsigned int mask) { CompTransform zTransform = *transform; Bool status; ZOOM_SCREEN(s); if (output->id != ~0 && (zs->zoomed & (1 << output->id))) { int saveFilter; ZoomBox box; float scale, x, y, x1, y1; float oWidth = output->width; float oHeight = output->height; mask &= ~PAINT_SCREEN_REGION_MASK; zoomGetCurrentZoom(s, output->id, &box); x1 = box.x1 - output->region.extents.x1; y1 = box.y1 - output->region.extents.y1; scale = oWidth / (box.x2 - box.x1); x = ((oWidth / 2.0f) - x1) / oWidth; y = ((oHeight / 2.0f) - y1) / oHeight; x = 0.5f - x * scale; y = 0.5f - y * scale; matrixTranslate(&zTransform, -x, y, 0.0f); matrixScale(&zTransform, scale, scale, 1.0f); mask |= PAINT_SCREEN_TRANSFORMED_MASK; saveFilter = s->filter[SCREEN_TRANS_FILTER]; if ((zs->zoomOutput != output->id || !zs->adjust) && scale > 3.9f && !zs->opt[ZOOM_SCREEN_OPTION_FILTER_LINEAR].value.b) s->filter[SCREEN_TRANS_FILTER] = COMP_TEXTURE_FILTER_FAST; UNWRAP(zs, s, paintOutput); status = (*s->paintOutput)(s, sAttrib, &zTransform, region, output, mask); WRAP(zs, s, paintOutput, zoomPaintOutput); s->filter[SCREEN_TRANS_FILTER] = saveFilter; } else { UNWRAP(zs, s, paintOutput); status = (*s->paintOutput)(s, sAttrib, transform, region, output, mask); WRAP(zs, s, paintOutput, zoomPaintOutput); } if (status && zs->grab) { int x1, x2, y1, y2; x1 = MIN(zs->x1, zs->x2); y1 = MIN(zs->y1, zs->y2); x2 = MAX(zs->x1, zs->x2); y2 = MAX(zs->y1, zs->y2); if (zs->grabIndex) { transformToScreenSpace(s, output, -DEFAULT_Z_CAMERA, &zTransform); glPushMatrix(); glLoadMatrixf(zTransform.m); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glEnable(GL_BLEND); glColor4us(0x2fff, 0x2fff, 0x4fff, 0x4fff); glRecti(x1, y2, x2, y1); glColor4us(0x2fff, 0x2fff, 0x4fff, 0x9fff); glBegin(GL_LINE_LOOP); glVertex2i(x1, y1); glVertex2i(x2, y1); glVertex2i(x2, y2); glVertex2i(x1, y2); glEnd(); glColor4usv(defaultColor); glDisable(GL_BLEND); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glPopMatrix(); } } return status; }
/* * groupPaintOutput * */ Bool groupPaintOutput (CompScreen *s, const ScreenPaintAttrib *sAttrib, const CompTransform *transform, Region region, CompOutput *output, unsigned int mask) { GroupSelection *group; Bool status; GROUP_SCREEN (s); GROUP_DISPLAY (&display); gs->painted = FALSE; gs->vpX = s->x; gs->vpY = s->y; if (gd->resizeInfo) { mask |= PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS_MASK; } else { for (group = gs->groups; group; group = group->next) { if (group->changeState != NoTabChange || group->tabbingState != NoTabbing) { mask |= PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS_MASK; } else if (group->tabBar && (group->tabBar->state != PaintOff)) { mask |= PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS_MASK; } } } UNWRAP (gs, s, paintOutput); status = (*s->paintOutput)(s, sAttrib, transform, region, output, mask); WRAP (gs, s, paintOutput, groupPaintOutput); if (status && !gs->painted) { if ((gs->grabState == ScreenGrabTabDrag) && gs->draggedSlot) { CompTransform wTransform = *transform; PaintState state; GROUP_WINDOW (gs->draggedSlot->window); transformToScreenSpace (s, output, -DEFAULT_Z_CAMERA, &wTransform); glPushMatrix (); glLoadMatrixf (wTransform.m); /* prevent tab bar drawing.. */ state = gw->group->tabBar->state; gw->group->tabBar->state = PaintOff; groupPaintThumb (NULL, gs->draggedSlot, &wTransform, OPAQUE); gw->group->tabBar->state = state; glPopMatrix (); } else if (gs->grabState == ScreenGrabSelect) { groupPaintSelectionOutline (s, sAttrib, transform, output, FALSE); } } return status; }