← Back to branch summary

~ubuntu-branches/ubuntu/trusty/compiz-fusion-plugins-main/trusty

« back to all changes in this revision

Viewing changes to src/kdecompat/kdecompat.c

  • Committer: Bazaar Package Importer
  • Author(s): Didier Roche
  • Date: 2010-10-19 12:07:20 UTC
  • mfrom: (1.1.38 upstream)
  • Revision ID: james.westby@ubuntu.com-20101019120720-c3wffrxv7khh2ll8
Tags: 0.9.2.1-0ubuntu1
* New upstream release
* debian/control, debian/rules:
  - convert to cmake, remove autoconf, and convert to debhelper7
* debian/control:
  - bump compiz build-dep and deps to 0.9,
  - reintroduce coreabiversion trick to dep on the good package
* debian/install:
  - removed, seems we shipped all files anyway. Now install in the package
    directly
* debian/docs:
  - adapt to latest upstream shipped file
* debian/source:
  - switch to quilt format
* debian/patches/01-animation-defaults.patch,
  debian/patches/03_default_options.patch,
  debian/patches/06_bug326995.patch,
  debian/patches/08_disable_desktop_vpswitch.patch:
  - adapt to latest version
* debian/patches/02_fix_edges.patch:
  - removed for now: the plugin has been rewritten and have a different
    behavior
* debian/control:
  - remove compiz-fusion-bcop as a build-dep, now built in the core itself
* debian/rules:
  - add some switch to build in package mode, not in debug one

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/kdecompat/kdecompat.c
1
 
