← Back to branch summary

~vanvugt/compiz-plugins-main/fix-915236

« back to all changes in this revision

Viewing changes to neg/src/neg.cpp

  • Committer: Sam Spilsbury
  • Date: 2011-08-12 06:36:10 UTC
  • Revision ID: sam.spilsbury@canonical.com-20110812063610-8mcxo2xohctyp2ak
Sync - Remove Plugins

Show diffs side-by-side

added added

removed removed

Lines of Context:
neg/src/neg.cpp
1
 
/*
2
 
 * Copyright (c) 2006 Darryll Truchan <moppsy@comcast.net>
3
 
 *
4
 
 * Pixel shader negating by Dennis Kasprzyk <onestone@beryl-project.org>
5
 
 * Usage of matches by Danny Baumann <maniac@beryl-project.org>
6
 
 *
7
 
 * This program is free software; you can redistribute it and/or
8
 
 * modify it under the terms of the GNU General Public License
9
 
 * as published by the Free Software Foundation; either version 2
10
 
 * of the License, or (at your option) any later version.
11
 
 *
12
 
 * This program is distributed in the hope that it will be useful,
13
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
 
 * GNU General Public License for more details.
16
 
 *
17
 
 * You should have received a copy of the GNU General Public License
18
 
 * along with this program; if not, write to the Free Software
19
 
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
20
 
 *
21
 
 */
22
 
 
23
 
#include "neg.h"
24
 
 
25
 
using namespace GLFragment;
26
 
 
27
 
COMPIZ_PLUGIN_20090315 (neg, NegPluginVTable);
28
 
 
29
 
void
30
 
NegWindow::toggle ()
31
 
{
32
 
    NEG_SCREEN (screen);
33
 
 
34
 
    /* toggle window negative flag */
35
 
    isNeg = !isNeg;
36
 
 
37
 
    /* check exclude list */
38
 
    if (ns->optionGetExcludeMatch ().evaluate (window))
39
 
        isNeg = false;
40
 
 
41
 
    /* cause repainting */
42
 
    cWindow->addDamage ();
43
 
 
44
 
    if (isNeg)
45
 
        gWindow->glDrawTextureSetEnabled (this, true);
46
 
    else
47
 
        gWindow->glDrawTextureSetEnabled (this, false);
48
 
}
49
 
 
50
 
bool
51
 
NegScreen::toggle (CompAction         *action,
52
 
                   CompAction::State  state,
53
 
                   CompOption::Vector options,
54
 
                   bool               all)
55
 
{
56
 
    if (all)
57
 
    {
58
 
        foreach (CompWindow *w, screen->windows ())
59
 
            NegWindow::get (w)->toggle ();
60
 
        /* toggle screen negative flag */
61
 
        isNeg = !isNeg;
62
 
    }
63
 
    else
64
 
    {
65
 
        Window     xid;
66
 
        CompWindow *w;
67
 
 
68
 
        xid = CompOption::getIntOptionNamed (options, "window");
69
 
        w   = screen->findWindow (xid);
70
 
        if (w)
71
 
            NegWindow::get (w)->toggle ();
72
 
    }
73
 
 
74
 
    return true;
75
 
}
76
 
 
77
 
int
78
 
NegScreen::getFragmentFunction (GLTexture *texture,
79
 
                                bool      alpha)
80
 
{
81
 
    int handle = 0;
82
 
 
83
 
    if (alpha && negAlphaFunction)
84
 
        handle = negAlphaFunction;
85
 
    else if (!alpha && negFunction)
86
 
        handle = negFunction;
87
 
 
88
 
    if (!handle)
89
 
    {
90
 
        FunctionData data;
91
 
        int          target;
92
 
 
93
 
        if (alpha)
94
 
            data.addTempHeaderOp ("neg");
95
 
 
96
 
        if (texture->target () == GL_TEXTURE_2D)
97
 
            target = COMP_FETCH_TARGET_2D;
98
 
        else
99
 
            target = COMP_FETCH_TARGET_RECT;
100
 
 
101
 
        data.addFetchOp ("output", NULL, target);
102
 
 
103
 
        if (alpha)
104
 
        {
105
 
            data.addDataOp ("RCP neg.a, output.a;");
106
 
            data.addDataOp ("MAD output.rgb, -neg.a, output, 1.0;");
107
 
        }
108
 
        else
109
 
            data.addDataOp ("SUB output.rgb, 1.0, output;");
110
 
 
111
 
        if (alpha)
112
 
            data.addDataOp ("MUL output.rgb, output.a, output;");
113
 
 
114
 
        data.addColorOp ("output", "output");
115
 
 
116
 
        if (!data.status ())
117
 
            return 0;
118
 
 
119
 
        handle = data.createFragmentFunction ("neg");
120
 
 
121
 
        if (alpha)
122
 
            negAlphaFunction = handle;
123
 
        else
124
 
            negFunction = handle;
125
 
    }
126
 
 
127
 
    return handle;
128
 
}
129
 
 
130
 
