← Back to branch summary

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

« back to all changes in this revision

Viewing changes to kdecompat/src/kdecompat.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:
kdecompat/src/kdecompat.cpp
1
 
/*
2
 
 *
3
 
 * Compiz KDE compatibility plugin
4
 
 *
5
 
 * kdecompat.cpp
6
 
 *
7
 
 * Copyright : (C) 2007 by Danny Baumann
8
 
 * E-mail    : maniac@opencompositing.org
9
 
 *
10
 
 * Based on scale.c and switcher.c:
11
 
 * Copyright : (C) 2007 David Reveman
12
 
 * E-mail    : davidr@novell.com
13
 
 *
14
 
 * This program is free software; you can redistribute it and/or
15
 
 * modify it under the terms of the GNU General Public License
16
 
 * as published by the Free Software Foundation; either version 2
17
 
 * of the License, or (at your option) any later version.
18
 
 *
19
 
 * This program is distributed in the hope that it will be useful,
20
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22
 
 * GNU General Public License for more details.
23
 
 *
24
 
 */
25
 
 
26
 
#include "kdecompat.h"
27
 
#include <sstream>
28
 
 
29
 
COMPIZ_PLUGIN_20090315 (kdecompat, KDECompatPluginVTable);
30
 
 
31
 
inline void
32
 
KDECompatScreen::checkPaintFunctions ()
33
 
{
34
 
    bool enabled = false;
35
 
 
36
 
    foreach (CompWindow *w, screen->windows ())
37
 
    {
38
 
        KDECompatWindow *kcw = KDECompatWindow::get (w);
39
 
        bool    wEnabled = (kcw->mPreviews.size () || kcw->mIsPreview ||
40
 
                             (kcw->mSlideData &&
41
 
                              kcw->mSlideData->remaining > 0.0));
42
 
        enabled |= wEnabled;
43
 
 
44
 
        kcw->gWindow->glPaintSetEnabled (kcw, wEnabled);
45
 
        kcw->cWindow->damageRectSetEnabled (kcw, wEnabled);
46
 
    }   
47
 
  
48
 
    KDECOMPAT_SCREEN (screen);
49
 
  
50
 
    gScreen->glPaintOutputSetEnabled (ks, enabled);
51
 
    cScreen->donePaintSetEnabled (ks, enabled);
52
 
    cScreen->preparePaintSetEnabled (ks, enabled);
53
 
}
54
 
 
55
 
void
56
 
KDECompatWindow::stopCloseAnimation ()
57
 
{
58
 
    while (mUnmapCnt)
59
 
    {
60
 
        window->unmap ();
61
 
        mUnmapCnt--;
62
 
    }
63
 
 
64
 
    while (mDestroyCnt)
65
 
    {
66
 
        window->destroy ();
67
 
        mDestroyCnt--;
68
 
    }
69
 
}
70
 
 
71
 
void
72
 
KDECompatWindow::sendSlideEvent (bool start)
73
 
{
74
 
    CompOption::Vector o (2);
75
 
 
76
 
    o[0] = CompOption ("window", CompOption::TypeInt);
77
 
    o[0].value ().set ((int) window->id ());
78
 
 
79
 
    o[1] = CompOption ("active", CompOption::TypeBool);
80
 
    o[1].value ().set (start);
81
 
 
82
 
    screen->handleCompizEvent ("kdecompat", "slide", o);
83
 
}
84
 
 
85
 
void
86
 
KDECompatWindow::startSlideAnimation (bool appearing)
87
 
{
88
 
    if (!mSlideData)
89
 
        return;
90
 
 
91
 
    KDECOMPAT_SCREEN (screen);
92
 
    
93
 
    if (appearing)
94
 
        mSlideData->duration = ks->optionGetSlideInDuration ();
95
 
    else
96
 
        mSlideData->duration = ks->optionGetSlideOutDuration ();
97
 
 
98
 
    if (mSlideData->remaining > mSlideData->duration)
99
 
        mSlideData->remaining = mSlideData->duration;
100
 
    else
101
 
        mSlideData->remaining = mSlideData->duration - mSlideData->remaining;
102
 
 
103
 
    mSlideData->appearing = appearing;
104
 
    ks->mHasSlidingPopups = true;
105
 
 
106
 
    ks->checkPaintFunctions ();
107
 
    
108
 
    cWindow->addDamage ();
109
 
    sendSlideEvent (true);
110
 
}
111
 
 
112
 
void
113
 
KDECompatWindow::endSlideAnimation ()
114
 
{
115
 
    if (mSlideData)
116
 
    {
117
 
        mSlideData->remaining = 0;
118
 
        stopCloseAnimation ();
119
 
        sendSlideEvent (false);
120
 
    }
121
 
 
122
 
   KDECompatScreen::get (screen)->checkPaintFunctions ();
123
 
}
124
 
 
125
 
void
126
 