/*
2
 
 *
3
 
 * Compiz KDE compatibility plugin
4
 
 *
5
 
 * kdecompat.c
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 <stdio.h>
27
 
#include <stdlib.h>
28
 
#include <string.h>
29
 
#include <math.h>
30
 
#include <sys/time.h>
31
 
 
32
 
#include <X11/Xatom.h>
33
 
 
34
 
#include <compiz-core.h>
35
 
#include "kdecompat_options.h"
36
 
 
37
 
static int displayPrivateIndex;
38
 
 
39
 
typedef struct _KdeCompatDisplay {
40
 
    int screenPrivateIndex;
41
 
 
42
 
    HandleEventProc       handleEvent;
43
 
    HandleCompizEventProc handleCompizEvent;
44
 
 
45
 
    CompPlugin        *scaleHandle;
46
 
    Bool              scaleActive;
47
 
    CompTimeoutHandle scaleTimeout;
48
 
 
49
 
    Atom kdePreviewAtom;
50
 
    Atom kdeSlideAtom;
51
 
    Atom kdePresentGroupAtom;
52
 
} KdeCompatDisplay;
53
 
 
54
 
typedef struct _KdeCompatScreen {
55
 
    int windowPrivateIndex;
56
 
 
57
 
    Bool hasSlidingPopups;
58
 
 
59
 
    PreparePaintScreenProc preparePaintScreen;
60
 
    PaintOutputProc        paintOutput;
61
 
    DonePaintScreenProc    donePaintScreen;
62
 
    PaintWindowProc        paintWindow;
63
 
    DamageWindowRectProc   damageWindowRect;
64
 
 
65
 
    CompWindow *presentWindow;
66
 
} KdeCompatScreen;
67
 
 
68
 
typedef struct {
69
 
   CompScreen *s;
70
 
   Window     manager;
71
 
   int        nWindows;
72
 
   Window     windows[0];
73
 
} PresentWindowData;
74
 
 
75
 
typedef struct _Thumb {
76
 
    Window     id;
77
 
    XRectangle thumb;
78
 
} Thumb;
79
 
 
80
 
typedef enum {
81
 
    West  = 0,
82
 
    North = 1,
83
 
    East  = 2,
84
 
    South = 3
85
 
} SlidePosition;
86
 
 
87
 
typedef struct {
88
 
    SlidePosition position;
89
 
    int           start;
90
 
    Bool          appearing;
91
 
    int           remaining;
92
 
    int           duration;
93
 
} SlideData;
94
 
 
95
 
typedef struct _KdeCompatWindow {
96
 
    Thumb        *previews;
97
 
    unsigned int nPreviews;
98
 
    Bool         isPreview;
99
 
 
100
 
    SlideData *slideData;
101
 
 
102
 
    int destroyCnt;
103
 
    int unmapCnt;
104
 
} KdeCompatWindow;
105
 
 
106
 
#define GET_KDECOMPAT_DISPLAY(d)                                      \
107
 
    ((KdeCompatDisplay *) (d)->base.privates[displayPrivateIndex].ptr)
108
 
 
109
 
#define KDECOMPAT_DISPLAY(d)                 \
110
 
    KdeCompatDisplay *kd = GET_KDECOMPAT_DISPLAY (d)
111
 
 
112
 
#define GET_KDECOMPAT_SCREEN(s, kd)                                       \
113
 
    ((KdeCompatScreen *) (s)->base.privates[(kd)->screenPrivateIndex].ptr)
114
 
 
115
 
#define KDECOMPAT_SCREEN(s)                                                \
116
 
    KdeCompatScreen *ks = GET_KDECOMPAT_SCREEN (s,                         \
117
 
                          GET_KDECOMPAT_DISPLAY (s->display))
118
 
 
119
 
#define GET_KDECOMPAT_WINDOW(w, ks)                                       \
120
 
    ((KdeCompatWindow *) (w)->base.privates[(ks)->windowPrivateIndex].ptr)
121
 
 
122
 
#define KDECOMPAT_WINDOW(w)                                            \
123
 
    KdeCompatWindow *kw = GET_KDECOMPAT_WINDOW  (w,                    \
124
 
                          GET_KDECOMPAT_SCREEN  (w->screen,            \
125
 
                          GET_KDECOMPAT_DISPLAY (w->screen->display)))
126
 
 
127
 
static void
128
 
kdecompatStopCloseAnimation (CompWindow *w)
129
 
{
130
 
    KDECOMPAT_WINDOW (w);
131
 
 
132
 
    while (kw->unmapCnt)
133
 
    {
134
 
        unmapWindow (w);
135
 
        kw->unmapCnt--;
136
 
    }
137
 
 
138
 
    while (kw->destroyCnt)
139
 
    {
140
 
        destroyWindow (w);
141
 
        kw->destroyCnt--;
142
 
    }
143
 
}
144
 
 
145
 
static void
146
 
kdecompatSendSlideEvent (CompWindow *w,
147
 
                         Bool       start)
148
 
{
149
 
    CompOption  o[2];
150
 
    CompDisplay *d = w->screen->display;
151
 
 
152
 
    o[0].type    = CompOptionTypeInt;
153
 
    o[0].name    = "window";
154
 
    o[0].value.i = w->id;
155
 
 
156
 
    o[1].type    = CompOptionTypeBool;
157
 
    o[1].name    = "active";
158
 
    o[1].value.b = start;
159
 
 
160
 
    (*d->handleCompizEvent) (d, "kdecompat", "slide", o, 2);
161
 
}
162
 
 
163
 
static void
164
 
kdecompatStartSlideAnimation (CompWindow *w,
165
 
                              Bool       appearing)
166
 
{
167
 
    KDECOMPAT_WINDOW (w);
168
 
 
169
 
    if (kw->slideData)
170
 
    {
171
 
        SlideData *data = kw->slideData;
172
 
 
173
 
        KDECOMPAT_SCREEN (w->screen);
174
 
 
175
 
        if (appearing)
176
 
            data->duration = kdecompatGetSlideInDuration (w->screen);
177
 
        else
178
 
            data->duration = kdecompatGetSlideOutDuration (w->screen);
179
 
 
180
 
        if (data->remaining > data->duration)
181
 
            data->remaining = data->duration;
182
 
        else
183
 
            data->remaining = data->duration - data->remaining;
184
 
 
185
 
        data->appearing      = appearing;
186
 
        ks->hasSlidingPopups = TRUE;
187
 
        addWindowDamage (w);
188
 
        kdecompatSendSlideEvent (w, TRUE);
189
 
    }
190
 
}
191
 
 
192
 
static void
193
 
kdecompatEndSlideAnimation (CompWindow *w)
194
 
{
195
 
    KDECOMPAT_WINDOW (w);
196
 
 
197
 
    if (kw->slideData)
198
 
    {
199
 
        kw->slideData->remaining = 0;
200
 
        kdecompatStopCloseAnimation (w);
201
 
        kdecompatSendSlideEvent (w, FALSE);
202
 
    }
203
 
}
204
 
 
205
 
static void
206
 
kdecompatPreparePaintScreen (CompScreen *s,
207
 
                             int        msSinceLastPaint)
208
 
{
209
 
    KDECOMPAT_SCREEN (s);
210
 
 
211
 
    if (ks->hasSlidingPopups)
212
 
    {
213
 
        CompWindow *w;
214
 
 
215
 
        for (w = s->windows; w; w = w->next)
216
 
        {
217
 
            KdeCompatWindow *kw = GET_KDECOMPAT_WINDOW (w, ks);
218
 
 
219
 
            if (!kw->slideData)
220
 
                continue;
221
 
 
222
 
            kw->slideData->remaining -= msSinceLastPaint;
223
 
            if (kw->slideData->remaining <= 0)
224
 
                kdecompatEndSlideAnimation (w);
225
 
        }
226
 
    }
227
 
 
228
 
    UNWRAP (ks, s, preparePaintScreen);
229
 
    (*s->preparePaintScreen) (s, msSinceLastPaint);
230
 
    WRAP (ks, s, preparePaintScreen, kdecompatPreparePaintScreen);
231
 
}
232
 
 
233
 
static Bool
234
 
kdecompatPaintOutput (CompScreen              *s,
235
 
                      const ScreenPaintAttrib *attrib,
236
 
                      const CompTransform     *transform,
237
 
                      Region                  region,
238
 
                      CompOutput              *output,
239
 
                      unsigned int            mask)
240
 
{
241
 
    Bool status;
242
 
 
243
 
    KDECOMPAT_SCREEN (s);
244
 
 
245
 
    if (ks->hasSlidingPopups)
246
 
        mask |= PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS_MASK;
247
 
 
248
 
    UNWRAP (ks, s, paintOutput);
249
 
    status = (*s->paintOutput) (s, attrib, transform, region, output, mask);
250
 
    WRAP (ks, s, paintOutput, kdecompatPaintOutput);
251
 
 
252
 
    return status;
253
 
}
254
 
 
255
 
static void
256
 
kdecompatDonePaintScreen (CompScreen *s)
257
 
{
258
 
    KDECOMPAT_SCREEN (s);
259
 
 
260
 
    if (ks->hasSlidingPopups)
261
 
    {
262
 
        CompWindow *w;
263
 
 
264
 
        ks->hasSlidingPopups = FALSE;
265
 
 
266
 
        for (w = s->windows; w; w = w->next)
267
 
        {
268
 
            KdeCompatWindow *kw = GET_KDECOMPAT_WINDOW (w, ks);
269
 
 
270
 
            if (kw->slideData && kw->slideData->remaining)
271
 
            {
272
 
                addWindowDamage (w);
273
 
                ks->hasSlidingPopups = TRUE;
274
 
            }
275
 
        }
276
 
    }
277
 
 
278
 
    UNWRAP (ks, s, donePaintScreen);
279
 
    (*s->donePaintScreen) (s);
280
 
    WRAP (ks, s, donePaintScreen, kdecompatDonePaintScreen);
281
 
}
282
 
 
283
 
static Bool
284
 
kdecompatPaintWindow (CompWindow                 *w,
285
 
                      const WindowPaintAttrib    *attrib,
286
 
                      const CompTransform        *transform,
287
 
                      Region                     region,
288
 
                      unsigned int               mask)
289
 
{
290
 
    CompScreen   *s = w->screen;
291
 
    Bool         status;
292
 
    unsigned int i;
293
 
 
294
 
    KDECOMPAT_SCREEN (s);
295
 
    KDECOMPAT_WINDOW (w);
296
 
 
297
 
    if (kw->slideData && kw->slideData->remaining)
298
 
    {
299
 
        FragmentAttrib fragment;
300
 
        CompTransform  wTransform = *transform;
301
 
        SlideData      *data = kw->slideData;
302
 
        float          xTranslate = 0, yTranslate = 0, remainder;
303
 
        BOX            clipBox;
304
 
 
305
 
        if (mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK)
306
 
            return FALSE;
307
 
 
308
 
        remainder = (float) data->remaining / data->duration;
309
 
        if (!data->appearing)
310
 
            remainder = 1.0 - remainder;
311
 
 
312
 
        clipBox.x1 = w->attrib.x;
313
 
        clipBox.y1 = w->attrib.y;
314
 
        clipBox.x2 = clipBox.x1 + w->width;
315
 
        clipBox.y2 = clipBox.y1 + w->height;
316
 
 
317
 
        switch (data->position) {
318
 
        case East:
319
 
            xTranslate = (data->start - w->attrib.x) * remainder;
320
 
            clipBox.x2 = data->start;
321
 
            break;
322
 
        case West:
323
 
            xTranslate = (data->start - w->width) * remainder;
324
 
            clipBox.x1 = data->start;
325
 
            break;
326
 
        case North:
327
 
            yTranslate = (data->start - w->height) * remainder;
328
 
            clipBox.y1 = data->start;
329
 
            break;
330
 
        case South:
331
 
        default:
332
 
            yTranslate = (data->start - w->attrib.y) * remainder;
333
 
            clipBox.y2 = data->start;
334
 
            break;
335
 
        }
336
 
 
337
 
        UNWRAP (ks, s, paintWindow);
338
 
        status = (*s->paintWindow) (w, attrib, transform, region,
339
 
                                    mask | PAINT_WINDOW_NO_CORE_INSTANCE_MASK);
340
 
        WRAP (ks, s, paintWindow, kdecompatPaintWindow);
341
 
 
342
 
        initFragmentAttrib (&fragment, &w->lastPaint);
343
 
 
344
 
        if (w->alpha || fragment.opacity != OPAQUE)
345
 
            mask |= PAINT_WINDOW_TRANSLUCENT_MASK;
346
 
 
347
 
        matrixTranslate (&wTransform, xTranslate, yTranslate, 0.0f);
348
 
 
349
 
        glPushMatrix ();
350
 
        glLoadMatrixf (wTransform.m);
351
 
 
352
 
        glPushAttrib (GL_SCISSOR_BIT);
353
 
        glEnable (GL_SCISSOR_TEST);
354
 
 
355
 
        glScissor (clipBox.x1, s->height - clipBox.y2,
356
 
                   clipBox.x2 - clipBox.x1, clipBox.y2 - clipBox.y1);
357
 
 
358
 
        (*s->drawWindow) (w, &wTransform, &fragment, region,
359
 
                          mask | PAINT_WINDOW_TRANSFORMED_MASK);
360
 
 
361
 
        glDisable (GL_SCISSOR_TEST);
362
 
        glPopAttrib ();
363
 
        glPopMatrix ();
364
 
    }
365
 
    else
366
 
    {
367
 
        UNWRAP (ks, s, paintWindow);
368
 
        status = (*s->paintWindow) (w, attrib, transform, region, mask);
369
 
        WRAP (ks, s, paintWindow, kdecompatPaintWindow);
370
 
    }
371
 
 
372
 
    if (!status                           ||
373
 
        !kdecompatGetPlasmaThumbnails (s) ||
374
 
        !kw->nPreviews                    ||
375
 
        !w->mapNum                        ||
376
 
        (mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK))
377
 
    {
378
 
        return status;
379
 
    }
380
 
 
381
 
    for (i = 0; i < kw->nPreviews; i++)
382
 
    {
383
 
        CompWindow   *tw = findWindowAtScreen (s, kw->previews[i].id);
384
 
        XRectangle   *rect = &kw->previews[i].thumb;
385
 
        unsigned int paintMask = mask | PAINT_WINDOW_TRANSFORMED_MASK;
386
 
        float        xScale = 1.0f, yScale = 1.0f, xTranslate, yTranslate;
387
 
        CompIcon     *icon = NULL;
388
 
 
389
 
        if (!tw)
390
 
            continue;
391
 
 
392
 
        xTranslate = rect->x + w->attrib.x - tw->attrib.x;
393
 
        yTranslate = rect->y + w->attrib.y - tw->attrib.y;
394
 
 
395
 
        if (tw->texture->pixmap)
396
 
        {
397
 
            unsigned int width, height;
398
 
 
399
 
            width  = tw->attrib.width + tw->input.left + tw->input.right;
400
 
            height = tw->attrib.height + tw->input.top + tw->input.bottom;
401
 
 
402
 
            xScale = (float) rect->width / width;
403
 
            yScale = (float) rect->height / height;
404
 
 
405
 
            xTranslate += tw->input.left * xScale;
406
 
            yTranslate += tw->input.top * yScale;
407
 
        }
408
 
        else
409
 
        {
410
 
            icon = getWindowIcon (tw, 256, 256);
411
 
            if (!icon)
412
 
                icon = s->defaultIcon;
413
 
 
414
 
            if (icon)
415
 
                if (!icon->texture.name && !iconToTexture (s, icon))
416
 
                    icon = NULL;
417
 
 
418
 
            if (icon)
419
 
            {
420
 
                REGION     iconReg;
421
 
                CompMatrix matrix;
422
 
 
423
 
                paintMask |= PAINT_WINDOW_BLEND_MASK;
424
 
 
425
 
                if (icon->width >= rect->width || icon->height >= rect->height)
426
 
                {
427
 
                    xScale = (float) rect->width / icon->width;
428
 
                    yScale = (float) rect->height / icon->height;
429
 
 
430
 
                    if (xScale < yScale)
431
 
                        yScale = xScale;
432
 
                    else
433
 
                        xScale = yScale;
434
 
                }
435
 
 
436
 
                xTranslate += rect->width / 2 - (icon->width * xScale / 2);
437
 
                yTranslate += rect->height / 2 - (icon->height * yScale / 2);
438
 
 
439
 
                iconReg.rects    = &iconReg.extents;
440
 
                iconReg.numRects = 1;
441
 
 
442
 
                iconReg.extents.x1 = tw->attrib.x;
443
 
                iconReg.extents.y1 = tw->attrib.y;
444
 
                iconReg.extents.x2 = tw->attrib.x + icon->width;
445
 
                iconReg.extents.y2 = tw->attrib.y + icon->height;
446
 
 
447
 
                matrix = icon->texture.matrix;
448
 
                matrix.x0 -= (tw->attrib.x * icon->texture.matrix.xx);
449
 
                matrix.y0 -= (tw->attrib.y * icon->texture.matrix.yy);
450
 
 
451
 
                tw->vCount = tw->indexCount = 0;
452
 
                (*s->addWindowGeometry) (tw, &matrix, 1,
453
 
                                         &iconReg, &infiniteRegion);
454
 
 
455
 
                if (!tw->vCount)
456
 
                    icon = NULL;
457
 
            }
458
 
        }
459
 
 
460
 
        if (tw->texture->pixmap || icon)
461
 
        {
462
 
            FragmentAttrib fragment;
463
 
            CompTransform  wTransform = *transform;
464
 
 
465
 
            initFragmentAttrib (&fragment, attrib);
466
 
 
467
 
            if (tw->alpha || fragment.opacity != OPAQUE)
468
 
                paintMask |= PAINT_WINDOW_TRANSLUCENT_MASK;
469
 
 
470
 
            matrixTranslate (&wTransform, tw->attrib.x, tw->attrib.y, 0.0f);
471
 
            matrixScale (&wTransform, xScale, yScale, 1.0f);
472
 
            matrixTranslate (&wTransform,
473
 
                             xTranslate / xScale - tw->attrib.x,
474
 
                             yTranslate / yScale - tw->attrib.y,
475
 
                             0.0f);
476
 
 
477
 
            glPushMatrix ();
478
 
            glLoadMatrixf (wTransform.m);
479
 
 
480
 
            if (tw->texture->pixmap)
481
 
                (*s->drawWindow) (tw, &wTransform, &fragment,
482
 
                                  &infiniteRegion, paintMask);
483
 
            else if (icon)
484
 
                (*s->drawWindowTexture) (tw, &icon->texture,
485
 
                                         &fragment, paintMask);
486
 
 
487
 
            glPopMatrix ();
488
 
        }
489
 
    }
490
 
 
491
 
    return status;
492
 
}
493
 
 
494
 
static void
495
 
kdecompatUpdatePreviews (CompWindow *w)
496
 
{
497
 
    CompWindow    *cw;
498
 
    CompScreen    *s = w->screen;
499
 
    CompDisplay   *d = s->display;
500
 
    Atom          actual;
501
 
    int           result, format;
502
 
    unsigned long n, left;
503
 
    unsigned char *propData;
504
 
 
505
 
    KDECOMPAT_DISPLAY (d);
506
 
    KDECOMPAT_SCREEN (s);
507
 
    KDECOMPAT_WINDOW (w);
508
 
 
509
 
    kw->nPreviews = 0;
510
 
 
511
 
    result = XGetWindowProperty (d->display, w->id, kd->kdePreviewAtom, 0,
512
 
                                 32768, FALSE, AnyPropertyType, &actual,
513
 
                                 &format, &n, &left, &propData);
514
 
 
515
 
    if (result == Success && propData)
516
 
    {
517
 
        if (format == 32 && actual == kd->kdePreviewAtom)
518
 
        {
519
 
            long *data    = (long *) propData;
520
 
            int  nPreview = *data++;
521
 
 
522
 
            if (n == (6 * nPreview + 1))
523
 
            {
524
 
                kw->previews = realloc (kw->previews,
525
 
                                        nPreview * sizeof (Thumb));
526
 
                if (kw->previews)
527
 
                {
528
 
                    while (kw->nPreviews < nPreview)
529
 
                    {
530
 
                        if (*data++ != 5)
531
 
                            break;
532
 
 
533
 
                        kw->previews[kw->nPreviews].id = *data++;
534
 
 
535
 
                        kw->previews[kw->nPreviews].thumb.x      = *data++;
536
 
                        kw->previews[kw->nPreviews].thumb.y      = *data++;
537
 
                        kw->previews[kw->nPreviews].thumb.width  = *data++;
538
 
                        kw->previews[kw->nPreviews].thumb.height = *data++;
539
 
 
540
 
                        kw->nPreviews++;
541
 
                    }
542
 
                }
543
 
            }
544
 
        }
545
 
 
546
 
        XFree (propData);
547
 
    }
548
 
 
549
 
    for (cw = s->windows; cw; cw = cw->next)
550
 
    {
551
 
        CompWindow      *rw;
552
 
        KdeCompatWindow *kcw = GET_KDECOMPAT_WINDOW (cw, ks);
553
 
 
554
 
        kcw->isPreview = FALSE;
555
 
        for (rw = s->windows; rw; rw = rw->next)
556
 
        {
557
 
            KdeCompatWindow *krw = GET_KDECOMPAT_WINDOW (rw, ks);
558
 
            unsigned int    i;
559
 
 
560
 
            for (i = 0; i < krw->nPreviews; i++)
561
 
            {
562
 
                if (krw->previews[i].id == cw->id)
563
 
                {
564
 
                    kcw->isPreview = TRUE;
565
 
                    break;
566
 
                }
567
 
            }
568
 
 
569
 
            if (kcw->isPreview)
570
 
                break;
571
 
        }
572
 
    }
573
 
}
574
 
 
575
 
static void
576
 
kdecompatUpdateSlidePosition (CompWindow *w)
577
 
{
578
 
    CompDisplay   *d = w->screen->display;
579
 
    Atom          actual;
580
 
    int           result, format;
581
 
    unsigned long n, left;
582
 
    unsigned char *propData;
583
 
 
584
 
    KDECOMPAT_DISPLAY (d);
585
 
    KDECOMPAT_WINDOW (w);
586
 
 
587
 
    if (kw->slideData)
588
 
    {
589
 
        free (kw->slideData);
590
 
        kw->slideData = NULL;
591
 
    }
592
 
 
593
 
    result = XGetWindowProperty (d->display, w->id, kd->kdeSlideAtom, 0,
594
 
                                 32768, FALSE, AnyPropertyType, &actual,
595
 
                                 &format, &n, &left, &propData);
596
 
 
597
 
    if (result == Success && propData)
598
 
    {
599
 
        if (format == 32 && actual == kd->kdeSlideAtom && n == 2)
600
 
        {
601
 
            long *data = (long *) propData;
602
 
 
603
 
            kw->slideData = malloc (sizeof (SlideData));
604
 
            if (kw->slideData)
605
 
            {
606
 
                kw->slideData->remaining = 0;
607
 
                kw->slideData->start     = data[0];
608
 
                kw->slideData->position  = data[1];
609
 
            }
610
 
        }
611
 
 
612
 
        XFree (propData);
613
 
    }
614
 
}
615
 
 
616
 
static void
617
 
kdecompatHandleWindowClose (CompWindow *w,
618
 
                            Bool       destroy)
619
 
{
620
 
    KDECOMPAT_WINDOW (w);
621
 
 
622
 
    if (kw->slideData && kdecompatGetSlidingPopups (w->screen))
623
 
    {
624
 
        if (destroy)
625
 
        {
626
 
            kw->destroyCnt++;
627
 
            w->destroyRefCnt++;
628
 
        }
629
 
        else
630
 
        {
631
 
            kw->unmapCnt++;
632
 
            w->unmapRefCnt++;
633
 
        }
634
 
 
635
 
        if (kw->slideData->appearing || !kw->slideData->remaining)
636
 
            kdecompatStartSlideAnimation (w, FALSE);
637
 
    }
638
 
}
639
 
 
640
 
static CompAction *
641
 
kdecompatGetScaleAction (CompDisplay *d,
642
 
                         const char  *name)
643
 
{
644
 
    CompObject *object;
645
 
    CompOption *option;
646
 
    int        nOption;
647
 
    CompPlugin *p;
648
 
 
649
 
    KDECOMPAT_DISPLAY (d);
650
 
 
651
 
    p = kd->scaleHandle;
652
 
    if (!p || !p->vTable->getObjectOptions)
653
 
        return NULL;
654
 
 
655
 
    object = compObjectFind (&core.base, COMP_OBJECT_TYPE_DISPLAY, NULL);
656
 
    if (!object)
657
 
        return NULL;
658
 
 
659
 
    option = (*p->vTable->getObjectOptions) (p, object, &nOption);
660
 
    while (nOption--)
661
 
    {
662
 
        if (option->type == CompOptionTypeAction ||
663
 
            option->type == CompOptionTypeButton ||
664
 
            option->type == CompOptionTypeKey)
665
 
        {
666
 
            if (strcmp (option->name, name) == 0)
667
 
            {
668
 
                return &option->value.action;
669
 
            }
670
 
        }
671
 
 
672
 
        option++;
673
 
    }
674
 
 
675
 
    return NULL;
676
 
}
677
 
 
678
 
static Bool
679
 
kdecompatScaleActivate (void *closure)
680
 
{
681
 
    PresentWindowData *data = (PresentWindowData *) closure;
682
 
    CompScreen        *s = data->s;
683
 
    CompDisplay       *d = s->display;
684
 
    CompWindow        *w;
685
 
 
686
 
    KDECOMPAT_DISPLAY (d);
687
 
 
688
 
    w = findWindowAtScreen (s, data->manager);
689
 
    if (w && !kd->scaleActive)
690
 
    {
691
 
        CompOption   o[2];
692
 
        unsigned int i;
693
 
        char         buffer[20];
694
 
        CompMatch    *windowMatch = &o[1].value.match;
695
 
        CompAction   *action;
696
 
 
697
 
        KDECOMPAT_SCREEN (s);
698
 
 
699
 
        o[0].name    = "root";
700
 
        o[0].type    = CompOptionTypeInt;
701
 
        o[0].value.i = s->root;
702
 
 
703
 
        o[1].name = "match";
704
 
        o[1].type = CompOptionTypeMatch;
705
 
 
706
 
        ks->presentWindow = w;
707
 
 
708
 
        matchInit (windowMatch);
709
 
 
710
 
        for (i = 0; i < data->nWindows; i++)
711
 
        {
712
 
            snprintf (buffer, sizeof (buffer), "xid=%ld", data->windows[i]);
713
 
            matchAddExp (windowMatch, 0, buffer);
714
 
        }
715
 
 
716
 
        matchUpdate (d, windowMatch);
717
 
 
718
 
        action = kdecompatGetScaleAction (d, "initiate_all_key");
719
 
        if (action && action->initiate)
720
 
            (action->initiate) (d, action, 0, o, 2);
721
 
 
722
 
        matchFini (windowMatch);
723
 
    }
724
 
 
725
 
    free (data);
726
 
 
727
 
    return FALSE;
728
 
}
729
 
 
730
 
static void
731
 
kdecompatFreeScaleTimeout (KdeCompatDisplay *kd)
732
 
{
733
 
    PresentWindowData *data = NULL;
734
 
 
735
 
    if (kd->scaleTimeout)
736
 
        data = compRemoveTimeout (kd->scaleTimeout);
737
 
    if (data)
738
 
        free (data);
739
 
 
740
 
    kd->scaleTimeout = 0;
741
 
}
742
 
 
743
 
static void
744
 
kdecompatPresentWindowGroup (CompWindow *w)
745
 
{
746
 
    CompScreen    *s = w->screen;
747
 
    CompDisplay   *d = s->display;
748
 
    Atom          actual;
749
 
    int           result, format;
750
 
    unsigned long n, left;
751
 
    unsigned char *propData;
752
 
 
753
 
 
754
 
    KDECOMPAT_DISPLAY (d);
755
 
 
756
 
    if (!kdecompatGetPresentWindows (s))
757
 
        return;
758
 
 
759
 
    if (!kd->scaleHandle)
760
 
    {
761
 
        compLogMessage ("kdecompat", CompLogLevelWarn,
762
 
                        "Scale plugin not loaded, present windows "
763
 
                        "effect not available!");
764
 
        return;
765
 
    }
766
 
 
767
 
    result = XGetWindowProperty (d->display, w->id, kd->kdePresentGroupAtom, 0,
768
 
                                 32768, FALSE, AnyPropertyType, &actual,
769
 
                                 &format, &n, &left, &propData);
770
 
 
771
 
    if (result == Success && propData)
772
 
    {
773
 
        if (format == 32 && actual == kd->kdePresentGroupAtom)
774
 
        {
775
 
            long *property = (long *) propData;
776
 
 
777
 
            if (!n || !property[0])
778
 
            {
779
 
                CompOption o;
780
 
                CompAction *action;
781
 
 
782
 
                /* end scale */