void
131
 
NegWindow::glDrawTexture (GLTexture          *texture,
132
 
                          GLFragment::Attrib &attrib,
133
 
                          unsigned int       mask)
134
 
{
135
 
    GLTexture::Filter filter;
136
 
    bool              doNeg = false;
137
 
    GLTexture         *tex = NULL;
138
 
 
139
 
    NEG_SCREEN (screen);
140
 
 
141
 
    if (isNeg)
142
 
    {
143
 
        if (ns->optionGetNegDecorations ())
144
 
        {
145
 
            doNeg = true;
146
 
            tex   = texture;
147
 
        }
148
 
        else
149
 
        {
150
 
            doNeg = false;
151
 
            for (unsigned int i = 0; i < gWindow->textures ().size (); i++)
152
 
            {
153
 
                tex = gWindow->textures ()[i];
154
 
                doNeg = (texture->name () == tex->name ());
155
 
                if (doNeg)
156
 
                    break;
157
 
            }
158
 
        }
159
 
    }
160
 
 
161
 
    if (doNeg && tex)
162
 
    {
163
 
        /* Fragment program negation */
164
 
        if (GL::fragmentProgram)
165
 
        {
166
 
            GLFragment::Attrib fa = attrib;
167
 
            int                function;
168
 
            bool               alpha = true;
169
 
 
170
 
            if (texture->name () == tex->name ()) /* Not a decoration */
171
 
                alpha = window->alpha ();
172
 
 
173
 
            function = ns->getFragmentFunction (texture, alpha);
174
 
            if (function)
175
 
                fa.addFunction (function);
176
 
 
177
 
            gWindow->glDrawTexture (texture, fa, mask);
178
 
        }
179
 
        else /* Texture manipulation negation */
180
 
        {
181
 
            /* this is for the most part taken from paint.c */
182
 
 
183
 
            if (mask & PAINT_WINDOW_TRANSFORMED_MASK)
184
 
                filter = ns->gScreen->filter (WINDOW_TRANS_FILTER);
185
 
            else if (mask & PAINT_WINDOW_ON_TRANSFORMED_SCREEN_MASK)
186
 
                filter = ns->gScreen->filter (SCREEN_TRANS_FILTER);
187
 
            else
188
 
                filter = ns->gScreen->filter (NOTHING_TRANS_FILTER);
189
 
 
190
 
            /* if we can adjust saturation, even if it's just on and off */
191
 
            if (GL::canDoSaturated && attrib.getSaturation () != COLOR)
192
 
            {
193
 
                GLfloat constant[4];
194
 
 
195
 
                /* if the paint mask has this set we want to blend */
196
 
                if (mask & PAINT_WINDOW_TRANSLUCENT_MASK)
197
 
                    glEnable (GL_BLEND);
198
 
 
199
 
                /* enable the texture */
200
 
                texture->enable (filter);
201
 
 
202
 
                /* texture combiner */
203
 
                glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
204
 
                glTexEnvf (GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE);
205
 
                glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE);
206
 
                glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_PRIMARY_COLOR);
207
 
                glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE2_RGB, GL_PRIMARY_COLOR);
208
 
 
209
 
                /* negate */
210
 
                glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND0_RGB,
211
 
                           GL_ONE_MINUS_SRC_COLOR);
212
 
 
213
 
                glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
214
 
                glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND2_RGB, GL_SRC_ALPHA);
215
 
 
216
 
                glTexEnvf (GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
217
 
                glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_TEXTURE);
218
 
                glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
219
 
 
220
 
                glColor4f (1.0f, 1.0f, 1.0f, 0.5f);
221
 
 
222
 
                /* make another texture active */
223
 
                GL::activeTexture (GL_TEXTURE1_ARB);
224
 
 
225
 
                /* enable that texture */
226
 
                texture->enable (filter);
227
 
 
228
 
                glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
229
 
                glTexEnvf (GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_DOT3_RGB);
230
 
                glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PREVIOUS);
231
 
                glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_CONSTANT);
232
 
                glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
233
 
                glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
234
 
 
235
 
                /* if we can do saturation that is in between min and max */
236
 
                if (GL::canDoSlightlySaturated && attrib.getSaturation () > 0)