KDECompatScreen::preparePaint (int msSinceLastPaint)
127
 
{
128
 
    if (mHasSlidingPopups)
129
 
    {
130
 
        foreach (CompWindow *w, screen->windows ())
131
 
        {
132
 
            KDECOMPAT_WINDOW (w);
133
 
 
134
 
            if (!kw->mSlideData)
135
 
                continue;
136
 
 
137
 
            kw->mSlideData->remaining -= msSinceLastPaint;
138
 
 
139
 
            if (kw->mSlideData->remaining <= 0)
140
 
                kw->endSlideAnimation ();
141
 
        }
142
 
    }
143
 
 
144
 
    cScreen->preparePaint (msSinceLastPaint);
145
 
}
146
 
 
147
 
bool
148
 
KDECompatScreen::glPaintOutput (const GLScreenPaintAttrib &attrib,
149
 
                                const GLMatrix            &transform,
150
 
                                const CompRegion          &region,
151
 
                                CompOutput                *output,
152
 
                                unsigned int              mask)
153
 
{
154
 
    bool status;
155
 
 
156
 
    if (mHasSlidingPopups)
157
 
        mask |= PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS_MASK;
158
 
 
159
 
    status = gScreen->glPaintOutput (attrib, transform, region, output, mask);
160
 
 
161
 
    return status;
162
 
}
163
 
 
164
 
void
165
 
KDECompatScreen::donePaint ()
166
 
{
167
 
    if (mHasSlidingPopups)
168
 
    {
169
 
        mHasSlidingPopups = false;
170
 
 
171
 
        foreach (CompWindow *w, screen->windows ())
172
 
        {
173
 
            KDECOMPAT_WINDOW (w);
174
 
 
175
 
            if (kw->mSlideData && kw->mSlideData->remaining)
176
 
            {
177
 
                kw->cWindow->addDamage ();
178
 
                mHasSlidingPopups = true;
179
 
            }
180
 
        }
181
 
    }
182
 
 
183
 
    cScreen->donePaint ();
184
 
}
185
 
 
186
 
bool
187
 
KDECompatWindow::glPaint (const GLWindowPaintAttrib &attrib,
188
 
                          const GLMatrix            &transform,
189
 
                          const CompRegion          &region,
190
 
                          unsigned int              mask)
191
 