783
 
 
784
 
                o.name    = "root";
785
 
                o.type    = CompOptionTypeInt;
786
 
                o.value.i = s->root;
787
 
 
788
 
                action = kdecompatGetScaleAction (d, "initiate_all_key");
789
 
                if (action && action->terminate)
790
 
                    (action->terminate) (d, action,
791
 
                                         CompActionStateCancel,  &o, 1);
792
 
 
793
 
            }
794
 
            else
795
 
            {
796
 
                PresentWindowData *data;
797
 
 
798
 
                /* Activate scale using a timeout - Rationale:
799
 
                 * At the time we get the property notify event, Plasma
800
 
                 * most likely holds a pointer grab due to the action being
801
 
                 * initiated by a button click. As scale also wants to get
802
 
                 * a pointer grab, we need to delay the activation a bit so
803
 
                 * Plasma can release its grab.
804
 
                 */
805
 
 
806
 
                kdecompatFreeScaleTimeout (kd);
807
 
 
808
 
                data = malloc (sizeof (PresentWindowData) + n * sizeof (Window));
809
 
                if (data)
810
 
                {
811
 
                    unsigned int i;
812
 
 
813
 
                    data->s        = s;
814
 
                    data->manager  = w->id;
815
 
                    data->nWindows = n;
816
 
                    for (i = 0; i < n; i++)
817
 
                        data->windows[i] = property[i];
818
 
 
819
 
                    kd->scaleTimeout = compAddTimeout (100, 200,
820
 
                                                       kdecompatScaleActivate,
821
 
                                                       data);
822
 
                }
823
 
            }