237
 
                {
238
 
                    glTexEnvf (GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
239
 
                    glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_PREVIOUS);
240
 
                    glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
241
 
 
242
 
                    constant[0] = 0.5f + 0.5f * RED_SATURATION_WEIGHT;
243
 
                    constant[1] = 0.5f + 0.5f * GREEN_SATURATION_WEIGHT;
244
 
                    constant[2] = 0.5f + 0.5f * BLUE_SATURATION_WEIGHT;
245
 
                    constant[3] = 1.0;
246
 
 
247
 
                    glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, constant);
248
 
 
249
 
                    /* make another texture active */
250
 
                    GL::activeTexture (GL_TEXTURE2_ARB);
251
 
 
252
 
                    /* enable that texture */
253
 
                    texture->enable (filter);
254
 
 
255
 
                    glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
256
 
                    glTexEnvf (GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE);
257
 
                    glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE0);
258
 
                    glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_PREVIOUS);
259
 
                    glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE2_RGB, GL_CONSTANT);
260
 
 
261
 
                    /* negate */
262
 
                    glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND0_RGB,
263
 
                               GL_ONE_MINUS_SRC_COLOR);
264
 
 
265
 
                    glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
266
 
                    glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND2_RGB, GL_SRC_ALPHA);
267
 
 
268
 
                    glTexEnvf (GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
269
 
                    glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_PREVIOUS);
270
 
                    glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
271
 
 
272
 
                    /* color constant */
273
 
                    constant[3] = attrib.getSaturation () / 65535.0f;
274
 
 
275
 
                    glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, constant);
276
 
 
277
 
                    /* if we are not opaque or not fully bright */
278
 
                    if (attrib.getOpacity () < OPAQUE ||
279
 
                        attrib.getBrightness () != BRIGHT)
280
 
                    {
281
 
                        /* make another texture active */
282
 
                        GL::activeTexture (GL_TEXTURE3_ARB);
283
 
 
284
 
                        /* enable that texture */
285
 
                        texture->enable (filter);
286
 
 
287
 
                        /* color constant */
288
 
                        constant[3] = attrib.getOpacity () / 65535.0f;
289
 
                        constant[0] = constant[1] = constant[2] =
290
 
                            constant[3] * attrib.getBrightness () / 65535.0f;
291
 
 
292
 
                        glTexEnvfv(GL_TEXTURE_ENV,
293
 
                                   GL_TEXTURE_ENV_COLOR, constant);
294
 
 
295
 
                        glTexEnvf(GL_TEXTURE_ENV,
296
 
                                  GL_TEXTURE_ENV_MODE, GL_COMBINE);
297
 
 
298
 
                        glTexEnvf (GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE);
299
 
                        glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PREVIOUS);
300
 
                        glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_CONSTANT);
301
 
                        glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND0_RGB,
302
 
                                   GL_SRC_COLOR);
303
 
                        glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND1_RGB,
304
 
                                   GL_SRC_COLOR);
305
 
 
306
 
                        glTexEnvf (GL_TEXTURE_ENV,
307
 
                                   GL_COMBINE_ALPHA, GL_MODULATE);
308
 
                        glTexEnvf(GL_TEXTURE_ENV,
309
 
                                  GL_SOURCE0_ALPHA, GL_PREVIOUS);
310
 
                        glTexEnvf(GL_TEXTURE_ENV,
311
 
                                  GL_SOURCE1_ALPHA, GL_CONSTANT);
312
 
                        glTexEnvf(GL_TEXTURE_ENV,
313
 
                                  GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
314
 
                        glTexEnvf(GL_TEXTURE_ENV,
315
 
                                  GL_OPERAND1_ALPHA, GL_SRC_ALPHA);
316
 
 
317
 
                        /* draw the window geometry */
318
 
                        gWindow->glDrawGeometry ();
319
 
 
320
 
                        /* disable the current texture */
321
 
                        texture->disable ();
322
 
 
323
 
                        /* set texture mode back to replace */
324
 
                        glTexEnvi (GL_TEXTURE_ENV,
325
 
                                   GL_TEXTURE_ENV_MODE, GL_REPLACE);
326
 
 
327
 
                        /* re-activate last texture */
328
 
                        GL::activeTexture (GL_TEXTURE2_ARB);
329
 
                    }
330
 
                    else
331
 
                    {
332
 
                        /* fully opaque and bright */
333
 
 
334
 
                        /* draw the window geometry */
335
 
                        gWindow->glDrawGeometry ();
336
 
                    }
337
 
 
338
 
                    /* disable the current texture */
339
 
                    texture->disable ();