{
192
 
    bool status = false;
193
 
 
194
 
    KDECOMPAT_SCREEN (screen);
195
 
 
196
 
    if ((!(ks->optionGetPlasmaThumbnails () || mPreviews.empty ()) &&
197
 
        !(mSlideData || mSlideData->remaining)) ||
198
 
        !window->mapNum ()                ||
199
 
        (mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK))
200
 
    {
201
 
        status = gWindow->glPaint (attrib, transform, region, mask);
202
 
        return status;
203
 
    }
204
 
 
205
 
    if (mSlideData && mSlideData->remaining)
206
 
    {
207
 
        GLFragment::Attrib fragment (gWindow->paintAttrib ());
208
 
        GLMatrix           wTransform = transform;
209
 
        SlideData          *data = mSlideData;
210
 
        float              xTranslate = 0, yTranslate = 0, remainder;
211
 
        CompRect           clipBox (window->x (), window->y (),
212
 
                                    window->width (), window->height ());
213
 
 
214
 
        if (mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK)
215
 
            return false;
216
 
 
217
 
        remainder = (float) data->remaining / data->duration;
218
 
        if (!data->appearing)
219
 
            remainder = 1.0 - remainder;
220
 
 
221
 
        switch (data->position) {
222
 
        case East:
223
 
            xTranslate = (data->start - window->x ()) * remainder;
224
 
            clipBox.setWidth (data->start - clipBox.x ());
225
 
            break;
226
 
        case West:
227
 
            xTranslate = (data->start - window->width ()) * remainder;
228
 
            clipBox.setX (data->start);
229
 
            break;
230
 
        case North:
231
 
            yTranslate = (data->start - window->height ()) * remainder;
232
 
            clipBox.setY (data->start);
233
 
            break;
234
 
        case South:
235
 
        default:
236
 
            yTranslate = (data->start - window->y ()) * remainder;
237
 
            clipBox.setHeight (data->start - clipBox.y1 ());
238
 
            break;
239
 
        }
240
 
 
241
 
        status = gWindow->glPaint (attrib, transform, region, mask |
242
 
                                   PAINT_WINDOW_NO_CORE_INSTANCE_MASK);
243
 
 
244
 
        if (window->alpha () || fragment.getOpacity () != OPAQUE)
245
 
            mask |= PAINT_WINDOW_TRANSLUCENT_MASK;
246
 
 
247
 
        wTransform.translate (xTranslate, yTranslate, 0.0f);
248
 
 
249
 
        glPushMatrix ();
250
 
        glLoadMatrixf (wTransform.getMatrix ());
251
 
 
252
 
        glPushAttrib (GL_SCISSOR_BIT);
253
 
        glEnable (GL_SCISSOR_TEST);
254
 
 
255
 
        glScissor (clipBox.x1 (), screen->height () - clipBox.y2 (),
256
 
                   clipBox.width (), clipBox.height ());
257
 
 
258
 
        status = gWindow->glDraw (wTransform, fragment, region,
259
 
                         mask | PAINT_WINDOW_TRANSFORMED_MASK);
260
 
 
261
 
        glDisable (GL_SCISSOR_TEST);
262
 
        glPopAttrib ();
263
 
        glPopMatrix ();
264
 
    }
265
 
 
266
 
    foreach (const Thumb& thumb, mPreviews)
267
 
    {
268
 
        CompWindow     *tw = screen->findWindow (thumb.id);
269
 
        GLWindow       *gtw;
270
 
        const CompRect &rect = thumb.thumb;
271
 
        unsigned int   paintMask = mask | PAINT_WINDOW_TRANSFORMED_MASK;
272
 
        float          xScale = 1.0f, yScale = 1.0f, xTranslate, yTranslate;
273
 
        GLTexture      *icon = NULL;
274
 
 
275
 
        if (!tw)
276
 
            continue;
277
 
 
278
 
        gtw = GLWindow::get (tw);
279
 
 
280
 
        xTranslate = rect.x () + window->x () - tw->x ();
281
 
        yTranslate = rect.y () + window->y () - tw->y ();
282
 
 
283
 
        if (!gtw->textures ().empty ())
284
 
        {
285
 
            unsigned int width, height;
286
 
            
287
 
            width = tw->width () - tw->input ().left + tw->input ().right;
288
 
            height = tw->height () - tw->input ().top + tw->input ().bottom;
289
 
            
290
 
            xScale = (float) rect.width () / width;
291
 
            yScale = (float) rect.height () / height;
292
 
 
293
 
            xTranslate += tw->input ().left * xScale;
294
 
            yTranslate += tw->input ().top * yScale;
295
 
        }
296
 
        else
297
 
        {
298
 
            icon = gWindow->getIcon (256, 256);
299
 
            if (!icon)
300
 
                icon = ks->gScreen->defaultIcon ();
301
 
 
302
 
            if (icon && !icon->name ())
303
 
                icon = NULL;
304
 
 
305
 
            if (icon)
306
 
            {
307
 
                GLTexture::MatrixList matrices (1);
308
 
 
309
 
                paintMask |= PAINT_WINDOW_BLEND_MASK;
310
 
 
311
 
                if (icon->width () >= rect.width () ||
312
 
                    icon->height () >= rect.height ())
313
 
                {
314
 
                    xScale = (float) rect.width () / icon->width ();
315
 
                    yScale = (float) rect.height () / icon->height ();
316
 
 
317
 
                    if (xScale < yScale)
318
 
                        yScale = xScale;
319
 
                    else
320
 
                        xScale = yScale;
321
 
                }
322
 
 
323
 
                xTranslate += rect.width () / 2 -
324
 
                              (icon->width () * xScale / 2);
325
 
                yTranslate += rect.height () / 2 -
326
 
                              (icon->height () * yScale / 2);
327
 
 
328
 
                matrices[0] = icon->matrix ();
329
 
                matrices[0].x0 -= (tw->x () * icon->matrix ().xx);
330
 
                matrices[0].y0 -= (tw->y () * icon->matrix ().yy);
331
 
 
332
 
                gtw->geometry ().reset ();
333
 
                gtw->glAddGeometry (matrices, tw->geometry (), infiniteRegion);
334
 
 
335
 
                if (!gtw->geometry ().vertices)
336
 
                    icon = NULL;
337
 
            }
338
 
        }
339
 
 
340
 
        if (!gtw->textures ().empty () || icon)
341
 
        {
342
 
            GLFragment::Attrib fragment (attrib);
343
 
            GLMatrix           wTransform (transform);
344
 
 
345
 
            if (tw->alpha () || fragment.getOpacity () != OPAQUE)
346
 
                paintMask |= PAINT_WINDOW_TRANSLUCENT_MASK;
347
 
 
348
 
            wTransform.translate (tw->x (), tw->y (), 0.0f);
349
 
            wTransform.scale (xScale, yScale, 1.0f);
350
 
            wTransform.translate (xTranslate / xScale - tw->x (),
351
 
                                  yTranslate / yScale - tw->y (),
352
 
                                  0.0f);
353
 
 
354
 
            glPushMatrix ();
355
 
            glLoadMatrixf (wTransform.getMatrix ());
356
 
 
357
 
            if (!gtw->textures ().empty ())
358
 
                gtw->glDraw (wTransform, fragment,
359
 
                                 infiniteRegion, paintMask);
360
 
            else if (icon)
361
 
                gtw->glDrawTexture (icon, fragment, paintMask);
362
 
 
363
 
            glPopMatrix ();
364
 
        }
365
 
    }
366
 
    
367
 
    if (!status)
368
 
        status = gWindow->glPaint (attrib, transform, region, mask);
369
 
 
370
 
    return status;
371
 
}
372
 
 
373
 