824
 
        }
825
 
 
826
 
        XFree (propData);
827
 
    }
828
 
}
829
 
 
830
 
static void
831
 
kdecompatHandleCompizEvent (CompDisplay *d,
832
 
                            const char  *pluginName,
833
 
                            const char  *eventName,
834
 
                            CompOption  *option,
835
 
                            int         nOption)
836
 
{
837
 
    KDECOMPAT_DISPLAY (d);
838
 
 
839
 
    UNWRAP (kd, d, handleCompizEvent);
840
 
    (*d->handleCompizEvent) (d, pluginName, eventName, option, nOption);
841
 
    WRAP (kd, d, handleCompizEvent, kdecompatHandleCompizEvent);
842
 
 
843
 
    if (kd->scaleHandle                   &&
844
 
        strcmp (pluginName, "scale") == 0 &&
845
 
        strcmp (eventName, "activate") == 0)
846
 
    {
847
 
        Window     xid = getIntOptionNamed (option, nOption, "root", 0);
848
 
        CompScreen *s  = findScreenAtDisplay (d, xid);
849
 
 
850
 
        kd->scaleActive = getBoolOptionNamed (option, nOption, "active", FALSE);
851
 
 
852
 
        if (!kd->scaleActive && s)
853
 
        {
854
 
            KDECOMPAT_SCREEN (s);
855
 
 
856
 
            if (ks->presentWindow)
857
 
                XDeleteProperty (d->display, ks->presentWindow->id,
858
 
                                 kd->kdePresentGroupAtom);
859
 
        }
860
 
    }
861
 
}
862
 
 
863
 
