C++ (Cpp) freeWindowPrivateIndexの例

コード例 #1

ファイル: decoration.c プロジェクト: SubwayDesktop/compiz-stable

static void
decorFiniScreen (CompPlugin *p,
		 CompScreen *s)
{
    int	i;

    DECOR_SCREEN (s);

    for (i = 0; i < DECOR_NUM; i++)
	if (ds->decor[i])
	    decorReleaseDecoration (s, ds->decor[i]);

    if (ds->decoratorStartHandle)
	compRemoveTimeout (ds->decoratorStartHandle);

    freeWindowPrivateIndex (s, ds->windowPrivateIndex);

    UNWRAP (ds, s, drawWindow);
    UNWRAP (ds, s, damageWindowRect);
    UNWRAP (ds, s, getOutputExtentsForWindow);
    UNWRAP (ds, s, windowMoveNotify);
    UNWRAP (ds, s, windowResizeNotify);
    UNWRAP (ds, s, windowStateChangeNotify);
    UNWRAP (ds, s, addSupportedAtoms);

    setSupportedWmHints (s);

    free (ds);
}

コード例 #2

ファイル: winrules.c プロジェクト: noodlylight/fusilli

static void
winrulesFiniScreen (CompPlugin *p,
                    CompScreen *s)
{
	WINRULES_SCREEN (s);

	UNWRAP (ws, s, getAllowedActionsForWindow);

	matchFini (&ws->skiptaskbar_match);
	matchFini (&ws->skippager_match);
	matchFini (&ws->above_match);
	matchFini (&ws->below_match);
	matchFini (&ws->sticky_match);
	matchFini (&ws->fullscreen_match);
	matchFini (&ws->maximize_match);
	matchFini (&ws->no_argb_match);
	matchFini (&ws->no_move_match);
	matchFini (&ws->no_resize_match);
	matchFini (&ws->no_minimize_match);
	matchFini (&ws->no_maximize_match);
	matchFini (&ws->no_close_match);
	matchFini (&ws->no_focus_match);

	int i;
	for (i = 0; i < ws->size_matches_count; i++)
		matchFini (&ws->size_matches[i]);

	freeWindowPrivateIndex (s, ws->windowPrivateIndex);

	free (ws);
}

コード例 #3

ファイル: ring.c プロジェクト: bhull2010/compizfusion-plugins-main-packages

static void
ringFiniScreen (CompPlugin *p,
		CompScreen *s)
{
    RING_SCREEN (s);

    freeWindowPrivateIndex (s, rs->windowPrivateIndex);

    UNWRAP (rs, s, preparePaintScreen);
    UNWRAP (rs, s, donePaintScreen);
    UNWRAP (rs, s, paintOutput);
    UNWRAP (rs, s, paintWindow);
    UNWRAP (rs, s, damageWindowRect);

    matchFini (&rs->match);

    ringFreeWindowTitle (s);

    if (rs->windows)
	free (rs->windows);

    if (rs->drawSlots)
	free (rs->drawSlots);

    free (rs);
}

コード例 #4

ファイル: titleinfo.c プロジェクト: AtheistSpacePirate/compiz

static void titleinfoFiniScreen(CompPlugin * p, CompScreen * s)
{
	TITLEINFO_SCREEN(s);

	UNWRAP(ts, s, addSupportedAtoms);

	freeWindowPrivateIndex(s, ts->windowPrivateIndex);

	free(ts);
}

コード例 #5

ファイル: colorfilter.c プロジェクト: compiz-reloaded/compiz-plugins-main

static void
colorFilterFiniScreen (CompPlugin * p, CompScreen * s)
{
    FILTER_SCREEN (s);

    freeWindowPrivateIndex (s, cfs->windowPrivateIndex);
    UNWRAP (cfs, s, drawWindowTexture);

    unloadFilters (s);

    free (cfs);
}

コード例 #6

ファイル: scaleaddon.c プロジェクト: AtheistSpacePirate/compiz