void
374
 
KDECompatWindow::updatePreviews ()
375
 
{
376
 
    Atom            actual;
377
 
    int             result, format;
378
 
    unsigned long   n, left;
379
 
    unsigned char   *propData;
380
 
    unsigned int    oldPreviewsSize;
381
 
 
382
 
    KDECOMPAT_SCREEN (screen);
383
 
 
384
 
    oldPreviewsSize = mPreviews.size ();
385
 
 
386
 
    mPreviews.clear ();
387
 
 
388
 
    result = XGetWindowProperty (screen->dpy (), window->id (),
389
 
                                 ks->mKdePreviewAtom, 0,
390
 
                                 32768, false, AnyPropertyType, &actual,
391
 
                                 &format, &n, &left, &propData);
392
 
 
393
 
    if (result == Success && propData)
394
 
    {
395
 
        if (format == 32 && actual == ks->mKdePreviewAtom)
396
 
        {
397
 
            long         *data    = (long *) propData;
398
 
            unsigned int nPreview = *data++;
399
 
 
400
 
            if (n == (6 * nPreview + 1))
401
 
            {
402
 
                while (mPreviews.size () < nPreview)
403
 
                {
404
 
                    Thumb t;
405
 
 
406
 
                    if (*data++ != 5)
407
 
                        break;
408
 
 
409
 
                    t.id = *data++;
410
 
                    t.thumb.setX (*data++);
411
 
                    t.thumb.setY (*data++);
412
 
                    t.thumb.setWidth (*data++);
413
 
                    t.thumb.setHeight (*data++);
414
 
 
415
 
                    mPreviews.push_back (t);
416
 
                }
417
 
            }
418
 
        }
419
 
 
420
 
        XFree (propData);
421
 
    }
422
 
    
423
 
    if (oldPreviewsSize != mPreviews.size ())
424
 
        cWindow->damageOutputExtents ();
425
 
 
426
 
    foreach (CompWindow *cw, screen->windows ())
427
 
    {
428
 
        CompWindow      *rw;
429
 
        KDECompatWindow *kcw = KDECompatWindow::get (cw);
430
 
 
431
 
        kcw->mIsPreview = false;
432
 
 
433
 
        foreach (rw, screen->windows ())
434
 
        {
435
 
            KDECompatWindow *krw = KDECompatWindow::get (rw);
436
 
 
437
 
            foreach (const Thumb& t, krw->mPreviews)
438
 
            {
439
 
                if (t.id == cw->id ())
440
 
                {
441
 
                    kcw->mIsPreview = true;
442
 
                    break;
443
 
                }
444
 
            }
445
 
 
446
 
            if (kcw->mIsPreview)
447
 
                break;
448
 
        }
449
 
        
450
 
        ks->checkPaintFunctions ();
451
 
    }
452
 
}
453
 
 
454
 
void
455
 
KDECompatWindow::updateSlidePosition ()
456
 
{
457
 
    Atom          actual;
458
 
    int           result, format;
459
 
    unsigned long n, left;
460
 
    unsigned char *propData;
461
 
 
462
 
    KDECOMPAT_SCREEN (screen);
463
 
 
464
 
    if (mSlideData)
465
 
    {
466
 
        delete mSlideData;
467
 
        mSlideData = NULL;
468
 
    }
469
 
 
470
 
    result = XGetWindowProperty (screen->dpy (), window->id (),
471
 
                                 ks->mKdeSlideAtom, 0, 32768, false,
472
 
                                 AnyPropertyType, &actual, &format, &n,
473
 
                                 &left, &propData);
474
 
 
475
 
    if (result == Success && propData)
476
 
    {
477
 
        if (format == 32 && actual == ks->mKdeSlideAtom && n == 2)
478
 
        {
479
 
            long *data = (long *) propData;
480
 
 
481
 
            mSlideData = new SlideData;
482
 
            if (mSlideData)
483
 
            {
484
 
                mSlideData->remaining = 0;
485
 
                mSlideData->start     = data[0];
486
 
                mSlideData->position  = (KDECompatWindow::SlidePosition) data[1];
487
 
            }
488
 
        }
489
 
        
490
 
        window->windowNotifySetEnabled (this, true);
491
 
 
492
 
        XFree (propData);
493
 
    }
494
 
    else
495
 
        window->windowNotifySetEnabled (this, false);
496
 
 
497
 
    ks->checkPaintFunctions ();
498
 
}
499
 
 
500
 
void
501
 
KDECompatWindow::handleClose (bool destroy)
502
 