static void
864
 
kdecompatHandleEvent (CompDisplay *d,
865
 
                      XEvent      *event)
866
 
{
867
 
    CompWindow *w;
868
 
 
869
 
    KDECOMPAT_DISPLAY (d);
870
 
 
871
 
    switch (event->type) {
872
 
    case DestroyNotify:
873
 
        w = findWindowAtDisplay (d, event->xdestroywindow.window);
874
 
        if (w)
875
 
            kdecompatHandleWindowClose (w, TRUE);
876
 
        break;
877
 
    case UnmapNotify:
878
 
        w = findWindowAtDisplay (d, event->xunmap.window);
879
 
        if (w && !w->pendingUnmaps)
880
 
            kdecompatHandleWindowClose (w, FALSE);
881
 
        break;
882
 
    case MapNotify:
883
 
        w = findWindowAtDisplay (d, event->xmap.window);
884
 
        if (w)
885
 
            kdecompatStopCloseAnimation (w);
886
 
        break;
887
 
    }
888
 
 
889
 
    UNWRAP (kd, d, handleEvent);
890
 
    (*d->handleEvent) (d, event);
891
 
    WRAP (kd, d, handleEvent, kdecompatHandleEvent);
892
 
 
893
 
    switch (event->type) {
894
 
    case PropertyNotify:
895
 
        if (event->xproperty.atom == kd->kdePreviewAtom)
896
 
        {
897
 
            w = findWindowAtDisplay (d, event->xproperty.window);
898
 
            if (w)
899
 
                kdecompatUpdatePreviews (w);
900
 
        }
901
 
        else if (event->xproperty.atom == kd->kdeSlideAtom)
902
 
        {
903
 
            w = findWindowAtDisplay (d, event->xproperty.window);
904
 
            if (w)
905
 
                kdecompatUpdateSlidePosition (w);
906
 
        }
907
 
        else if (event->xproperty.atom == kd->kdePresentGroupAtom)
908
 
        {
909
 
            w = findWindowAtDisplay (d, event->xproperty.window);
910
 
            if (w)
911
 
                kdecompatPresentWindowGroup (w);
912
 
        }
913
 
        break;
914
 
    }
915
 
}
916
 
 
917
 
