← Back to branch summary

~ubuntu-branches/ubuntu/precise/compiz/precise

« back to all changes in this revision

Viewing changes to .pc/fix_931927.patch/src/plugin.cpp

  • Committer: Package Import Robot
  • Author(s): Didier Roche, Łukasz 'sil2100' Zemczak, Didier Roche
  • Date: 2012-03-12 10:22:10 UTC
  • mfrom: (0.168.15)
  • Revision ID: package-import@ubuntu.com-20120312102210-e248pzbccr7r2tdq
Tags: 1:0.9.7.0+bzr3035-0ubuntu1
https://launchpad.net/bugs/930071
https://launchpad.net/bugs/930412
https://launchpad.net/bugs/931283
https://launchpad.net/bugs/925293
https://launchpad.net/bugs/933226
https://launchpad.net/bugs/924736
https://launchpad.net/bugs/780505
https://launchpad.net/bugs/932087
https://launchpad.net/bugs/931927
https://launchpad.net/bugs/936675
https://launchpad.net/bugs/936778
https://launchpad.net/bugs/936774
https://launchpad.net/bugs/934058
https://launchpad.net/bugs/936781
https://launchpad.net/bugs/936487
https://launchpad.net/bugs/940115
https://launchpad.net/bugs/938478
https://launchpad.net/bugs/940139
https://launchpad.net/bugs/940066
https://launchpad.net/bugs/871801
https://launchpad.net/bugs/936784
https://launchpad.net/bugs/942890
https://launchpad.net/bugs/943116
https://launchpad.net/bugs/943223
https://launchpad.net/bugs/943612
https://launchpad.net/bugs/944631
https://launchpad.net/bugs/943851
https://launchpad.net/bugs/945373
https://launchpad.net/bugs/944979
https://launchpad.net/bugs/806255
https://launchpad.net/bugs/943194
[ Łukasz 'sil2100' Zemczak ]
* New upstream snapshot:
  - Fix gtk-window-decorator crash upon demaximizing a window (LP: #930071)
  - Fix core keybindings (LP: #930412)
  - Fixes compiz crash with SIGSEGV on shutdown (LP: #931283)
  - Plugins can't tell the difference between a key-tap and modifier
    key-release (LP: #925293)
  - compiz-core r3001 (and 3002) ftbfs (LP: #933226)
  - Semi-maximized windows have no shadow or frame (LP: #924736)
  - Untranslated strings in gtk-window-decorator (LP: #780505)
  - Initialize the _NET_WM_STATE_FOCUSED (LP: #932087)
  - [regression] Customized shortcuts don't work (LP: #931927)
  - Window stacking problem (LP: #936675)
  - Quickly demaximized windows can receive maximized window decorations if 
    they were initially maximized (LP: #936778)
  - Maximized windows do not get shadows at all (LP: #936774)
  - [regression] Launcher, top panel and keyboard un-responsive after using 
    any Super-x shortcut (LP: #934058)
  - No draggable border if mutter isn't installed (LP: #936781)
  - Fix compiz crash with SIGSEGV in XDefineCursor() (LP: #936487)
  - Fixes memory leak at DecorWindow::updateSwitcher() (LP: #940115)
  - Unresolved symbols in plugins cause compiz to exit (LP: #938478)
  - Fix compiz spending about 51% of its CPU time in CompRegion 
    construction/destruction (LP: #940139)
  - Fix Conditional jump or move depends on uninitialised value(s) in 
    decor_match_pixmap (LP: #940066)
  - Fix 'show desktop' behaviour (LP: #871801)
  - Tweak algorithm used to cast shadows on maximized windows (LP: #936784)
  - "Svg" and "Png" should be "SVG and "PNG" (LP: #942890)
  - Fix invalid memory usage after free() in DecorWindow (LP: #943116)
  - Fix alt + F10 (LP: #943223)
* Removed cherry-picked patches
* debian/patches/fix_944631.patch:
  - Always replay the keyboard if something was grabbed and didn't trigger 
    an action and don't trigger actions which aren't added accidentally 
    (LP: #943612) (LP: #944631)
* debian/patches/fix_923683.patch:
  - Backports a patch which prevents the shift race condition

[ Didier Roche ]
* debian/patches/fix_alt_pressing.patch:
  - Patch from ddv to fix all the regressions with the alt key fix and other
    (LP: #943851, #945373)
  - Fix Quicklist are not showing if right-clicking a launcher icon in Expo
    mode if triggered by Super + S (LP: #944979)
* debian/patches/fix_806255.patch:
  - Unity/compiz intercepts keystrokes from grabbed windows (LP: #806255)
* debian/patches/fix_943194.patch:
  - second part for the alt key fix (LP: #943194)
* debian/patches/additional_alt_tapping_fix.patch:
  - again another alt tapping related fix for some regressions from the
    previous branch. Taken from "tapping-panacea" upstream branch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/fix_931927.patch/src/plugin.cpp
1
 
/*
2
 
 * Copyright © 2005 Novell, Inc.
3
 
 *
4
 
 * Permission to use, copy, modify, distribute, and sell this software
5
 
 * and its documentation for any purpose is hereby granted without
6
 
 * fee, provided that the above copyright notice appear in all copies
7
 
 * and that both that copyright notice and this permission notice
8
 
 * appear in supporting documentation, and that the name of
9
 
 * Novell, Inc. not be used in advertising or publicity pertaining to
10
 
 * distribution of the software without specific, written prior permission.
11
 
 * Novell, Inc. makes no representations about the suitability of this
12
 
 * software for any purpose. It is provided "as is" without express or
13
 
 * implied warranty.
14
 
 *
15
 
 * NOVELL, INC. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
16
 
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
17
 
 * NO EVENT SHALL NOVELL, INC. BE LIABLE FOR ANY SPECIAL, INDIRECT OR
18
 
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
19
 
 * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
20
 
 * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
21
 
 * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
22
 
 *
23
 
 * Author: David Reveman <davidr@novell.com>
24
 
 */
25
 
 
26
 
#include "core/plugin.h"
27
 
#include "privatescreen.h"
28
 
 
29
 
#include <boost/scoped_array.hpp>
30
 
#include <boost/foreach.hpp>
31
 
 
32
 
#include <stdio.h>
33
 
#include <stdlib.h>
34
 
#include <string.h>
35
 
#include <dlfcn.h>
36
 
#include <dirent.h>
37
 
#include <errno.h>
38
 
#include <sys/stat.h>
39
 
#include <sys/types.h>
40
 
 
41
 
#include <algorithm>
42
 
#include <set>
43
 
 
44
 
#define foreach BOOST_FOREACH
45
 
 
46
 
 
47
 
CompPlugin::Map pluginsMap;
48
 
CompPlugin::List plugins;
49
 
 
50
 
class CorePluginVTable : public CompPlugin::VTable
51
 
{
52
 
    public:
53
 
 
54
 
        bool init ();
55
 
 
56
 
        CompOption::Vector & getOptions ();
57
 
 
58
 
        bool setOption (const CompString  &name,
59
 
                        CompOption::Value &value);
60
 
};
61
 
 
62
 
COMPIZ_PLUGIN_20090315 (core, CorePluginVTable)
63
 
 
64
 
CompPlugin::VTable * getCoreVTable ()
65
 
{
66
 
    if (!coreVTable)
67
 
    {
68
 
        return getCompPluginVTable20090315_core ();
69
 
    }
70
 
 
71
 
    return coreVTable;
72
 
}
73
 
 
74
 
bool
75
 
CorePluginVTable::init ()
76
 
{
77
 
    return true;
78
 
}
79
 
 
80
 
CompOption::Vector &
81
 
CorePluginVTable::getOptions ()
82
 
{
83
 
    return screen->getOptions ();
84
 
}
85
 
 
86
 
bool
87
 
CorePluginVTable::setOption (const CompString  &name,
88
 
                             CompOption::Value &value)
89
 
{
90
 
    return screen->setOption (name, value);
91
 
}
92
 
 
93
 
static bool
94
 
cloaderLoadPlugin (CompPlugin *p,
95
 
                   const char *path,
96
 
                   const char *name)
97
 
{
98
 
    if (path)
99
 
        return false;
100
 
 
101
 
    if (strcmp (name, getCoreVTable ()->name ().c_str ()))
102
 
        return false;
103
 
 
104
 
    p->vTable         = getCoreVTable ();
105
 
    p->devPrivate.ptr = NULL;
106
 
    p->devType        = "cloader";
107
 
 
108
 
    return true;
109
 
}
110
 
 
111
 
static void
112
 
cloaderUnloadPlugin (CompPlugin *p)
113
 
{
114
 
    delete p->vTable;
115
 
}
116
 
 
117
 
static CompStringList
118
 
cloaderListPlugins (const char *path)
119
 
{
120
 
    CompStringList rv;
121
 
 
122
 
    if (path)
123
 
        return CompStringList ();
124
 
 
125
 
    rv.push_back (CompString (getCoreVTable ()->name ()));
126
 
 
127
 
    return rv;
128
 
}
129
 
 
130
 
static bool
131
 
dlloaderLoadPlugin (CompPlugin *p,
132
 
                    const char *path,
133
 
                    const char *name)
134
 
{
135
 
    CompString  file;
136
 
    void        *dlhand;
137
 
    bool        loaded = false;
138
 
    struct stat fileInfo;
139
 
 
140
 
    if (cloaderLoadPlugin (p, path, name))
141
 
        return true;
142
 
 
143
 
    if (path)
144
 
    {
145
 
        file  = path;
146
 
        file += "/";
147
 
    }
148
 
 
149
 
    file += "lib";
150
 
    file += name;
151
 
    file += ".so";
152
 
 
153
 
    if (stat (file.c_str (), &fileInfo) != 0)
154
 
    {
155
 
        /* file likely not present */
156
 
        compLogMessage ("core", CompLogLevelDebug,
157
 
                        "Could not stat() file %s : %s",
158
 
                        file.c_str (), strerror (errno));
159
 
        return false;
160
 
    }
161
 
 
162
 
    int open_flags = RTLD_LAZY;
163
 
#ifdef DEBUG
164
 
    // Do not unload the library during dlclose.
165
 
    open_flags |= RTLD_NODELETE;
166
 
    // Make the symbols available globally
167
 
    open_flags |= RTLD_GLOBAL;
168
 
#endif
169
 
    dlhand = dlopen (file.c_str (), open_flags);
170
 
    if (dlhand)
171
 
    {
172
 
        PluginGetInfoProc getInfo;
173
 
        char              *error;
174
 
        char              sym[1024];
175
 
 
176
 
        dlerror ();
177
 
 
178
 
        snprintf (sym, 1024, "getCompPluginVTable20090315_%s", name);
179
 
        getInfo = (PluginGetInfoProc) dlsym (dlhand, sym);
180
 
 
181
 
        error = dlerror ();
182
 
        if (error)
183
 
        {
184
 
            compLogMessage ("core", CompLogLevelError, "dlsym: %s", error);
185
 
            getInfo = 0;
186
 
        }
187
 
 
188
 
        if (getInfo)
189
 
        {
190
 
            p->vTable = (*getInfo) ();
191
 
            if (!p->vTable)
192
 
            {
193
 
                compLogMessage ("core", CompLogLevelError,
194
 
                                "Couldn't get vtable from '%s' plugin",
195
 
                                file.c_str ());
196
 
            }
197
 
            else
198
 
            {
199
 
                p->devPrivate.ptr = dlhand;
200
 
                p->devType        = "dlloader";
201
 
                loaded            = true;
202
 
            }
203
 
        }
204
 
    }
205
 
    else
206
 
    {
207
 
        compLogMessage ("core", CompLogLevelError,
208
 
                        "Couldn't load plugin '%s' : %s",
209
 
                        file.c_str (), dlerror ());
210
 
    }
211
 
 
212
 
    if (!loaded && dlhand)
213
 
        dlclose (dlhand);
214
 
 
215
 
    return loaded;
216
 
}
217
 
 
218
 
static void
219
 
dlloaderUnloadPlugin (CompPlugin *p)
220
 
{
221
 
    if (p->devType == "dlloader")
222
 
    {
223
 
        delete p->vTable;
224
 
        dlclose (p->devPrivate.ptr);
225
 
    }
226
 
    else
227
 
        cloaderUnloadPlugin (p);
228
 
}
229
 
 
230
 
static int
231
 
dlloaderFilter (const struct dirent *name)
232
 
{
233
 
    int length = strlen (name->d_name);
234
 
 
235
 
    if (length < 7)
236
 
        return 0;
237
 
 
238
 
    if (strncmp (name->d_name, "lib", 3) ||
239
 
        strncmp (name->d_name + length - 3, ".so", 3))
240
 
        return 0;
241
 
 
242
 
    return 1;
243
 
}
244
 
 
245
 
static CompStringList
246
 
dlloaderListPlugins (const char *path)
247
 
{
248
 
    struct dirent **nameList;
249
 
    char          name[1024];
250
 
    int           length, nFile, i;
251
 
 
252
 
    CompStringList rv = cloaderListPlugins (path);
253
 
 
254
 
    if (!path)
255
 
        path = ".";
256
 
 
257
 
    nFile = scandir (path, &nameList, dlloaderFilter, alphasort);
258
 
    if (!nFile)
259
 
        return rv;
260
 
 
261
 
    for (i = 0; i < nFile; i++)
262
 
    {
263
 
        length = strlen (nameList[i]->d_name);
264
 
 
265
 
        strncpy (name, nameList[i]->d_name + 3, length - 6);
266
 
        name[length - 6] = '\0';
267
 
 
268
 
        rv.push_back (CompString (name));
269
 
    }
270
 
 
271
 
    return rv;
272
 
}
273
 
 
274
 
LoadPluginProc   loaderLoadPlugin   = dlloaderLoadPlugin;
275
 
UnloadPluginProc loaderUnloadPlugin = dlloaderUnloadPlugin;
276
 
ListPluginsProc  loaderListPlugins  = dlloaderListPlugins;
277
 
 
278
 
 
279
 
bool
280
 
CompManager::initPlugin (CompPlugin *p)
281
 
{
282
 
 
283
 
    if (!p->vTable->init ())
284
 
    {
285
 
        compLogMessage ("core", CompLogLevelError,
286
 
                        "InitPlugin '%s' failed", p->vTable->name ().c_str ());
287
 
        return false;
288
 
    }
289
 
 
290
 
    if (screen && screen->priv->initialized)
291
 
    {
292
 
        if (!p->vTable->initScreen (screen))
293
 
        {
294
 
            compLogMessage (p->vTable->name ().c_str (), CompLogLevelError,
295
 
                            "initScreen failed");
296
 
            p->vTable->fini ();
297
 
            return false;
298
 
        }
299
 
        if (!screen->initPluginForScreen (p))
300
 
        {
301
 
            p->vTable->fini ();
302
 
            return false;
303
 
        }
304
 
    }
305
 
 
306
 
    return true;
307
 
}
308
 
 
309
 
void
310
 
CompManager::finiPlugin (CompPlugin *p)
311
 
{
312
 
 
313
 
    if (screen)
314
 
    {
315
 
        screen->finiPluginForScreen (p);
316
 
        p->vTable->finiScreen (screen);
317
 
    }
318
 
 
319
 
    p->vTable->fini ();
320
 
}
321
 
 
322
 
bool
323
 
CompScreen::initPluginForScreen (CompPlugin *p)
324
 
{
325
 
    WRAPABLE_HND_FUNCTN_RETURN (bool, initPluginForScreen, p)
326
 
    return _initPluginForScreen (p);
327
 
}
328
 
 
329
 
bool
330
 
CompScreenImpl::_initPluginForScreen (CompPlugin *p)
331
 
{
332
 
    bool status               = true;
333
 
    CompWindowList::iterator it, fail;
334
 
    CompWindow               *w;
335
 
 
336
 
    it = fail = priv->windows.begin ();
337
 
    for (;it != priv->windows.end (); it++)
338
 
    {
339
 
        w = *it;
340
 
        if (!p->vTable->initWindow (w))
341
 
        {
342
 
            compLogMessage (p->vTable->name ().c_str (), CompLogLevelError,
343
 
                            "initWindow failed");
344
 
            fail   = it;
345
 
            status = false;
346
 
        }
347
 
    }
348
 
 
349
 
    it = priv->windows.begin ();
350
 
    for (;it != fail; it++)
351
 
    {
352
 
        w = *it;
353
 
        p->vTable->finiWindow (w);
354
 
    }
355
 
 
356
 
    return status;
357
 
}
358
 
 
359
 
void
360
 
CompScreen::finiPluginForScreen (CompPlugin *p)
361
 
{
362
 
    WRAPABLE_HND_FUNCTN (finiPluginForScreen, p)
363
 
    _finiPluginForScreen (p);
364
 
}
365
 
 
366
 
void
367
 
CompScreenImpl::_finiPluginForScreen (CompPlugin *p)
368
 
{
369
 
    foreach (CompWindow *w, priv->windows)
370
 
        p->vTable->finiWindow (w);
371
 
}
372
 
 
373
 
bool
374
 
CompPlugin::screenInitPlugins (CompScreen *s)
375
 
{
376
 
    CompPlugin::List::reverse_iterator it = plugins.rbegin ();
377
 
 
378
 
    CompPlugin *p = NULL;
379
 
 
380
 
    /* Plugins is a btf list, so iterate it in reverse */
381
 
    while (it != plugins.rend ())
382
 
    {
383
 
        p = (*it);
384
 
 
385
 
        if (p->vTable->initScreen (s))
386
 
            s->initPluginForScreen (p);
387
 
 
388
 
        it++;
389
 
    }
390
 
 
391
 
    return true;
392
 
}
393
 
 
394
 
void
395
 
CompPlugin::screenFiniPlugins (CompScreen *s)
396
 
{
397
 
    foreach (CompPlugin *p, plugins)
398
 
    {
399
 
        s->finiPluginForScreen (p);
400
 
        p->vTable->finiScreen (s);
401
 
    }
402
 
 
403
 
}
404
 
 
405
 
bool
406
 
CompPlugin::windowInitPlugins (CompWindow *w)
407
 
{
408
 
    bool status = true;
409
 
 
410
 
    for (List::reverse_iterator rit = plugins.rbegin ();
411
 
         rit != plugins.rend (); ++rit)
412
 
    {
413
 
        status &= (*rit)->vTable->initWindow (w);
414
 
    }
415
 
 
416
 
    return status;
417
 
}
418
 
 
419
 
void
420
 
CompPlugin::windowFiniPlugins (CompWindow *w)
421
 
{
422
 
    foreach (CompPlugin *p, plugins)
423
 
    {
424
 
        p->vTable->finiWindow (w);
425
 
    }
426
 
}
427
 
 
428
 
 
429
 
CompPlugin *
430
 
CompPlugin::find (const char *name)
431
 
{
432
 
    CompPlugin::Map::iterator it = pluginsMap.find (name);
433
 
 
434
 
    if (it != pluginsMap.end ())
435
 
        return it->second;
436
 
 
437
 
    return NULL;
438
 
}
439
 
 
440
 
void
441
 
CompPlugin::unload (CompPlugin *p)
442
 
{
443
 
    loaderUnloadPlugin (p);
444
 
    delete p;
445
 
}
446
 
 
447
 
CompPlugin *
448
 
CompPlugin::load (const char *name)
449
 
{
450
 
    std::auto_ptr<CompPlugin>p(new CompPlugin ());
451
 
 
452
 
    p->devPrivate.uval = 0;
453
 
    p->devType         = "";
454
 
    p->vTable          = 0;
455
 
 
456
 
 
457
 
    if (char* home = getenv ("HOME"))
458
 
    {
459
 
        boost::scoped_array<char> plugindir(new char [strlen (home) + strlen (HOME_PLUGINDIR) + 3]);
460
 
        sprintf (plugindir.get(), "%s/%s", home, HOME_PLUGINDIR);
461
 
 
462
 
        if (loaderLoadPlugin (p.get(), plugindir.get(), name))
463
 
            return p.release();
464
 
    }
465
 
 
466
 
    if (loaderLoadPlugin (p.get(), PLUGINDIR, name))
467
 
        return p.release();
468
 
 
469
 
    if (loaderLoadPlugin (p.get(), NULL, name))
470
 
        return p.release();
471
 
 
472
 
    compLogMessage ("core", CompLogLevelError,
473
 
                    "Couldn't load plugin '%s'", name);
474
 
 
475
 
    return 0;
476
 
}
477
 
 
478
 
bool
479
 
CompPlugin::push (CompPlugin *p)
480
 
{
481
 
    const char *name = p->vTable->name ().c_str ();
482
 
 
483
 
    std::pair<CompPlugin::Map::iterator, bool> insertRet =
484
 
        pluginsMap.insert (std::pair<const char *, CompPlugin *> (name, p));
485
 
 
486
 
    if (!insertRet.second)
487
 
    {
488
 
        compLogMessage ("core", CompLogLevelWarn,
489
 
                        "Plugin '%s' already active",
490
 
                        p->vTable->name ().c_str ());
491
 
 
492
 
        return false;
493
 
    }
494
 
 
495
 
    plugins.push_front (p);
496
 
 
497
 
    if (!CompManager::initPlugin (p))
498
 
    {
499
 
        compLogMessage ("core", CompLogLevelError,
500
 
                        "Couldn't activate plugin '%s'", name);
501
 
 
502
 
        pluginsMap.erase (name);
503
 
        plugins.pop_front ();
504
 
 
505
 
        return false;
506
 
    }
507
 
 
508
 
    return true;
509
 
}
510
 
 
511
 
CompPlugin *
512
 
CompPlugin::pop (void)
513
 
{
514
 
    if (plugins.empty ())
515
 
        return NULL;
516
 
 
517
 
    CompPlugin *p = plugins.front ();
518
 
 
519
 
    if (!p)
520
 
        return 0;
521
 
 
522
 
    pluginsMap.erase (p->vTable->name ().c_str ());
523
 
 
524
 
    CompManager::finiPlugin (p);
525
 
 
526
 
    plugins.pop_front ();
527
 
 
528
 
    return p;
529
 
}
530
 
 
531
 
CompPlugin::List &
532
 
CompPlugin::getPlugins (void)
533
 
{
534
 
    return plugins;
535
 
}
536
 
 
537
 
CompStringList
538
 
CompPlugin::availablePlugins ()
539
 
{
540
 
    CompStringList homeList;
541
 
 
542
 
    if (char* home = getenv ("HOME"))
543
 
    {
544
 
        boost::scoped_array<char> plugindir(new char [strlen (home) + strlen (HOME_PLUGINDIR) + 3]);
545
 
        sprintf (plugindir.get(), "%s/%s", home, HOME_PLUGINDIR);
546
 
 
547
 
        homeList = loaderListPlugins (plugindir.get());
548
 
    }
549
 
 
550
 
    std::set<CompString> set;
551
 
 
552
 
    CompStringList pluginList  = loaderListPlugins (PLUGINDIR);
553
 
    CompStringList currentList = loaderListPlugins (0);
554
 
 
555
 
    std::copy(homeList.begin(), homeList.end(), std::inserter(set, set.end()));
556
 
    std::copy(pluginList.begin(), pluginList.end(), std::inserter(set, set.end()));
557
 
    std::copy(currentList.begin(), currentList.end(), std::inserter(set, set.end()));
558
 
 
559
 
    return CompStringList(set.begin(), set.end());
560
 
}
561
 
 
562
 
int
563
 
CompPlugin::getPluginABI (const char *name)
564
 
{
565
 
    CompPlugin *p = find (name);
566
 
    CompString s = name;
567
 
 
568
 
    if (!p)
569
 
        return 0;
570
 
 
571
 
    s += "_ABI";
572
 
 
573
 
    if (!screen->hasValue (s))
574
 
        return 0;
575
 
 
576
 
    return screen->getValue (s).uval;
577
 
}
578
 
 
579
 
bool
580
 
CompPlugin::checkPluginABI (const char *name,
581
 
                            int        abi)
582
 
{
583
 
    int pluginABI;
584
 
 
585
 
    pluginABI = getPluginABI (name);
586
 
    if (!pluginABI)
587
 
    {
588
 
        compLogMessage ("core", CompLogLevelError,
589
 
                        "Plugin '%s' not loaded.\n", name);
590
 
        return false;
591
 
    }
592
 
    else if (pluginABI != abi)
593
 
    {
594
 
        compLogMessage ("core", CompLogLevelError,
595
 
                        "Plugin '%s' has ABI version '%d', expected "
596
 
                        "ABI version '%d'.\n",
597
 
                        name, pluginABI, abi);
598
 
        return false;
599
 
    }
600
 
 
601
 
    return true;
602
 
}
603
 
 
604
 
CompPlugin::VTable::VTable () :
605
 
    mName (""),
606
 
    mSelf (NULL)
607
 
{
608
 
}
609
 
 
610
 
CompPlugin::VTable::~VTable ()
611
 
{
612
 
    if (mSelf)
613
 
        *mSelf = NULL;
614
 
}
615
 
 
616
 
void
617
 
CompPlugin::VTable::initVTable (CompString         name,
618
 
                                CompPlugin::VTable **self)
619
 
{
620
 
    mName = name;
621
 
    if (self)
622
 
    {
623
 
        mSelf = self;
624
 
        *mSelf = this;
625
 
    }
626
 
}
627
 
 
628
 
const CompString
629
 
CompPlugin::VTable::name () const
630
 
{
631
 
    return mName;
632
 
}
633
 
 
634
 
void
635
 
CompPlugin::VTable::fini ()
636
 
{
637
 
}
638
 
 
639
 
bool
640
 
CompPlugin::VTable::initScreen (CompScreen *)
641
 
{
642
 
    return true;
643
 
}
644
 
 
645
 
void
646
 
CompPlugin::VTable::finiScreen (CompScreen *)
647
 
{
648
 
}
649
 
 
650
 
bool
651
 
CompPlugin::VTable::initWindow (CompWindow *)
652
 
{
653
 
    return true;
654
 
}
655
 
 
656
 
void
657
 
CompPlugin::VTable::finiWindow (CompWindow *)
658
 
{
659
 
}
660
 
 
661
 
CompOption::Vector &
662
 
CompPlugin::VTable::getOptions ()
663
 
{
664
 
    return noOptions;
665
 
}
666
 
 
667
 
bool
668
 
CompPlugin::VTable::setOption (const CompString  &name,
669
 
                               CompOption::Value &value)
670
 
{
671
 
    return false;
672
 
}