{
503
 
    KDECOMPAT_SCREEN (screen);
504
 
 
505
 
    if (mSlideData && ks->optionGetSlidingPopups ())
506
 
    {
507
 
        if (destroy)
508
 
        {
509
 
            mDestroyCnt++;
510
 
            window->incrementDestroyReference ();
511
 
        }
512
 
        else
513
 
        {
514
 
            mUnmapCnt++;
515
 
            window->incrementUnmapReference ();
516
 
        }
517
 
 
518
 
        if (mSlideData->appearing || !mSlideData->remaining)
519
 
            startSlideAnimation (false);
520
 
    }
521
 
}
522
 
 
523
 
CompAction *
524
 
KDECompatScreen::getScaleAction (const char *name)
525
 
{
526
 
    CompPlugin *p = mScaleHandle;
527
 
 
528
 
    if (!p)
529
 
        return NULL;
530
 
 
531
 
    foreach (CompOption &option, p->vTable->getOptions ())
532
 
    {
533
 
        if (option.type () == CompOption::TypeAction ||
534
 
            option.type () == CompOption::TypeButton ||
535
 
            option.type () == CompOption::TypeKey)
536
 
        {
537
 
            if (option.name () == name)
538
 
                return &option.value ().action ();
539
 
        }
540
 
    }
541
 
 
542
 
    return NULL;
543
 
}
544
 
 
545
 
bool
546
 
KDECompatScreen::scaleActivate ()
547
 
{
548
 
    if (mPresentWindow && !mScaleActive)
549
 
    {
550
 
        CompOption::Vector options (2);
551
 
        CompAction         *action;
552
 
 
553
 
        options[0] = CompOption ("root", CompOption::TypeInt);
554
 
        options[0].value ().set ((int) screen->root ());
555
 
 
556
 
        options[1] = CompOption ("match", CompOption::TypeMatch);
557
 
        options[1].value ().set (CompMatch ());
558
 
 
559
 
        CompMatch& windowMatch = options[1].value ().match ();
560
 
 
561
 
        foreach (Window win, mPresentWindowList)
562
 
        {
563
 
            std::ostringstream exp;
564
 
 
565
 
            exp << "xid=" << win;
566
 
            windowMatch |= exp.str ();
567
 
        }
568
 
 
569
 
        windowMatch.update ();
570
 
 
571
 
        action = getScaleAction ("initiate_all_key");
572
 
        if (action && action->initiate ())
573
 
            action->initiate () (action, 0, options);
574
 
    }
575
 
 
576
 
    return false;
577
 
}
578
 
 
579
 
void
580
 
KDECompatWindow::presentGroup ()
581
 
{
582
 
    Atom          actual;
583
 
    int           result, format;
584
 
    unsigned long n, left;
585
 
    unsigned char *propData;
586
 
 
587
 
 
588
 
    KDECOMPAT_SCREEN (screen);
589
 
 
590
 
    if (!ks->optionGetPresentWindows ())
591
 
        return;
592
 
 
593
 
    if (!ks->mScaleHandle)
594
 
    {
595
 
        compLogMessage ("kdecompat", CompLogLevelWarn,
596
 
                        "Scale plugin not loaded, present windows "
597
 
                        "effect not available!");
598
 
        return;
599
 
    }
600
 
 
601
 
    result = XGetWindowProperty (screen->dpy (), window->id (),
602
 
                                 ks->mKdePresentGroupAtom, 0,
603
 
                                 32768, false, AnyPropertyType, &actual,
604
 
                                 &format, &n, &left, &propData);
605
 
 
606
 
    if (result == Success && propData)
607
 
    {
608
 
        if (format == 32 && actual == ks->mKdePresentGroupAtom)
609
 
        {
610
 
            long *property = (long *) propData;
611
 
 
612
 
            if (!n || !property[0])
613
 
            {
614
 
                CompOption::Vector o (1);
615
 
                CompAction *action;
616
 
 
617
 
                /* end scale */
618
 
                o[0] = CompOption ("root", CompOption::TypeInt);
619
 
                o[0].value ().set ((int) screen->root ());
620
 
 
621
 
                action = ks->getScaleAction ("initiate_all_key");
622
 
                if (action && action->terminate ())
623
 
                    action->terminate () (action, CompAction::StateCancel, o);
624
 
 
625
 
                ks->mPresentWindow = NULL;
626
 
            }
627
 
            else
628
 
            {
629
 
                /* Activate scale using a timeout - Rationale:
630
 
                 * At the time we get the property notify event, Plasma
631
 
                 * most likely holds a pointer grab due to the action being
632
 
                 * initiated by a button click. As scale also wants to get
633
 
                 * a pointer grab, we need to delay the activation a bit so
634
 
                 * Plasma can release its grab.
635
 
                 */
636
 
 
637
 
                ks->mPresentWindow = window;
638
 
                ks->mPresentWindowList.clear ();
639
 
 
640
 
                for (unsigned int i = 0; i < n; i++)
641
 
                    ks->mPresentWindowList.push_back (property[i]);
642
 
 
643
 
                ks->mScaleTimeout.setCallback (
644
 
                    boost::bind (&KDECompatScreen::scaleActivate, ks));
645
 
                ks->mScaleTimeout.start ();
646
 
            }
647
 
        }
648
 
 
649
 
        XFree (propData);
650
 
    }
651
 
}
652
 
 
653
 