static Bool
918
 
kdecompatDamageWindowRect (CompWindow *w,
919
 
                           Bool       initial,
920
 
                           BoxPtr     rect)
921
 
{
922
 
    Bool       status;
923
 
    CompScreen *s = w->screen;
924
 
 
925
 
    KDECOMPAT_SCREEN (s);
926
 
    KDECOMPAT_WINDOW (w);
927
 
 
928
 
    if (kw->isPreview && kdecompatGetPlasmaThumbnails (s))
929
 
    {
930
 
        CompWindow *cw;
931
 
        REGION     reg;
932
 
 
933
 
        reg.rects = &reg.extents;
934
 
        reg.numRects = 1;
935
 
 
936
 
        for (cw = s->windows; cw; cw = cw->next)
937
 
        {
938
 
            KdeCompatWindow *kcw = GET_KDECOMPAT_WINDOW (cw, ks);
939
 
            unsigned int    i;
940
 
 
941
 
            for (i = 0; i < kcw->nPreviews; i++)
942
 
            {
943
 
                if (kcw->previews[i].id != w->id)
944
 
                    continue;
945
 
 
946
 
                reg.extents.x1 = kcw->previews[i].thumb.x + cw->attrib.x;
947
 
                reg.extents.x2 = reg.extents.x1 + kcw->previews[i].thumb.width;
948
 
                reg.extents.y1 = kcw->previews[i].thumb.y + cw->attrib.y;
949
 
                reg.extents.y2 = reg.extents.y1 + kcw->previews[i].thumb.height;
950
 
 
951
 
                damageScreenRegion (s, &reg);
952
 
            }
953
 
        }
954
 
    }
955
 
 
956
 
    if (initial && kdecompatGetSlidingPopups (s))
957
 
        kdecompatStartSlideAnimation (w, TRUE);
958
 
 
959
 
    UNWRAP (ks, s, damageWindowRect);
960
 
    status = (*s->damageWindowRect) (w, initial, rect);
961
 
    WRAP (ks, s, damageWindowRect, kdecompatDamageWindowRect);
962
 
 
963
 
    return status;
964
 
}
965
 
 
966
 