340
 
 
341
 
                    /* set the texture mode back to replace */
342
 
                    glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
343
 
 
344
 
                    /* re-activate last texture */
345
 
                    GL::activeTexture (GL_TEXTURE1_ARB);
346
 
                }
347
 
                else
348
 
                {
349
 
                    /* fully saturated or fully unsaturated */
350
 
 
351
 
                    glTexEnvf (GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_MODULATE);
352
 
                    glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_PREVIOUS);
353
 
                    glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE1_ALPHA, GL_CONSTANT);
354
 
                    glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
355
 
                    glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA);
356
 
 
357
 
                    /* color constant */
358
 
                    constant[3] = attrib.getOpacity () / 65535.0f;
359
 
                    constant[0] = constant[1] = constant[2] =
360
 
                        constant[3] * attrib.getBrightness () / 65535.0f;
361
 
 
362
 
                    constant[0] =
363
 
                        0.5f + 0.5f * RED_SATURATION_WEIGHT * constant[0];
364
 
                    constant[1] =
365
 
                        0.5f + 0.5f * GREEN_SATURATION_WEIGHT * constant[1];
366
 
                    constant[2] =
367
 
                        0.5f + 0.5f * BLUE_SATURATION_WEIGHT * constant[2];
368
 
 
369
 
                    glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, constant);
370
 
 
371
 
                    /* draw the window geometry */
372
 
                    gWindow->glDrawGeometry ();
373
 
                }
374
 
 
375
 
                /* disable the current texture */
376
 
                texture->disable ();
377
 
 
378
 
                /* set the texture mode back to replace */
379
 
                glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
380
 
 
381
 
                /* re-activate last texture */
382
 
                GL::activeTexture (GL_TEXTURE0_ARB);
383
 
 
384
 
                /* disable that texture */
385
 
                texture->disable ();
386
 
 
387
 
                /* set the default color */
388
 
                glColor4usv (defaultColor);
389
 
 
390
 
                /* set screens texture mode back to replace */
391
 
                ns->gScreen->setTexEnvMode (GL_REPLACE);
392
 
 
393
 
                /* if it's a translucent window, disable blending */
394
 
                if (mask & PAINT_WINDOW_TRANSLUCENT_MASK)
395
 
                    glDisable (GL_BLEND);
396
 
            }
397
 
            else
398
 
            {
399
 
                /* no saturation adjustments */
400
 
 
401
 
                /* enable the current texture */
402
 
                texture->enable (filter);
403
 
 
404
 
                glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
405
 
                glTexEnvf (GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_REPLACE);
406
 
                glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE);
407
 
 
408
 
                /* negate */
409
 
                glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND0_RGB,
410
 
                          GL_ONE_MINUS_SRC_COLOR);
411
 
 
412
 
                /* we are not opaque or fully bright */
413
 
                if ((mask & PAINT_WINDOW_TRANSLUCENT_MASK) ||
414
 
                    attrib.getBrightness () != BRIGHT)
415
 
                {
416
 
                    GLfloat constant[4];
417
 
 
418
 
                    /* enable blending */
419
 
                    glEnable (GL_BLEND);
420
 
 
421
 
                    /* color constant */
422
 
                    constant[3] = attrib.getOpacity () / 65535.0f;
423
 
                    constant[0] = constant[1] = constant[2] =
424
 
                        constant[3] * attrib.getBrightness () / 65535.0f;
425
 
 
426
 
                    glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, constant);
427
 
                    glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
428
 
                    glTexEnvf (GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE);
429
 
                    glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE);
430
 
                    glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_CONSTANT);
431
 
 
432
 
                    /* negate */
433
 
                    glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND0_RGB,
434
 
                               GL_ONE_MINUS_SRC_COLOR);
435
 
 
436
 
                    glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
437
 
                    glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
438
 
                    glTexEnvf (GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_MODULATE);
439
 
                    glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_TEXTURE);
440
 
                    glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE1_ALPHA, GL_CONSTANT);
441
 
                    glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
442
 
                    glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA);
443
 
 
444
 
                    /* draw the window geometry */
445
 
                    gWindow->glDrawGeometry ();
446
 
 
447
 
                    /* disable blending */
448
 
                    glDisable (GL_BLEND);
449
 
                }
450
 
                else
451
 
                {
452
 
                    /* no adjustments to saturation, brightness or opacity */
453
 
 
454
 
                    /* draw the window geometry */
455
 
                    gWindow->glDrawGeometry ();
456
 
                }
457
 
 
458
 
                /* disable the current texture */
459
 
                texture->disable ();