void
654
 
KDECompatScreen::handleCompizEvent (const char  *pluginName,
655
 
                                    const char  *eventName,
656
 
                                    CompOption::Vector  options)
657
 
{
658
 
 
659
 
    screen->handleCompizEvent (pluginName, eventName, options);
660
 
 
661
 
    if (mScaleHandle                      &&
662
 
        strcmp (pluginName, "scale") == 0 &&
663
 
        strcmp (eventName, "activate") == 0)
664
 
    {
665
 
        mScaleActive = CompOption::getBoolOptionNamed (options, "active", false);
666
 
        if (!mScaleActive && mPresentWindow)
667
 
            XDeleteProperty (screen->dpy (), mPresentWindow->id (),
668
 
                             mKdePresentGroupAtom);
669
 
    }
670
 
}
671
 
 
672
 
void
673
 
KDECompatWindow::updateBlurProperty (bool enabled)
674
 
{
675
 
    Atom actual;
676
 
    int  result, format;
677
 
    unsigned long n, left;
678
 
    unsigned char *propData;
679
 
    bool          validProperty = false;
680
 
 
681
 
    KDECOMPAT_SCREEN (screen);
682
 
 
683
 
    if (!ks->mBlurLoaded || !ks->optionGetWindowBlur ())
684
 
        return;
685
 
 
686
 
    if (!enabled)
687
 
    {
688
 
        if (mBlurPropertySet)
689
 
            XDeleteProperty (screen->dpy (), window->id (),
690
 
                             KDECompatScreen::get (screen)->mCompizWindowBlurAtom);
691
 
        return;
692
 
    }
693
 
 
694
 
    
695
 
    if (!mBlurPropertySet)
696
 
    {
697
 
        result = XGetWindowProperty (screen->dpy (), window->id (),
698
 
                                     ks->mCompizWindowBlurAtom, 0, 32768,
699
 
                                     false, AnyPropertyType, &actual,
700
 
                                     &format, &n, &left, &propData);
701
 
 
702
 
        if (result == Success && propData)
703
 
        {
704
 
            /* somebody else besides us already set a property,
705
 
             * don't touch that property
706
 
             */
707
 
 
708
 
            XFree (propData);
709
 
            return;
710
 
        }
711
 
    }
712
 
 
713
 
    result = XGetWindowProperty (screen->dpy (), window->id (),
714
 
                                 ks->mKdeBlurBehindRegionAtom, 0, 32768,
715
 
                                 false, AnyPropertyType, &actual, &format,
716
 
                                 &n, &left, &propData);
717
 
 
718
 
    if (result == Success && propData)
719
 
    {
720
 
        if (format == 32 && actual == XA_CARDINAL &&
721
 
            n > 0 && (n % 4 == 0))
722
 
        {
723
 
            long         *data = (long *) propData;
724
 
            unsigned int nBox = n / 4;
725
 
            long         compizProp[nBox * 6 + 2];
726
 
            unsigned int i = 2;
727
 
 
728
 
            compizProp[0] = 2; /* threshold */
729
 
            compizProp[1] = 0; /* filter */
730
 
 
731
 
            while (nBox--)
732
 
            {
733
 
                int x, y, w, h;
734
 
                x = *data++;
735
 
                y = *data++;
736
 
                w = *data++;
737
 
                h = *data++;
738
 
 
739
 
                compizProp[i++] = GRAVITY_NORTH | GRAVITY_WEST; /* P1 gravity */
740
 
                compizProp[i++] = x;                            /* P1 X */
741
 
                compizProp[i++] = y;                            /* P1 Y */
742
 
                compizProp[i++] = GRAVITY_NORTH | GRAVITY_WEST; /* P2 gravity */
743
 
                compizProp[i++] = x + w;                        /* P2 X */
744
 
                compizProp[i++] = y + h;                        /* P2 Y */
745
 
            }
746
 
 
747
 
            XChangeProperty (screen->dpy (), window->id (), ks->mCompizWindowBlurAtom,
748
 
                             XA_INTEGER, 32, PropModeReplace,
749
 
                             (unsigned char *) compizProp, i);
750
 
 
751
 
            mBlurPropertySet = true;
752
 
            validProperty       = TRUE;
753
 
        }
754
 
 
755
 
        XFree (propData);
756
 
    }
757
 
 
758
 
    if (mBlurPropertySet && !validProperty)
759
 
    {
760
 
        mBlurPropertySet = FALSE;
761
 
        XDeleteProperty (screen->dpy (), window->id (), ks->mKdeBlurBehindRegionAtom);
762
 
    }
763
 
}
764
 
 
765
 