static void
967
 
kdecompatAdvertiseSupport (CompScreen *s,
968
 
                           Atom       atom,
969
 
                           Bool       enable)
970
 
{
971
 
    if (enable)
972
 
    {
973
 
        unsigned char value = 0;
974
 
 
975
 
        XChangeProperty (s->display->display, s->root, atom, atom,
976
 
                         8, PropModeReplace, &value, 1);
977
 
    }
978
 
    else
979
 
    {
980
 
        XDeleteProperty (s->display->display, s->root, atom);
981
 
    }
982
 
}
983
 
 
984
 
static void
985
 
kdecompatScreenOptionChanged (CompScreen             *s,
986
 
                              CompOption             *opt,
987
 
                              KdecompatScreenOptions num)
988
 
{
989
 
    KDECOMPAT_DISPLAY (s->display);
990
 
 
991
 
    if (num == KdecompatScreenOptionPlasmaThumbnails)
992
 
        kdecompatAdvertiseSupport (s, kd->kdePreviewAtom, opt->value.b);
993
 
    else if (num == KdecompatScreenOptionSlidingPopups)
994
 
        kdecompatAdvertiseSupport (s, kd->kdeSlideAtom, opt->value.b);
995
 
    else if (num == KdecompatScreenOptionPresentWindows)
996
 
        kdecompatAdvertiseSupport (s, kd->kdePresentGroupAtom,
997
 
                                   opt->value.b && kd->scaleHandle);
998
 
}
999
 
 
1000
 
static Bool
1001
 
kdecompatInitDisplay (CompPlugin  *p,
1002
 
                      CompDisplay *d)
1003
 
{
1004
 
    KdeCompatDisplay *kd;
1005
 
 
1006
 
    if (!checkPluginABI ("core", CORE_ABIVERSION))
1007
 
        return FALSE;
1008
 
 
1009
 
    kd = malloc (sizeof (KdeCompatDisplay));
1010
 
    if (!kd)
1011
 
        return FALSE;
1012
 
 
1013
 
    kd->screenPrivateIndex = allocateScreenPrivateIndex (d);
1014
 
    if (kd->screenPrivateIndex < 0)
1015
 
    {
1016
 
        free (kd);
1017
 
        return FALSE;
1018
 
    }
1019
 
 
1020
 
    kd->kdePreviewAtom = XInternAtom (d->display, "_KDE_WINDOW_PREVIEW", 0);
1021
 
    kd->kdeSlideAtom = XInternAtom (d->display, "_KDE_SLIDE", 0);
1022
 
    kd->kdePresentGroupAtom = XInternAtom (d->display,
1023
 
                                           "_KDE_PRESENT_WINDOWS_GROUP", 0);
1024
 
 
1025
 
    kd->scaleHandle  = findActivePlugin ("scale");
1026
 
    kd->scaleActive  = FALSE;
1027
 
    kd->scaleTimeout = 0;
1028
 
 
1029
 
    WRAP (kd, d, handleEvent, kdecompatHandleEvent);
1030
 
    WRAP (kd, d, handleCompizEvent, kdecompatHandleCompizEvent);
1031
 
 
1032
 
    d->base.privates[displayPrivateIndex].ptr = kd;
1033
 
 
1034
 
    return TRUE;
1035
 
}
1036
 
 
1037
 
static void
1038
 
kdecompatFiniDisplay (CompPlugin  *p,
1039
 
                      CompDisplay *d)
1040
 
{
1041
 
    KDECOMPAT_DISPLAY (d);
1042
 
 
1043
 
    kdecompatFreeScaleTimeout (kd);
1044
 
 
1045
 
    freeScreenPrivateIndex (d, kd->screenPrivateIndex);
1046
 
 
1047
 
    UNWRAP (kd, d, handleEvent);
1048
 
    UNWRAP (kd, d, handleCompizEvent);
1049
 
 
1050
 
    free (kd);
1051
 
}
1052
 
 
1053
 
static Bool
1054
 
kdecompatInitScreen (CompPlugin *p,
1055
 
                     CompScreen *s)
1056
 
{
1057
 
    KdeCompatScreen *ks;
1058
 
 
1059
 
    KDECOMPAT_DISPLAY (s->display);
1060
 
 
1061
 
    ks = malloc (sizeof (KdeCompatScreen));
1062
 
    if (!ks)
1063
 
        return FALSE;
1064
 
 
1065
 
    ks->windowPrivateIndex = allocateWindowPrivateIndex (s);
1066
 
    if (ks->windowPrivateIndex < 0)
1067
 
    {
1068
 
        free (ks);
1069
 
        return FALSE;
1070
 
    }
1071
 
 
1072
 
    ks->hasSlidingPopups = FALSE;
1073
 
    ks->presentWindow    = NULL;
1074
 
 
1075
 
    kdecompatAdvertiseSupport (s, kd->kdePreviewAtom,
1076
 
                               kdecompatGetPlasmaThumbnails (s));
1077
 
    kdecompatAdvertiseSupport (s, kd->kdeSlideAtom,
1078
 
                               kdecompatGetSlidingPopups (s));
1079
 
    kdecompatAdvertiseSupport (s, kd->kdePresentGroupAtom,
1080
 
                               kdecompatGetPresentWindows (s) &&
1081
 
                               kd->scaleHandle);
1082
 
 
1083
 
    kdecompatSetPlasmaThumbnailsNotify (s, kdecompatScreenOptionChanged);
1084
 
    kdecompatSetSlidingPopupsNotify (s, kdecompatScreenOptionChanged);
1085
 
 
1086
 
    WRAP (ks, s, preparePaintScreen, kdecompatPreparePaintScreen);
1087
 
    WRAP (ks, s, paintOutput, kdecompatPaintOutput);
1088
 
    WRAP (ks, s, donePaintScreen, kdecompatDonePaintScreen);
1089
 
    WRAP (ks, s, paintWindow, kdecompatPaintWindow);
1090
 
    WRAP (ks, s, damageWindowRect, kdecompatDamageWindowRect);
1091
 
 
1092
 
    s->base.privates[kd->screenPrivateIndex].ptr = ks;
1093
 
 
1094
 
    return TRUE;
1095
 
}
1096
 
 
1097
 
