static Bool fadeInitScreen (CompPlugin *p, CompScreen *s) { FadeScreen *fs; FADE_DISPLAY (s->display); fs = malloc (sizeof (FadeScreen)); if (!fs) return FALSE; fs->windowPrivateIndex = allocateWindowPrivateIndex (s); if (fs->windowPrivateIndex < 0) { free (fs); return FALSE; } fs->steps = 0; fs->fadeTime = 1000.0f / FADE_SPEED_DEFAULT; fadeScreenInitOptions (fs); WRAP (fs, s, preparePaintScreen, fadePreparePaintScreen); WRAP (fs, s, paintWindow, fadePaintWindow); WRAP (fs, s, damageWindowRect, fadeDamageWindowRect); s->privates[fd->screenPrivateIndex].ptr = fs; return TRUE; }
static Bool tileInitScreen (CompPlugin *p, CompScreen *s) { TileScreen *ts; TILE_DISPLAY (s->display); ts = (TileScreen *) calloc (1, sizeof (TileScreen)); ts->windowPrivateIndex = allocateWindowPrivateIndex (s); if (ts->windowPrivateIndex < 0) { free (ts); return FALSE; } srand (time (0)); s->base.privates[td->screenPrivateIndex].ptr = ts; ts->grabIndex = 0; ts->msResizing = 0; ts->oneDuration = 0; /* Wrap plugin functions */ WRAP (ts, s, paintOutput, tilePaintOutput); WRAP (ts, s, preparePaintScreen, tilePreparePaintScreen); WRAP (ts, s, paintScreen, tilePaintScreen); WRAP (ts, s, donePaintScreen, tileDonePaintScreen); WRAP (ts, s, windowResizeNotify, tileResizeNotify); WRAP (ts, s, paintWindow, tilePaintWindow); return TRUE; }
static Bool svgInitScreen(CompPlugin *p, CompScreen *s) { SvgScreen *ss; SVG_DISPLAY(s->display); ss = malloc(sizeof (SvgScreen)); if (!ss) return FALSE; ss->windowPrivateIndex = allocateWindowPrivateIndex(s); if (ss->windowPrivateIndex < 0) { free(ss); return FALSE; } memset(&ss->zoom, 0, sizeof (BoxRec)); WRAP(ss, s, drawWindow, svgDrawWindow); WRAP(ss, s, windowMoveNotify, svgWindowMoveNotify); WRAP(ss, s, windowResizeNotify, svgWindowResizeNotify); s->base.privates[sd->screenPrivateIndex].ptr = ss; return TRUE; }
static Bool titleinfoInitScreen (CompPlugin *p, CompScreen *s) { TitleinfoScreen *ts; TITLEINFO_DISPLAY (s->display); ts = malloc (sizeof (TitleinfoScreen)); if (!ts) return FALSE; ts->windowPrivateIndex = allocateWindowPrivateIndex (s); if (ts->windowPrivateIndex < 0) { free (ts); return FALSE; } s->base.privates[td->screenPrivateIndex].ptr = ts; WRAP (ts, s, addSupportedAtoms, titleinfoAddSupportedAtoms); return TRUE; }
static Bool throwInitScreen (CompPlugin *p, CompScreen *s) { ThrowScreen * ts; THROW_DISPLAY (s->display); ts = malloc (sizeof (ThrowScreen)); if (!ts) return FALSE; ts->windowPrivateIndex = allocateWindowPrivateIndex (s); if (ts->windowPrivateIndex < 0) { free (ts); return FALSE; } WRAP (ts, s, windowGrabNotify, throwWindowGrabNotify); WRAP (ts, s, windowUngrabNotify, throwWindowUngrabNotify); WRAP (ts, s, preparePaintScreen, throwPreparePaintScreen); WRAP (ts, s, windowMoveNotify, throwWindowMoveNotify); WRAP (ts, s, donePaintScreen, throwDonePaintScreen); s->base.privates[td->screenPrivateIndex].ptr = ts; return TRUE; }
static Bool staticInitScreen (CompPlugin *p, CompScreen *s) { StaticScreen *ss; STATIC_DISPLAY (s->display); ss = calloc (1, sizeof (StaticScreen) ); if (!ss) return FALSE; ss->windowPrivateIndex = allocateWindowPrivateIndex (s); if (ss->windowPrivateIndex < 0) { free (ss); return FALSE; } ss->active = FALSE; WRAP (ss, s, paintWindow, staticPaintWindow); WRAP (ss, s, paintOutput, staticPaintOutput); WRAP (ss, s, addWindowGeometry, staticAddWindowGeometry); WRAP (ss, s, drawWindowTexture, staticDrawWindowTexture); WRAP (ss, s, preparePaintScreen, staticPreparePaintScreen); WRAP (ss, s, applyScreenTransform, staticApplyScreenTransform); WRAP (ss, s, paintTransformedOutput, staticPaintTransformedOutput); s->base.privates[sd->screenPrivateIndex].ptr = ss; return TRUE; }
static Bool smartputInitScreen (CompPlugin *p, CompScreen *s) { SmartputScreen *sps; SMARTPUT_DISPLAY (s->display); sps = malloc (sizeof (SmartputScreen)); if (!sps) return FALSE; sps->windowPrivateIndex = allocateWindowPrivateIndex (s); if (sps->windowPrivateIndex < 0) { free (sps); return FALSE; } /* initialize variables * bad stuff happens if we don't do this */ sps->animation = FALSE; sps->grabIndex = 0; sps->lastWindow = None; /* wrap the overloaded functions */ WRAP (sps, s, preparePaintScreen, smartputPreparePaintScreen); WRAP (sps, s, donePaintScreen, smartputDonePaintScreen); WRAP (sps, s, paintOutput, smartputPaintOutput); WRAP (sps, s, paintWindow, smartputPaintWindow); s->base.privates[spd->screenPrivateIndex].ptr = sps; return TRUE; }
static Bool snapInitScreen(CompPlugin * p, CompScreen * s) { SnapScreen *ss; SNAP_DISPLAY(s->display); ss = malloc(sizeof(SnapScreen)); if (!ss) return FALSE; ss->windowPrivateIndex = allocateWindowPrivateIndex(s); if (ss->windowPrivateIndex < 0) { free(ss); return FALSE; } //WRAP(ss, s, windowResizeNotify, snapWindowResizeNotify); WRAP(ss, s, windowMoveNotify, snapWindowMoveNotify); WRAP(ss, s, windowGrabNotify, snapWindowGrabNotify); WRAP(ss, s, windowUngrabNotify, snapWindowUngrabNotify); s->base.privates[sd->screenPrivateIndex].ptr = ss; return TRUE; }
static Bool screenSaverInitScreen (CompPlugin *p, CompScreen *s) { ScreenSaverScreen *ss; SCREENSAVER_DISPLAY (s->display); ss = (ScreenSaverScreen*)malloc (sizeof (ScreenSaverScreen)); if (!ss) return FALSE; ss->windowPrivateIndex = allocateWindowPrivateIndex (s); if (ss->windowPrivateIndex < 0) { free (ss); return FALSE; } s->base.privates[sd->screenPrivateIndex].ptr = ss; ss->effect = new ScreenEffect(s); ss->desktopOpacity = OPAQUE; WRAP (ss, s, preparePaintScreen, screenSaverPreparePaintScreen); WRAP (ss, s, donePaintScreen, screenSaverDonePaintScreen); WRAP (ss, s, paintOutput, screenSaverPaintOutput); WRAP (ss, s, paintWindow, screenSaverPaintWindow); WRAP (ss, s, paintTransformedOutput, screenSaverPaintTransformedOutput); WRAP (ss, s, paintScreen, screenSaverPaintScreen); return TRUE; }
static Bool colorFilterInitScreen (CompPlugin *p, CompScreen *s) { ColorFilterScreen *cfs; FILTER_DISPLAY (&display); if (!s->fragmentProgram) { compLogMessage ("colorfilter", CompLogLevelFatal, "Fragment program support missing."); return TRUE; } cfs = malloc (sizeof (ColorFilterScreen)); if (!cfs) return FALSE; cfs->windowPrivateIndex = allocateWindowPrivateIndex (s); if (cfs->windowPrivateIndex < 0) { free (cfs); return FALSE; } cfs->isFiltered = FALSE; cfs->currentFilter = 0; cfs->filtersLoaded = FALSE; cfs->filtersFunctions = NULL; cfs->filtersCount = 0; WRAP (cfs, s, drawWindowTexture, colorFilterDrawWindowTexture); WRAP (cfs, s, windowAddNotify, colorFilterWindowAddNotify); s->privates[cfd->screenPrivateIndex].ptr = cfs; const BananaValue * option_filter_match = bananaGetOption (bananaIndex, "filter_match", s->screenNum); matchInit (&cfs->filter_match); matchAddFromString (&cfs->filter_match, option_filter_match->s); matchUpdate (&cfs->filter_match); const BananaValue * option_exclude_match = bananaGetOption (bananaIndex, "exclude_match", s->screenNum); matchInit (&cfs->exclude_match); matchAddFromString (&cfs->exclude_match, option_exclude_match->s); matchUpdate (&cfs->exclude_match); return TRUE; }
static Bool ringInitScreen (CompPlugin *p, CompScreen *s) { RingScreen *rs; RING_DISPLAY (s->display); rs = malloc (sizeof (RingScreen)); if (!rs) return FALSE; rs->windowPrivateIndex = allocateWindowPrivateIndex (s); if (rs->windowPrivateIndex < 0) { free (rs); return FALSE; } rs->grabIndex = 0; rs->state = RingStateNone; rs->windows = NULL; rs->drawSlots = NULL; rs->windowsSize = 0; rs->paintingSwitcher = FALSE; rs->selectedWindow = NULL; rs->moreAdjust = FALSE; rs->rotateAdjust = FALSE; rs->rotAdjust = 0; rs->rVelocity = 0; rs->textData = NULL; matchInit (&rs->match); WRAP (rs, s, preparePaintScreen, ringPreparePaintScreen); WRAP (rs, s, donePaintScreen, ringDonePaintScreen); WRAP (rs, s, paintOutput, ringPaintOutput); WRAP (rs, s, paintWindow, ringPaintWindow); WRAP (rs, s, damageWindowRect, ringDamageWindowRect); s->base.privates[rd->screenPrivateIndex].ptr = rs; return TRUE; }
static Bool videoInitScreen(CompPlugin *p, CompScreen *s) { VideoScreen *vs; VIDEO_DISPLAY(s->display); vs = malloc(sizeof (VideoScreen)); if (!vs) return FALSE; vs->windowPrivateIndex = allocateWindowPrivateIndex(s); if (vs->windowPrivateIndex < 0) { free(vs); return FALSE; } vs->yv12Functions = NULL; memset(vs->imageFormat, 0, sizeof (vs->imageFormat)); vs->imageFormat[IMAGE_FORMAT_RGB] = TRUE; if (s->fragmentProgram) { if (s->glxPixmapFBConfigs[8].fbConfig) { vs->imageFormat[IMAGE_FORMAT_YV12] = TRUE; } else { compLogMessage("video", CompLogLevelWarn, "No 8 bit GLX pixmap format, " "disabling YV12 image format"); } } WRAP(vs, s, drawWindow, videoDrawWindow); WRAP(vs, s, drawWindowTexture, videoDrawWindowTexture); WRAP(vs, s, damageWindowRect, videoDamageWindowRect); WRAP(vs, s, windowMoveNotify, videoWindowMoveNotify); WRAP(vs, s, windowResizeNotify, videoWindowResizeNotify); s->base.privates[vd->screenPrivateIndex].ptr = vs; videoSetSupportedHint(s); return TRUE; }
static Bool fadeInitScreen(CompPlugin *p, CompScreen *s) { FadeScreen *fs; FADE_DISPLAY(s->display); fs = malloc(sizeof (FadeScreen)); if (!fs) return FALSE; if (!compInitScreenOptionsFromMetadata(s, &fadeMetadata, fadeScreenOptionInfo, fs->opt, FADE_SCREEN_OPTION_NUM)) { free(fs); return FALSE; } fs->windowPrivateIndex = allocateWindowPrivateIndex(s); if (fs->windowPrivateIndex < 0) { compFiniScreenOptions(s, fs->opt, FADE_SCREEN_OPTION_NUM); free(fs); return FALSE; } fs->fadeTime = 1000.0f / fs->opt[FADE_SCREEN_OPTION_FADE_SPEED].value.f; matchInit(&fs->match); fadeUpdateWindowFadeMatch(s->display, &fs->opt[FADE_SCREEN_OPTION_WINDOW_MATCH].value, &fs->match); WRAP(fs, s, preparePaintScreen, fadePreparePaintScreen); WRAP(fs, s, paintWindow, fadePaintWindow); WRAP(fs, s, damageWindowRect, fadeDamageWindowRect); WRAP(fs, s, focusWindow, fadeFocusWindow); WRAP(fs, s, windowResizeNotify, fadeWindowResizeNotify); s->base.privates[fd->screenPrivateIndex].ptr = fs; return TRUE; }
static Bool minInitScreen (CompPlugin *p, CompScreen *s) { MinScreen *ms; MIN_DISPLAY (&display); ms = malloc (sizeof (MinScreen)); if (!ms) return FALSE; ms->windowPrivateIndex = allocateWindowPrivateIndex (s); if (ms->windowPrivateIndex < 0) { free (ms); return FALSE; } ms->moreAdjust = FALSE; const BananaValue * option_shade_resistance = bananaGetOption (bananaIndex, "shade_resistance", s->screenNum); ms->shadeStep = 100 - option_shade_resistance->i + 1; const BananaValue * option_window_match = bananaGetOption (bananaIndex, "window_match", s->screenNum); matchInit (&ms->match); matchAddFromString (&ms->match, option_window_match->s); matchUpdate (&ms->match); WRAP (ms, s, preparePaintScreen, minPreparePaintScreen); WRAP (ms, s, donePaintScreen, minDonePaintScreen); WRAP (ms, s, paintOutput, minPaintOutput); WRAP (ms, s, paintWindow, minPaintWindow); WRAP (ms, s, damageWindowRect, minDamageWindowRect); WRAP (ms, s, focusWindow, minFocusWindow); s->privates[md->screenPrivateIndex].ptr = ms; return TRUE; }
static Bool decorInitScreen (CompPlugin *p, CompScreen *s) { DecorScreen *ds; DECOR_DISPLAY (s->display); ds = malloc (sizeof (DecorScreen)); if (!ds) return FALSE; ds->windowPrivateIndex = allocateWindowPrivateIndex (s); if (ds->windowPrivateIndex < 0) { free (ds); return FALSE; } memset (ds->decor, 0, sizeof (ds->decor)); ds->dmWin = None; ds->decoratorStartHandle = 0; WRAP (ds, s, drawWindow, decorDrawWindow); WRAP (ds, s, damageWindowRect, decorDamageWindowRect); WRAP (ds, s, getOutputExtentsForWindow, decorGetOutputExtentsForWindow); WRAP (ds, s, windowMoveNotify, decorWindowMoveNotify); WRAP (ds, s, windowResizeNotify, decorWindowResizeNotify); WRAP (ds, s, windowStateChangeNotify, decorWindowStateChangeNotify); WRAP (ds, s, addSupportedAtoms, decorAddSupportedAtoms); s->base.privates[dd->screenPrivateIndex].ptr = ds; decorCheckForDmOnScreen (s, FALSE); setSupportedWmHints (s); if (!ds->dmWin) ds->decoratorStartHandle = compAddTimeout (0, -1, decorStartDecorator, s); return TRUE; }
static Bool colorFilterInitScreen (CompPlugin * p, CompScreen * s) { ColorFilterScreen *cfs; FILTER_DISPLAY (s->display); if (!s->fragmentProgram) { compLogMessage ("colorfilter", CompLogLevelFatal, "Fragment program support missing."); return TRUE; } cfs = malloc (sizeof (ColorFilterScreen)); if (!cfs) return FALSE; cfs->windowPrivateIndex = allocateWindowPrivateIndex (s); if (cfs->windowPrivateIndex < 0) { free (cfs); return FALSE; } cfs->isFiltered = FALSE; cfs->currentFilter = 0; cfs->filtersLoaded = FALSE; cfs->filtersFunctions = NULL; cfs->filtersCount = 0; colorfilterSetFilterMatchNotify (s, colorFilterMatchsChanged); colorfilterSetExcludeMatchNotify (s, colorFilterExcludeMatchsChanged); colorfilterSetFiltersNotify (s, colorFiltersChanged); colorfilterSetFilterDecorationsNotify (s, colorFilterDamageDecorations); WRAP (cfs, s, drawWindowTexture, colorFilterDrawWindowTexture); s->base.privates[cfd->screenPrivateIndex].ptr = cfs; return TRUE; }
static Bool opacifyInitScreen (CompPlugin *p, CompScreen *s) { OpacifyScreen *os; OPACIFY_DISPLAY (&display); os = malloc (sizeof (OpacifyScreen)); if (!os) return FALSE; os->windowPrivateIndex = allocateWindowPrivateIndex (s); if (os->windowPrivateIndex < 0) { free (os); return FALSE; } WRAP (os, s, paintWindow, opacifyPaintWindow); const BananaValue * option_window_match = bananaGetOption (bananaIndex, "window_match", s->screenNum); matchInit (&os->window_match); matchAddFromString (&os->window_match, option_window_match->s); matchUpdate (&os->window_match); s->privates[od->screenPrivateIndex].ptr = os; os->intersect = XCreateRegion (); os->justMoved = FALSE; os->passiveNum = 0; os->active = 0; return TRUE; }
static Bool minInitScreen(CompPlugin * p, CompScreen * s) { MinScreen *ms; MIN_DISPLAY(s->display); ms = malloc(sizeof(MinScreen)); if (!ms) return FALSE; if (!compInitScreenOptionsFromMetadata(s, &minMetadata, minScreenOptionInfo, ms->opt, MIN_SCREEN_OPTION_NUM)) { free(ms); return FALSE; } ms->windowPrivateIndex = allocateWindowPrivateIndex(s); if (ms->windowPrivateIndex < 0) { compFiniScreenOptions(s, ms->opt, MIN_SCREEN_OPTION_NUM); free(ms); return FALSE; } ms->moreAdjust = FALSE; ms->shadeStep = ms->opt[MIN_SCREEN_OPTION_SHADE_RESISTANCE].rest.i.max - ms->opt[MIN_SCREEN_OPTION_SHADE_RESISTANCE].value.i + 1; WRAP(ms, s, preparePaintScreen, minPreparePaintScreen); WRAP(ms, s, donePaintScreen, minDonePaintScreen); WRAP(ms, s, paintOutput, minPaintOutput); WRAP(ms, s, paintWindow, minPaintWindow); WRAP(ms, s, damageWindowRect, minDamageWindowRect); WRAP(ms, s, focusWindow, minFocusWindow); s->base.privates[md->screenPrivateIndex].ptr = ms; return TRUE; }
static Bool scaleaddonInitScreen (CompPlugin *p, CompScreen *s) { ScaleAddonScreen *as; ADDON_DISPLAY (s->display); SCALE_SCREEN (s); as = malloc (sizeof (ScaleAddonScreen)); if (!as) return FALSE; as->windowPrivateIndex = allocateWindowPrivateIndex (s); if (as->windowPrivateIndex < 0) { free (as); return FALSE; } as->scale = 1.0f; as->lastState = SCALE_STATE_NONE; WRAP (as, s, donePaintScreen, scaleaddonDonePaintScreen); WRAP (as, ss, scalePaintDecoration, scaleaddonScalePaintDecoration); WRAP (as, ss, selectWindow, scaleaddonSelectWindow); WRAP (as, ss, layoutSlotsAndAssignWindows, scaleaddonLayoutSlotsAndAssignWindows); scaleaddonSetWindowTitleNotify (s, scaleaddonScreenOptionChanged); scaleaddonSetTitleBoldNotify (s, scaleaddonScreenOptionChanged); scaleaddonSetTitleSizeNotify (s, scaleaddonScreenOptionChanged); scaleaddonSetBorderSizeNotify (s, scaleaddonScreenOptionChanged); scaleaddonSetFontColorNotify (s, scaleaddonScreenOptionChanged); scaleaddonSetBackColorNotify (s, scaleaddonScreenOptionChanged); s->base.privates[ad->screenPrivateIndex].ptr = as; return TRUE; }
static Bool NEGInitScreen (CompPlugin *p, CompScreen *s) { NEGScreen *ns; NEG_DISPLAY (s->display); ns = malloc (sizeof (NEGScreen)); if (!ns) return FALSE; ns->windowPrivateIndex = allocateWindowPrivateIndex (s); if (ns->windowPrivateIndex < 0) { free (ns); return FALSE; } /* initialize the screen variables * you know what happens if you don't */ ns->isNeg = FALSE; ns->negFunction = 0; ns->negAlphaFunction = 0; negSetNegMatchNotify (s, NEGScreenOptionChanged); negSetExcludeMatchNotify (s, NEGScreenOptionChanged); /* wrap overloaded functions */ WRAP (ns, s, drawWindowTexture, NEGDrawWindowTexture); s->base.privates[nd->screenPrivateIndex].ptr = ns; return TRUE; }
/* * groupInitScreen * */ static Bool groupInitScreen (CompPlugin *p, CompScreen *s) { GroupScreen *gs; int glowType; GROUP_DISPLAY (&display); gs = malloc (sizeof (GroupScreen)); if (!gs) return FALSE; gs->windowPrivateIndex = allocateWindowPrivateIndex (s); if (gs->windowPrivateIndex < 0) { free (gs); return FALSE; } WRAP (gs, s, windowMoveNotify, groupWindowMoveNotify); WRAP (gs, s, windowResizeNotify, groupWindowResizeNotify); WRAP (gs, s, getOutputExtentsForWindow, groupGetOutputExtentsForWindow); WRAP (gs, s, preparePaintScreen, groupPreparePaintScreen); WRAP (gs, s, paintOutput, groupPaintOutput); WRAP (gs, s, drawWindow, groupDrawWindow); WRAP (gs, s, paintWindow, groupPaintWindow); WRAP (gs, s, paintTransformedOutput, groupPaintTransformedOutput); WRAP (gs, s, donePaintScreen, groupDonePaintScreen); WRAP (gs, s, windowGrabNotify, groupWindowGrabNotify); WRAP (gs, s, windowUngrabNotify, groupWindowUngrabNotify); WRAP (gs, s, damageWindowRect, groupDamageWindowRect); WRAP (gs, s, windowStateChangeNotify, groupWindowStateChangeNotify); WRAP (gs, s, activateWindow, groupActivateWindow); s->privates[gd->screenPrivateIndex].ptr = gs; gs->groups = NULL; gs->tmpSel.windows = NULL; gs->tmpSel.nWins = 0; gs->grabIndex = 0; gs->grabState = ScreenGrabNone; gs->lastHoveredGroup = NULL; gs->queued = FALSE; gs->pendingMoves = NULL; gs->pendingGrabs = NULL; gs->pendingUngrabs = NULL; gs->dequeueTimeoutHandle = 0; gs->draggedSlot = NULL; gs->dragged = FALSE; gs->dragHoverTimeoutHandle = 0; gs->prevX = 0; gs->prevY = 0; gs->showDelayTimeoutHandle = 0; /* one-shot timeout for stuff that needs to be initialized after all screens and windows are initialized */ gs->initialActionsTimeoutHandle = compAddTimeout (0, 0, groupApplyInitialActions, (void *) s); initTexture (s, &gs->glowTexture); const BananaValue * option_glow_type = bananaGetOption (bananaIndex, "glow_type", s->screenNum); glowType = option_glow_type->i; imageDataToTexture (s, &gs->glowTexture, glowTextureProperties[glowType].textureData, glowTextureProperties[glowType].textureSize, glowTextureProperties[glowType].textureSize, GL_RGBA, GL_UNSIGNED_BYTE); const BananaValue * option_window_match = bananaGetOption (bananaIndex, "window_match", s->screenNum); matchInit (&gs->window_match); matchAddFromString (&gs->window_match, option_window_match->s); matchUpdate (&gs->window_match); const BananaValue * option_autotab_windows = bananaGetOption (bananaIndex, "autotab_windows", s->screenNum); gs->autotabCount = option_autotab_windows->list.nItem; gs->autotab = malloc (gs->autotabCount * sizeof (CompMatch)); int i; for (i = 0; i <= gs->autotabCount - 1; i++) { matchInit (&gs->autotab[i]); matchAddFromString (&gs->autotab[i], option_autotab_windows->list.item[i].s); matchUpdate (&gs->autotab[i]); } return TRUE; }
static Bool winrulesInitScreen (CompPlugin *p, CompScreen *s) { WinrulesScreen *ws; WINRULES_DISPLAY (&display); ws = malloc (sizeof (WinrulesScreen)); if (!ws) return FALSE; ws->windowPrivateIndex = allocateWindowPrivateIndex (s); if (ws->windowPrivateIndex < 0) { free (ws); return FALSE; } WRAP (ws, s, getAllowedActionsForWindow, winrulesGetAllowedActionsForWindow); const BananaValue * option_skiptaskbar_match = bananaGetOption (bananaIndex, "skiptaskbar_match", s->screenNum); matchInit (&ws->skiptaskbar_match); matchAddFromString (&ws->skiptaskbar_match, option_skiptaskbar_match->s); matchUpdate (&ws->skiptaskbar_match); const BananaValue * option_skippager_match = bananaGetOption (bananaIndex, "skippager_match", s->screenNum); matchInit (&ws->skippager_match); matchAddFromString (&ws->skippager_match, option_skippager_match->s); matchUpdate (&ws->skippager_match); const BananaValue * option_above_match = bananaGetOption (bananaIndex, "above_match", s->screenNum); matchInit (&ws->above_match); matchAddFromString (&ws->above_match, option_above_match->s); matchUpdate (&ws->above_match); const BananaValue * option_below_match = bananaGetOption (bananaIndex, "below_match", s->screenNum); matchInit (&ws->below_match); matchAddFromString (&ws->below_match, option_below_match->s); matchUpdate (&ws->below_match); const BananaValue * option_sticky_match = bananaGetOption (bananaIndex, "sticky_match", s->screenNum); matchInit (&ws->sticky_match); matchAddFromString (&ws->sticky_match, option_sticky_match->s); matchUpdate (&ws->sticky_match); const BananaValue * option_fullscreen_match = bananaGetOption (bananaIndex, "fullscreen_match", s->screenNum); matchInit (&ws->fullscreen_match); matchAddFromString (&ws->fullscreen_match, option_fullscreen_match->s); matchUpdate (&ws->fullscreen_match); const BananaValue * option_maximize_match = bananaGetOption (bananaIndex, "maximize_match", s->screenNum); matchInit (&ws->maximize_match); matchAddFromString (&ws->maximize_match, option_maximize_match->s); matchUpdate (&ws->maximize_match); const BananaValue * option_no_argb_match = bananaGetOption (bananaIndex, "no_argb_match", s->screenNum); matchInit (&ws->no_argb_match); matchAddFromString (&ws->no_argb_match, option_no_argb_match->s); matchUpdate (&ws->no_argb_match); const BananaValue * option_no_move_match = bananaGetOption (bananaIndex, "no_move_match", s->screenNum); matchInit (&ws->no_move_match); matchAddFromString (&ws->no_move_match, option_no_move_match->s); matchUpdate (&ws->no_move_match); const BananaValue * option_no_resize_match = bananaGetOption (bananaIndex, "no_resize_match", s->screenNum); matchInit (&ws->no_resize_match); matchAddFromString (&ws->no_resize_match, option_no_resize_match->s); matchUpdate (&ws->no_resize_match); const BananaValue * option_no_minimize_match = bananaGetOption (bananaIndex, "no_minimize_match", s->screenNum); matchInit (&ws->no_minimize_match); matchAddFromString (&ws->no_minimize_match, option_no_minimize_match->s); matchUpdate (&ws->no_minimize_match); const BananaValue * option_no_maximize_match = bananaGetOption (bananaIndex, "no_maximize_match", s->screenNum); matchInit (&ws->no_maximize_match); matchAddFromString (&ws->no_maximize_match, option_no_maximize_match->s); matchUpdate (&ws->no_maximize_match); const BananaValue * option_no_close_match = bananaGetOption (bananaIndex, "no_close_match", s->screenNum); matchInit (&ws->no_close_match); matchAddFromString (&ws->no_close_match, option_no_close_match->s); matchUpdate (&ws->no_close_match); const BananaValue * option_no_focus_match = bananaGetOption (bananaIndex, "no_focus_match", s->screenNum); matchInit (&ws->no_focus_match); matchAddFromString (&ws->no_focus_match, option_no_focus_match->s); matchUpdate (&ws->no_focus_match); const BananaValue * option_size_matches = bananaGetOption (bananaIndex, "size_matches", s->screenNum); ws->size_matches_count = option_size_matches->list.nItem; int i; for (i = 0; i < option_size_matches->list.nItem; i++) { matchInit (&ws->size_matches[i]); matchAddFromString (&ws->size_matches[i], option_size_matches->list.item[i].s); matchUpdate (&ws->size_matches[i]); } s->privates[wd->screenPrivateIndex].ptr = ws; return TRUE; }