void
766
 
KDECompatWindow::windowNotify (CompWindowNotify n)
767
 
{
768
 
    if (!KDECompatScreen::get (screen)->optionGetSlidingPopups ())
769
 
        return window->windowNotify (n);
770
 
 
771
 
    switch (n)
772
 
    {
773
 
        case CompWindowNotifyClose:
774
 
            handleClose (false);
775
 
            break;
776
 
        case CompWindowNotifyBeforeDestroy:
777
 
            handleClose (true);
778
 
            break;
779
 
        case CompWindowNotifyBeforeMap:
780
 
            startSlideAnimation (true);
781
 
            break;
782
 
        default:
783
 
            break;
784
 
    }
785
 
}
786
 
 
787
 
 
788
 
void
789
 
KDECompatScreen::handleEvent (XEvent *event)
790
 
{
791
 
    CompWindow *w;
792
 
 
793
 
    screen->handleEvent (event);
794
 
 
795
 
    switch (event->type) {
796
 
    case PropertyNotify:
797
 
        if (event->xproperty.atom == mKdePreviewAtom)
798
 
        {
799
 
            w = screen->findWindow (event->xproperty.window);
800
 
            if (w)
801
 
                KDECompatWindow::get (w)->updatePreviews ();
802
 
        }
803
 
        else if (event->xproperty.atom == mKdeSlideAtom)
804
 
        {
805
 
            w = screen->findWindow (event->xproperty.window);
806
 
            if (w)
807
 
                KDECompatWindow::get (w)->updateSlidePosition ();
808
 
        }
809
 
        else if (event->xproperty.atom == mKdePresentGroupAtom)
810
 
        {
811
 
            w = screen->findWindow (event->xproperty.window);
812
 
            if (w)
813
 
                KDECompatWindow::get (w)->presentGroup ();
814
 
        }
815
 
        else if (event->xproperty.atom == mKdeBlurBehindRegionAtom)
816
 
        {
817
 
            w = screen->findWindow (event->xproperty.window);
818
 
            if (w)
819
 
                KDECompatWindow::get (w)->updateBlurProperty (true);
820
 
        }
821
 
        break;
822
 
    }
823
 
}
824
 
 
825
 
bool
826
 
KDECompatWindow::damageRect (bool           initial,
827
 
                             const CompRect &rect)
828
 
{
829
 
    bool       status;
830
 
 
831
 
    KDECOMPAT_SCREEN (screen);
832
 
 
833
 
    if (mIsPreview && ks->optionGetPlasmaThumbnails ())
834
 
    {
835
 
        foreach (CompWindow *cw, screen->windows ())
836
 
        {
837
 
            KDECompatWindow *kdw = KDECompatWindow::get (cw);
838
 
 
839
 
            foreach (const Thumb& thumb, kdw->mPreviews)
840
 
            {
841
 
                if (thumb.id != window->id ())
842
 
                    continue;
843
 
 
844
 
                CompRect rect (thumb.thumb.x () + cw->x (),
845
 
                               thumb.thumb.y () + cw->y (),
846
 
                               thumb.thumb.width (),
847
 
                               thumb.thumb.height ());
848
 
 
849
 
                ks->cScreen->damageRegion (rect);
850
 
            }
851
 
        }
852
 
    }
853
 
 
854
 
    status = cWindow->damageRect (initial, rect);
855
 
 
856
 
    return status;
857
 
}
858
 
 
859
 
void
860
 
KDECompatScreen::advertiseSupport (Atom atom,
861
 
                                   bool enable)
862
 
{
863
 
    if (enable)
864
 
    {
865
 
        unsigned char value = 0;
866
 
 
867
 
        XChangeProperty (screen->dpy (), screen->root (), atom,
868
 
                         mKdePreviewAtom, 8, PropModeReplace, &value, 1);
869
 
    }
870
 
    else
871
 
    {
872
 
        XDeleteProperty (screen->dpy (), screen->root (), atom);
873
 
    }
874
 
}
875
 
 
876
 
void
877
 
KDECompatScreen::optionChanged (CompOption                *option,
878
 
                                KdecompatOptions::Options num)
879
 
{
880
 
    if (num == KdecompatOptions::PlasmaThumbnails)
881
 
        advertiseSupport (mKdePreviewAtom, option->value ().b ());
882
 
    else if (num == KdecompatOptions::SlidingPopups)
883
 
        advertiseSupport (mKdeSlideAtom, option->value (). b ());
884
 
    else if (num == KdecompatOptions::PresentWindows)
885
 
        advertiseSupport (mKdePresentGroupAtom,
886
 
                          option->value ().b () && mScaleHandle);
887
 
    else if (num == KdecompatOptions::WindowBlur)
888
 
    {
889
 
        advertiseSupport (mKdeBlurBehindRegionAtom,
890
 
                          option->value ().b () && mBlurLoaded);
891
 
        foreach (CompWindow *w, screen->windows ())
892
 
            KDECompatWindow::get (w)->updateBlurProperty (option->value ().b ());
893
 
    }
894
 
}
895
 
 
896
 
 
897
 