static void
1098
 
kdecompatFiniScreen (CompPlugin *p,
1099
 
                     CompScreen *s)
1100
 
{
1101
 
    KDECOMPAT_SCREEN (s);
1102
 
    KDECOMPAT_DISPLAY (s->display);
1103
 
 
1104
 
    freeWindowPrivateIndex (s, ks->windowPrivateIndex);
1105
 
 
1106
 
    kdecompatAdvertiseSupport (s, kd->kdePreviewAtom, FALSE);
1107
 
    kdecompatAdvertiseSupport (s, kd->kdeSlideAtom, FALSE);
1108
 
    kdecompatAdvertiseSupport (s, kd->kdePresentGroupAtom, FALSE);
1109
 
 
1110
 
    UNWRAP (ks, s, preparePaintScreen);
1111
 
    UNWRAP (ks, s, paintOutput);
1112
 
    UNWRAP (ks, s, donePaintScreen);
1113
 
    UNWRAP (ks, s, paintWindow);
1114
 
    UNWRAP (ks, s, damageWindowRect);
1115
 
 
1116
 
    free (ks);
1117
 
}
1118
 
 
1119
 
static Bool
1120
 
kdecompatInitWindow (CompPlugin *p,
1121
 
                     CompWindow *w)
1122
 
{
1123
 
    KdeCompatWindow *kw;
1124
 
 
1125
 
    KDECOMPAT_SCREEN (w->screen);
1126
 
 
1127
 
    kw = malloc (sizeof (KdeCompatWindow));
1128
 
    if (!kw)
1129
 
        return FALSE;
1130
 
 
1131
 
    kw->previews  = NULL;
1132
 
    kw->nPreviews = 0;
1133
 
    kw->isPreview = FALSE;
1134
 
 
1135
 
    kw->slideData = NULL;
1136
 
 
1137
 
    kw->unmapCnt   = 0;
1138
 
    kw->destroyCnt = 0;
1139
 
 
1140
 
    w->base.privates[ks->windowPrivateIndex].ptr = kw;
1141
 
 
1142
 
    return TRUE;
1143
 
}
1144
 
 
1145
 
static void
1146
 
kdecompatFiniWindow (CompPlugin *p,
1147
 
                     CompWindow *w)
1148
 
{
1149
 
    KDECOMPAT_WINDOW (w);
1150
 
    KDECOMPAT_SCREEN (w->screen);
1151
 
 
1152
 
    if (ks->presentWindow == w)
1153
 
        ks->presentWindow = NULL;
1154
 
 
1155
 
    kdecompatStopCloseAnimation (w);
1156
 
 
1157
 
    if (kw->previews)
1158
 
        free (kw->previews);
1159
 
 
1160
 
    if (kw->slideData)
1161
 
        free (kw->slideData);
1162
 
 
1163
 
    free (kw);
1164
 
}
1165
 
 
1166
 
static CompBool
1167
 
kdecompatInitObject (CompPlugin *p,
1168
 
                     CompObject *o)
1169
 
{
1170
 
    static InitPluginObjectProc dispTab[] = {
1171
 
        (InitPluginObjectProc) 0, /* InitCore */
1172
 
        (InitPluginObjectProc) kdecompatInitDisplay,
1173
 
        (InitPluginObjectProc) kdecompatInitScreen,
1174
 
        (InitPluginObjectProc) kdecompatInitWindow
1175
 
    };
1176
 
 
1177
 
    RETURN_DISPATCH (o, dispTab, ARRAY_SIZE (dispTab), TRUE, (p, o));
1178
 
}
1179
 
 
1180
 
static void
1181
 
kdecompatFiniObject (CompPlugin *p,
1182
 
                     CompObject *o)
1183
 
{
1184
 
    static FiniPluginObjectProc dispTab[] = {
1185
 
        (FiniPluginObjectProc) 0, /* FiniCore */
1186
 
        (FiniPluginObjectProc) kdecompatFiniDisplay,
1187
 
        (FiniPluginObjectProc) kdecompatFiniScreen,
1188
 
        (FiniPluginObjectProc) kdecompatFiniWindow
1189
 
    };
1190
 
 
1191
 
    DISPATCH (o, dispTab, ARRAY_SIZE (dispTab), (p, o));
1192
 
}
1193
 
 
1194
 
static Bool
1195
 
kdecompatInit (CompPlugin *p)
1196
 
{
1197
 
    displayPrivateIndex = allocateDisplayPrivateIndex ();
1198
 
    if (displayPrivateIndex < 0)
1199
 
        return FALSE;
1200
 
 
1201
 
    return TRUE;
1202
 
}
1203
 
 
1204
 
static void
1205
 
kdecompatFini (CompPlugin *p)
1206
 
{
1207
 
    freeDisplayPrivateIndex (displayPrivateIndex);
1208
 
}
1209
 
 
1210
 
CompPluginVTable kdecompatVTable = {
1211
 
    "kdecompat",
1212
 
    0,
1213
 
    kdecompatInit,
1214
 
    kdecompatFini,
1215
 
    kdecompatInitObject,
1216
 
    kdecompatFiniObject,
1217
 
    0,
1218
 
    0
1219
 
};
1220
 
 
1221
 
CompPluginVTable *
1222
 
getCompPluginInfo (void)
1223
 
{
1224
 
    return &kdecompatVTable;
1225
 
}
1226