/*
 * groupCreateCairoLayer
 *
 */
GroupCairoLayer*
groupCreateCairoLayer (CompScreen *s,
		       int        width,
		       int        height)
{
    GroupCairoLayer *layer;


    layer = malloc (sizeof (GroupCairoLayer));
    if (!layer)
        return NULL;

    layer->surface = NULL;
    layer->cairo   = NULL;
    layer->buffer  = NULL;
    layer->pixmap  = None;

    layer->animationTime = 0;
    layer->state         = PaintOff;

    layer->texWidth  = width;
    layer->texHeight = height;

    initTexture (s, &layer->texture);

    layer->buffer = calloc (4 * width * height, sizeof (unsigned char));
    if (!layer->buffer)
    {
	compLogMessage ("group", CompLogLevelError,
			"Failed to allocate cairo layer buffer.");
	groupDestroyCairoLayer (s, layer);
	return NULL;
    }

    layer->surface = cairo_image_surface_create_for_data (layer->buffer,
							  CAIRO_FORMAT_ARGB32,
							  width, height,
							  4 * width);
    if (cairo_surface_status (layer->surface) != CAIRO_STATUS_SUCCESS)
    {
	compLogMessage ("group", CompLogLevelError,
			"Failed to create cairo layer surface.");
	groupDestroyCairoLayer (s, layer);
	return NULL;
    }

    layer->cairo = cairo_create (layer->surface);
    if (cairo_status (layer->cairo) != CAIRO_STATUS_SUCCESS)
    {
	compLogMessage ("group", CompLogLevelError,
			"Failed to create cairo layer context.");
	groupDestroyCairoLayer (s, layer);
	return NULL;
    }

    groupClearCairoLayer (layer);

    return layer;
}
/*
 * groupRebuildCairoLayer
 *
 */
GroupCairoLayer*
groupRebuildCairoLayer (CompScreen      *s,
			GroupCairoLayer *layer,
			int             width,
			int             height)
{
    int        timeBuf = layer->animationTime;
    PaintState stateBuf = layer->state;

    groupDestroyCairoLayer (s, layer);
    layer = groupCreateCairoLayer (s, width, height);
    if (!layer)
	return NULL;

    layer->animationTime = timeBuf;
    layer->state = stateBuf;

    return layer;
}
Exemple #3
0
/*
 * groupFiniScreen
 *
 */
static void
groupFiniScreen (CompPlugin *p,
                 CompScreen *s)
{
    GROUP_SCREEN (s);

    if (gs->groups)
    {
        GroupSelection *group, *nextGroup;

        for (group = gs->groups; group; )
        {
            if (group->tabBar)
            {
                GroupTabBarSlot *slot, *nextSlot;

                for (slot = group->tabBar->slots; slot; )
                {
                    if (slot->region)
                        XDestroyRegion (slot->region);

                    nextSlot = slot->next;
                    free (slot);
                    slot = nextSlot;
                }

                groupDestroyCairoLayer (s, group->tabBar->textLayer);
                groupDestroyCairoLayer (s, group->tabBar->bgLayer);
                groupDestroyCairoLayer (s, group->tabBar->selectionLayer);

                if (group->inputPrevention)
                    XDestroyWindow (display.display,
                                    group->inputPrevention);

                if (group->tabBar->region)
                    XDestroyRegion (group->tabBar->region);

                if (group->tabBar->timeoutHandle)
                    compRemoveTimeout (group->tabBar->timeoutHandle);

                free (group->tabBar);
            }

            nextGroup = group->next;
            free (group);
            group = nextGroup;
        }
    }

    if (gs->tmpSel.windows)
        free (gs->tmpSel.windows);

    if (gs->grabIndex)
        groupGrabScreen (s, ScreenGrabNone);

    if (gs->dragHoverTimeoutHandle)
        compRemoveTimeout (gs->dragHoverTimeoutHandle);

    if (gs->showDelayTimeoutHandle)
        compRemoveTimeout (gs->showDelayTimeoutHandle);

    if (gs->dequeueTimeoutHandle)
        compRemoveTimeout (gs->dequeueTimeoutHandle);

    if (gs->initialActionsTimeoutHandle)
        compRemoveTimeout (gs->initialActionsTimeoutHandle);

    freeWindowPrivateIndex (s, gs->windowPrivateIndex);

    matchFini (&gs->window_match);

    UNWRAP (gs, s, windowMoveNotify);
    UNWRAP (gs, s, windowResizeNotify);
    UNWRAP (gs, s, getOutputExtentsForWindow);
    UNWRAP (gs, s, preparePaintScreen);
    UNWRAP (gs, s, paintOutput);
    UNWRAP (gs, s, drawWindow);
    UNWRAP (gs, s, paintWindow);
    UNWRAP (gs, s, paintTransformedOutput);
    UNWRAP (gs, s, donePaintScreen);
    UNWRAP (gs, s, windowGrabNotify);
    UNWRAP (gs, s, windowUngrabNotify);
    UNWRAP (gs, s, damageWindowRect);
    UNWRAP (gs, s, windowStateChangeNotify);
    UNWRAP (gs, s, activateWindow);

    finiTexture (s, &gs->glowTexture);
    free (gs);
}