KDECompatScreen::KDECompatScreen (CompScreen *screen) :
898
 
    PluginClassHandler<KDECompatScreen, CompScreen> (screen),
899
 
    cScreen (CompositeScreen::get (screen)),
900
 
    gScreen (GLScreen::get (screen)),
901
 
    mKdePreviewAtom (XInternAtom (screen->dpy (), "_KDE_WINDOW_PREVIEW", 0)),
902
 
    mKdeSlideAtom (XInternAtom (screen->dpy (), "_KDE_SLIDE", 0)),
903
 
    mKdePresentGroupAtom (XInternAtom (screen->dpy (),
904
 
                          "_KDE_PRESENT_WINDOWS_GROUP", 0)),
905
 
    mKdeBlurBehindRegionAtom (XInternAtom (screen->dpy (),
906
 
                                           "_KDE_NET_WM_BLUR_BEHIND_REGION",
907
 
                                           0)),
908
 
    mCompizWindowBlurAtom (XInternAtom (screen->dpy (),
909
 
                                              "_COMPIZ_WM_WINDOW_BLUR", 0)),
910
 
    mHasSlidingPopups (false),
911
 
    mDestroyCnt (0),
912
 
    mUnmapCnt (0),
913
 
    mScaleHandle (CompPlugin::find ("scale")),
914
 
    mScaleActive (false),
915
 
    mBlurLoaded ((CompPlugin::find ("blur") != NULL)),
916
 
    mPresentWindow (NULL)
917
 
{
918
 
    ScreenInterface::setHandler (screen);
919
 
    CompositeScreenInterface::setHandler (cScreen, false);
920
 
    GLScreenInterface::setHandler (gScreen, false);
921
 
 
922
 
    mScaleTimeout.setTimes (100, 200);
923
 
 
924
 
    advertiseSupport (mKdePreviewAtom, optionGetPlasmaThumbnails ());
925
 
    advertiseSupport (mKdeSlideAtom, optionGetSlidingPopups ());
926
 
    advertiseSupport (mKdePresentGroupAtom, optionGetPresentWindows () &&
927
 
                                            mScaleHandle);
928
 
    optionSetPlasmaThumbnailsNotify (
929
 
        boost::bind (&KDECompatScreen::optionChanged, this, _1, _2));
930
 
}
931
 
 
932
 
KDECompatScreen::~KDECompatScreen ()
933
 
{
934
 
    advertiseSupport (mKdePreviewAtom, false);
935
 
    advertiseSupport (mKdeSlideAtom, false);
936
 
    advertiseSupport (mKdePresentGroupAtom, false);
937
 
}
938
 
 
939
 
KDECompatWindow::KDECompatWindow (CompWindow *window) :
940
 
    PluginClassHandler <KDECompatWindow, CompWindow> (window),
941
 
    window (window),
942
 
    cWindow (CompositeWindow::get (window)),
943
 
    gWindow (GLWindow::get (window)),
944
 
    mIsPreview (false),
945
 
    mSlideData (NULL),
946
 
    mDestroyCnt (0),
947
 
    mUnmapCnt (0),
948
 
    mBlurPropertySet (false)
949
 
{
950
 
    WindowInterface::setHandler (window, false);
951
 
    CompositeWindowInterface::setHandler (cWindow, false);
952
 
    GLWindowInterface::setHandler (gWindow, false);
953
 
    
954
 
    updateBlurProperty (KDECompatScreen::get (screen)->optionGetWindowBlur ());
955
 
}
956
 
 
957
 
KDECompatWindow::~KDECompatWindow ()
958
 
{
959
 
    stopCloseAnimation ();
960
 
 
961
 
    if (mSlideData)
962
 
        delete mSlideData;
963
 
 
964
 
    if (KDECompatScreen::get (screen)->mPresentWindow == window)
965
 
        KDECompatScreen::get (screen)->mPresentWindow = NULL;
966
 
 
967
 
    updateBlurProperty (false);
968
 
}
969
 
 
970
 
bool
971
 
KDECompatPluginVTable::init ()
972
 
{
973
 
    if (!CompPlugin::checkPluginABI ("core", CORE_ABIVERSION) ||
974
 
        !CompPlugin::checkPluginABI ("composite", COMPIZ_COMPOSITE_ABI) ||
975
 
        !CompPlugin::checkPluginABI ("opengl", COMPIZ_OPENGL_ABI))
976
 
        return false;
977
 
 
978
 
    return true;
979
 
}