460
 
 
461
 
                /* set the screens texture mode back to replace */
462
 
                ns->gScreen->setTexEnvMode (GL_REPLACE);
463
 
            }
464
 
        }
465
 
    }
466
 
    else
467
 
    {
468
 
        /* not negative */
469
 
        gWindow->glDrawTexture (texture, attrib, mask);
470
 
    }
471
 
}
472
 
 
473
 
void
474
 
NegScreen::optionChanged (CompOption          *opt,
475
 
                          NegOptions::Options num)
476
 
{
477
 
    switch (num)
478
 
    {
479
 
    case NegOptions::NegMatch:
480
 
    case NegOptions::ExcludeMatch:
481
 
        {
482
 
            foreach (CompWindow *w, screen->windows ())
483
 
            {
484
 
                bool isNowNeg;
485
 
                NEG_WINDOW (w);
486
 
 
487
 
                isNowNeg = optionGetNegMatch ().evaluate (w);
488
 
                isNowNeg = isNowNeg && !optionGetExcludeMatch ().evaluate (w);
489
 
 
490
 
                if (isNowNeg && isNeg && !nw->isNeg)
491
 
                    nw->toggle ();
492
 
                else if (!isNowNeg && nw->isNeg)
493
 
                    nw->toggle ();
494
 
            }
495
 
        }
496
 
        break;
497
 
        case NegOptions::NegDecorations:
498
 
        {
499
 
                foreach (CompWindow *w, screen->windows ())
500
 
                        if (NegWindow::get (w)->isNeg)
501
 
                                NegWindow::get (w)->cWindow->addDamage ();
502
 
        }
503
 
    default:
504
 
        break;
505
 
    }
506
 
}
507
 
 
508
 
NegScreen::NegScreen (CompScreen *screen) :
509
 
    PluginClassHandler <NegScreen, CompScreen> (screen),
510
 
    NegOptions (),
511
 
    negFunction (0),
512
 
    negAlphaFunction (0),
513
 
    isNeg (false),
514
 
    gScreen (GLScreen::get (screen))
515
 
{
516
 
    optionSetWindowToggleKeyInitiate (boost::bind (&NegScreen::toggle, this,
517
 
                                                   _1, _2, _3,
518
 
                                                   false));
519
 
    optionSetScreenToggleKeyInitiate (boost::bind (&NegScreen::toggle, this,
520
 
                                                   _1, _2, _3,
521
 
                                                   true));
522
 
 
523
 
    optionSetNegMatchNotify (boost::bind (&NegScreen::optionChanged, this,
524
 
                                          _1, _2));
525
 
    optionSetExcludeMatchNotify (boost::bind (&NegScreen::optionChanged, this,
526
 
                                              _1, _2));
527
 
        optionSetNegDecorationsNotify (boost::bind (&NegScreen::optionChanged, this,
528
 
                                          _1, _2));
529
 
 
530
 
}
531
 
 
532
 
void
533
 
NegWindow::postLoad ()
534
 
{
535
 
    if (isNeg)
536
 
    {
537
 
        cWindow->addDamage ();
538
 
        gWindow->glDrawTextureSetEnabled (this, true);
539
 
    }
540
 
}
541
 
        
542
 
 
543
 
NegWindow::NegWindow (CompWindow *window) :
544
 
    PluginClassHandler <NegWindow, CompWindow> (window),
545
 
    PluginStateWriter <NegWindow> (this, window->id ()),
546
 
    window (window),
547
 
    cWindow (CompositeWindow::get (window)),
548
 
    gWindow (GLWindow::get (window)),
549
 
    isNeg (0)
550
 
{
551
 
    GLWindowInterface::setHandler (gWindow, false);
552
 
 
553
 
    NEG_SCREEN (screen);
554
 
 
555
 
    /* Taken from ObjectAdd, since there is no equavilent
556
 
     * we check for screenNeg == true in ctor */
557
 
 
558
 
    if (ns->isNeg && ns->optionGetNegMatch ().evaluate (window))
559
 
        toggle ();
560
 
}
561
 
 
562
 
NegWindow::~NegWindow ()
563
 
{
564
 
    writeSerializedData ();
565
 
}
566
 
 
567
 
bool
568
 
NegPluginVTable::init ()
569
 
{
570
 
    if (!CompPlugin::checkPluginABI ("core", CORE_ABIVERSION) ||
571
 
        !CompPlugin::checkPluginABI ("composite", COMPIZ_COMPOSITE_ABI) ||
572
 
        !CompPlugin::checkPluginABI ("opengl", COMPIZ_OPENGL_ABI))
573
 
        return false;
574
 
 
575
 
    return true;
576
 
}