static void scaleaddonFiniScreen(CompPlugin * p, CompScreen * s)
{
	ADDON_SCREEN(s);
	SCALE_SCREEN(s);

	UNWRAP(as, s, donePaintScreen);
	UNWRAP(as, ss, scalePaintDecoration);
	UNWRAP(as, ss, selectWindow);
	UNWRAP(as, ss, layoutSlotsAndAssignWindows);

	freeWindowPrivateIndex(s, as->windowPrivateIndex);
	free(as);
}

コード例 #7

ファイル: snap.c プロジェクト: compiz-reloaded/compiz-plugins-main

static void snapFiniScreen(CompPlugin * p, CompScreen * s)
{
	SNAP_SCREEN(s);

	freeWindowPrivateIndex(s, ss->windowPrivateIndex);

	//UNWRAP(ss, s, windowResizeNotify);
	UNWRAP(ss, s, windowMoveNotify);
	UNWRAP(ss, s, windowGrabNotify);
	UNWRAP(ss, s, windowUngrabNotify);

	free(ss);
}

コード例 #8

ファイル: fade.c プロジェクト: freedesktop-unofficial-mirror/xorg__app__glxcompmgr

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);
}

コード例 #9

ファイル: svg.c プロジェクト: zmike/compiz

static void
svgFiniScreen(CompPlugin *p,
              CompScreen *s)
{
    SVG_SCREEN(s);

    freeWindowPrivateIndex(s, ss->windowPrivateIndex);

    UNWRAP(ss, s, drawWindow);
    UNWRAP(ss, s, windowMoveNotify);
    UNWRAP(ss, s, windowResizeNotify);

    free(ss);
}

コード例 #10

ファイル: smartput.c プロジェクト: JakeSFR/compiz-plugins-experimental

static void
smartputFiniScreen (CompPlugin *p,
		    CompScreen *s)
{
    SMARTPUT_SCREEN (s);

    freeWindowPrivateIndex (s, sps->windowPrivateIndex);

    UNWRAP (sps, s, preparePaintScreen);
    UNWRAP (sps, s, donePaintScreen);
    UNWRAP (sps, s, paintOutput);
    UNWRAP (sps, s, paintWindow);

    free (sps);
}

コード例 #11

ファイル: throw.c プロジェクト: JakeSFR/compiz-plugins-experimental

static void
throwFiniScreen (CompPlugin *p,
		CompScreen *s)
{
    THROW_SCREEN (s);

    freeWindowPrivateIndex (s, ts->windowPrivateIndex);

    UNWRAP (ts, s, windowGrabNotify);
    UNWRAP (ts, s, windowUngrabNotify);
    UNWRAP (ts, s, preparePaintScreen);
    UNWRAP (ts, s, windowMoveNotify);
    UNWRAP (ts, s, donePaintScreen);

    free (ts);
}

コード例 #12

ファイル: neg.c プロジェクト: bhull2010/compizfusion-plugins-main-packages

static void
NEGFiniScreen (CompPlugin *p,
	       CompScreen *s)
{
    NEG_SCREEN (s);

    freeWindowPrivateIndex (s, ns->windowPrivateIndex);

    UNWRAP (ns, s, drawWindowTexture);

    if (ns->negFunction)
	destroyFragmentFunction (s, ns->negFunction);
    if (ns->negAlphaFunction)
	destroyFragmentFunction (s, ns->negAlphaFunction);

    free (ns);
}

コード例 #13

ファイル: screensaver.cpp プロジェクト: JakeSFR/compiz-plugins-experimental

static void
screenSaverFiniScreen (CompPlugin *p,
		      CompScreen *s)
{
	SCREENSAVER_SCREEN (s);

	UNWRAP (ss, s, preparePaintScreen);
	UNWRAP (ss, s, donePaintScreen);
	UNWRAP (ss, s, paintOutput);
	UNWRAP (ss, s, paintWindow);
	UNWRAP (ss, s, paintTransformedOutput);
	UNWRAP (ss, s, paintScreen);

	delete ss->effect;
	freeWindowPrivateIndex(s, ss->windowPrivateIndex);
	free (ss);
}

コード例 #14

ファイル: minimize.c プロジェクト: AtheistSpacePirate/compiz

static void minFiniScreen(CompPlugin * p, CompScreen * s)
{
	MIN_SCREEN(s);

	freeWindowPrivateIndex(s, ms->windowPrivateIndex);

	UNWRAP(ms, s, preparePaintScreen);
	UNWRAP(ms, s, donePaintScreen);
	UNWRAP(ms, s, paintOutput);
	UNWRAP(ms, s, paintWindow);
	UNWRAP(ms, s, damageWindowRect);
	UNWRAP(ms, s, focusWindow);

	compFiniScreenOptions(s, ms->opt, MIN_SCREEN_OPTION_NUM);

	free(ms);
}

コード例 #15

ファイル: static.c プロジェクト: compiz-reloaded/compiz-plugins-experimental

static void
staticFiniScreen (CompPlugin *p,
                  CompScreen *s)
{
    STATIC_SCREEN (s);

    freeWindowPrivateIndex (s, ss->windowPrivateIndex);

    UNWRAP (ss, s, paintTransformedOutput);
    UNWRAP (ss, s, applyScreenTransform);
    UNWRAP (ss, s, preparePaintScreen);
    UNWRAP (ss, s, drawWindowTexture);
    UNWRAP (ss, s, addWindowGeometry);
    UNWRAP (ss, s, paintOutput);
    UNWRAP (ss, s, paintWindow);

    free (ss);
}

コード例 #16

ファイル: minimize.c プロジェクト: jordigh/fusilli

static void
minFiniScreen (CompPlugin *p,
               CompScreen *s)
{
	MIN_SCREEN (s);

	matchFini (&ms->match);
	freeWindowPrivateIndex (s, ms->windowPrivateIndex);

	UNWRAP (ms, s, preparePaintScreen);
	UNWRAP (ms, s, donePaintScreen);
	UNWRAP (ms, s, paintOutput);
	UNWRAP (ms, s, paintWindow);
	UNWRAP (ms, s, damageWindowRect);
	UNWRAP (ms, s, focusWindow);

	free (ms);
}

コード例 #17

ファイル: tile.c プロジェクト: compiz-reloaded/compiz-plugins-experimental

static void
tileFiniScreen (CompPlugin *p,
		CompScreen *s)
{
    TILE_SCREEN (s);

    freeWindowPrivateIndex (s, ts->windowPrivateIndex);

    /* Restore the original function */
    UNWRAP (ts, s, paintOutput);
    UNWRAP (ts, s, preparePaintScreen);
    UNWRAP (ts, s, paintScreen);
    UNWRAP (ts, s, donePaintScreen);
    UNWRAP (ts, s, windowResizeNotify);
    UNWRAP (ts, s, paintWindow);

    free (ts);
}

コード例 #18

ファイル: fade.c プロジェクト: zmike/compiz

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);
}

コード例 #19

ファイル: video.c プロジェクト: zmike/compiz

static void
videoFiniScreen(CompPlugin *p,
                CompScreen *s)
{
   VIDEO_DISPLAY(s->display);
   VIDEO_SCREEN(s);

   freeWindowPrivateIndex(s, vs->windowPrivateIndex);

   XDeleteProperty(s->display->display, s->root, vd->videoSupportedAtom);

   videoDestroyFragmentFunctions(s, &vs->yv12Functions);

   UNWRAP(vs, s, drawWindow);
   UNWRAP(vs, s, drawWindowTexture);
   UNWRAP(vs, s, damageWindowRect);
   UNWRAP(vs, s, windowMoveNotify);
   UNWRAP(vs, s, windowResizeNotify);

   free(vs);
}

コード例 #20

ファイル: group-init.c プロジェクト: noodlylight/fusilli

/*
 * 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);
}