← Back to branch summary

~ubuntu-branches/ubuntu/utopic/kde-workspace/utopic-proposed

« back to all changes in this revision

Viewing changes to kwin/scripting/meta.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Michał Zając
  • Date: 2011-07-09 08:31:15 UTC
  • Revision ID: james.westby@ubuntu.com-20110709083115-ohyxn6z93mily9fc
Tags: upstream-4.6.90
Import upstream version 4.6.90

Show diffs side-by-side

added added

removed removed

Lines of Context:
kwin/scripting/meta.cpp
 
1
/********************************************************************
 
2
 KWin - the KDE window manager
 
3
 This file is part of the KDE project.
 
4
 
 
5
Copyright (C) 2010 Rohan Prabhu <rohan@rohanprabhu.com>
 
6
 
 
7
This program is free software; you can redistribute it and/or modify
 
8
it under the terms of the GNU General Public License as published by
 
9
the Free Software Foundation; either version 2 of the License, or
 
10
(at your option) any later version.
 
11
 
 
12
This program is distributed in the hope that it will be useful,
 
13
but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
15
GNU General Public License for more details.
 
16
 
 
17
You should have received a copy of the GNU General Public License
 
18
along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
19
*********************************************************************/
 
20
 
 
21
#include "meta.h"
 
22
 
 
23
Q_DECLARE_METATYPE(SWrapper::Client*)
 
24
Q_DECLARE_METATYPE(SWrapper::ClientGroup*)
 
25
 
 
26
using namespace KWin::MetaScripting;
 
27
 
 
28
// Wrapper for KWin::Client* objects
 
29
QScriptValue Client::toScriptValue(QScriptEngine* eng, const KClientRef& client)
 
30
{
 
31
    return SWrapper::Client::generate(client, eng);
 
32
}
 
33
 
 
34
void Client::fromScriptValue(const QScriptValue& obj, KWin::Client*& client)
 
35
{
 
36
    SWrapper::Client* wrapper = qscriptvalue_cast<SWrapper::Client*>(obj);
 
37
 
 
38
    if (wrapper == 0) {
 
39
        client = 0;
 
40
    } else {
 
41
        client = wrapper->getCentralObject();
 
42
    }
 
43
}
 
44
// End of metas for KWin::Client* objects
 
45
 
 
46
// Meta for KWin::ClientGroup* objects
 
47
QScriptValue ClientGroup::toScriptValue(QScriptEngine* eng, const KClientGroupRef& cGrp)
 
48
{
 
49
    return SWrapper::ClientGroup::generate(eng, new SWrapper::ClientGroup(cGrp));
 
50
}
 
51
 
 
52
void ClientGroup::fromScriptValue(const QScriptValue& obj, KWin::ClientGroup*& cGrp)
 
53
{
 
54
    SWrapper::ClientGroup* wrapper = qscriptvalue_cast<SWrapper::ClientGroup*>(obj);
 
55
 
 
56
    if (wrapper == 0) {
 
57
        cGrp = 0;
 
58
    } else {
 
59
        cGrp = wrapper->getCentralObject();
 
60
    }
 
61
}
 
62
// End of metas for KWin::ClientGroup* objects
 
63
 
 
64
// Wrapper for KWin::Toplevel* objects [ONE DIRTY HACK]
 
65
QScriptValue Toplevel::toScriptValue(QScriptEngine* eng, const KToplevelRef& tlevel)
 
66
{
 
67
    Q_UNUSED(eng)
 
68
    Q_UNUSED(tlevel)
 
69
    return QScriptValue();
 
70
}
 
71
 
 
72
void Toplevel::fromScriptValue(const QScriptValue& obj, KWin::Toplevel*& tlevel)
 
73
{
 
74
    SWrapper::Client* wrapper = qscriptvalue_cast<SWrapper::Client*>(obj);
 
75
    if (wrapper == 0) {
 
76
        tlevel = 0;
 
77
    } else {
 
78
        tlevel = static_cast<KWin::Client*>(wrapper->getCentralObject());
 
79
    }
 
80
}
 
81
// End of wrapper for KWin::Toplevel* object
 
82
 
 
83
// Meta for QPoint object
 
84
QScriptValue Point::toScriptValue(QScriptEngine* eng, const QPoint& point)
 
85
{
 
86
    QScriptValue temp = eng->newObject();
 
87
    temp.setProperty("x", point.x());
 
88
    temp.setProperty("y", point.y());
 
89
    return temp;
 
90
}
 
91
 
 
92
void Point::fromScriptValue(const QScriptValue& obj, QPoint& point)
 
93
{
 
94
    QScriptValue x = obj.property("x", QScriptValue::ResolveLocal);
 
95
    QScriptValue y = obj.property("y", QScriptValue::ResolveLocal);
 
96
 
 
97
    if (!x.isUndefined() && !y.isUndefined()) {
 
98
        point.setX(x.toInt32());
 
99
        point.setY(y.toInt32());
 
100
    }
 
101
}
 
102
// End of meta for QPoint object
 
103
 
 
104
// Meta for QSize object
 
105
QScriptValue Size::toScriptValue(QScriptEngine* eng, const QSize& size)
 
106
{
 
107
    QScriptValue temp = eng->newObject();
 
108
    temp.setProperty("w", size.width());
 
109
    temp.setProperty("h", size.height());
 
110
    return temp;
 
111
}
 
112
 
 
113
void Size::fromScriptValue(const QScriptValue& obj, QSize& size)
 
114
{
 
115
    QScriptValue w = obj.property("w", QScriptValue::ResolveLocal);
 
116
    QScriptValue h = obj.property("h", QScriptValue::ResolveLocal);
 
117
 
 
118
    if (!w.isUndefined() && !h.isUndefined()) {
 
119
        size.setWidth(w.toInt32());
 
120
        size.setHeight(h.toInt32());
 
121
    }
 
122
}
 
123
// End of meta for QSize object
 
124
 
 
125
// Meta for QRect object. Just a temporary measure, hope to
 
126
// add a much better wrapping of the QRect object soon
 
127
QScriptValue Rect::toScriptValue(QScriptEngine* eng, const QRect& rect)
 
128
{
 
129
    QScriptValue temp = eng->newObject();
 
130
    temp.setProperty("x", rect.x());
 
131
    temp.setProperty("y", rect.y());
 
132
    temp.setProperty("width", rect.width());
 
133
    temp.setProperty("height", rect.height());
 
134
 
 
135
    return temp;
 
136
}
 
137
 
 
138
void Rect::fromScriptValue(const QScriptValue& obj, QRect &rect)
 
139
{
 
140
    QScriptValue w = obj.property("w", QScriptValue::ResolveLocal);
 
141
    QScriptValue h = obj.property("h", QScriptValue::ResolveLocal);
 
142
    QScriptValue x = obj.property("x", QScriptValue::ResolveLocal);
 
143
    QScriptValue y = obj.property("y", QScriptValue::ResolveLocal);
 
144
 
 
145
    if (!w.isUndefined() && !h.isUndefined() && !x.isUndefined() && !y.isUndefined()) {
 
146
        rect.setX(x.toInt32());
 
147
        rect.setY(y.toInt32());
 
148
        rect.setWidth(w.toInt32());
 
149
        rect.setHeight(h.toInt32());
 
150
    }
 
151
}
 
152
// End of meta for QRect object
 
153
 
 
154
// Other helper functions
 
155
void KWin::MetaScripting::registration(QScriptEngine* eng)
 
156
{
 
157
    qScriptRegisterMetaType<KClientRef>(eng, Client::toScriptValue, Client::fromScriptValue);
 
158
    qScriptRegisterMetaType<QPoint>(eng, Point::toScriptValue, Point::fromScriptValue);
 
159
    qScriptRegisterMetaType<QSize>(eng, Size::toScriptValue, Size::fromScriptValue);
 
160
    qScriptRegisterMetaType<QRect>(eng, Rect::toScriptValue, Rect::fromScriptValue);
 
161
    qScriptRegisterMetaType<KToplevelRef>(eng, Toplevel::toScriptValue, Toplevel::fromScriptValue);
 
162
    qScriptRegisterMetaType<KClientGroupRef>(eng, ClientGroup::toScriptValue, ClientGroup::fromScriptValue);
 
163
 
 
164
    qScriptRegisterSequenceMetaType<QStringList>(eng);
 
165
    qScriptRegisterSequenceMetaType< QList<KWin::ClientGroup*> >(eng);
 
166
    qScriptRegisterSequenceMetaType<KClientList>(eng);
 
167
}
 
168
 
 
169
QScriptValue KWin::MetaScripting::configExists(QScriptContext* ctx, QScriptEngine* eng)
 
170
{
 
171
    QHash<QString, QVariant> scriptConfig = (((ctx->thisObject()).data()).toVariant()).toHash();
 
172
    QVariant val = scriptConfig.value((ctx->argument(0)).toString(), QVariant());
 
173
 
 
174
    return eng->toScriptValue<bool>(val.isValid());
 
175
}
 
176
 
 
177
QScriptValue KWin::MetaScripting::getConfigValue(QScriptContext* ctx, QScriptEngine* eng)
 
178
{
 
179
    int num = ctx->argumentCount();
 
180
    QHash<QString, QVariant> scriptConfig = (((ctx->thisObject()).data()).toVariant()).toHash();
 
181
 
 
182
    /*
 
183
     * Handle config.get() separately. Compute and return immediately.
 
184
     **/
 
185
    if (num == 0) {
 
186
        QHash<QString, QVariant>::const_iterator i;
 
187
        QScriptValue ret = eng->newArray();
 
188
 
 
189
        for (i = scriptConfig.constBegin(); i != scriptConfig.constEnd(); ++i) {
 
190
            ret.setProperty(i.key(), eng->newVariant(i.value()));
 
191
        }
 
192
 
 
193
        return ret;
 
194
    }
 
195
 
 
196
    if ((num == 1) && !((ctx->argument(0)).isArray())) {
 
197
        QVariant val = scriptConfig.value((ctx->argument(0)).toString(), QVariant());
 
198
 
 
199
        if (val.isValid()) {
 
200
            return eng->newVariant(val);
 
201
        } else {
 
202
            return QScriptValue();
 
203
        }
 
204
    } else {
 
205
        QScriptValue ret = eng->newArray();
 
206
        int j = 0;
 
207
 
 
208
        if ((ctx->argument(0)).isArray()) {
 
209
            bool simple = (num == 1) ? 0 : (ctx->argument(1)).toBool();
 
210
            QScriptValue array = (ctx->argument(0));
 
211
            int len = (array.property("length").isValid()) ? array.property("length").toNumber() : 0;
 
212
 
 
213
            for (int i = 0; i < len; i++) {
 
214
                QVariant val = scriptConfig.value(array.property(i).toString(), QVariant());
 
215
 
 
216
                if (val.isValid()) {
 
217
                    if (simple) {
 
218
                        ret.setProperty(j, eng->newVariant(val));
 
219
                    } else {
 
220
                        ret.setProperty(array.property(i).toString(), eng->newVariant(val));
 
221
                    }
 
222
 
 
223
                    j++;
 
224
                }
 
225
            }
 
226
        } else {
 
227
            for (int i = 0; i < num; i++) {
 
228
                QVariant val = scriptConfig.value((ctx->argument(i)).toString(), QVariant());
 
229
 
 
230
                if (val.isValid()) {
 
231
                    ret.setProperty((ctx->argument(i)).toString(), eng->newVariant(val));
 
232
                    j = 1;
 
233
                }
 
234
            }
 
235
        }
 
236
 
 
237
 
 
238
        if (j == 0) {
 
239
            return QScriptValue();
 
240
        } else {
 
241
            return ret;
 
242
        }
 
243
    }
 
244
}
 
245
 
 
246
void KWin::MetaScripting::supplyConfig(QScriptEngine* eng, const QVariant& scriptConfig)
 
247
{
 
248
    QScriptValue configObject = eng->newObject();
 
249
    configObject.setData(eng->newVariant(scriptConfig));
 
250
    configObject.setProperty("get", eng->newFunction(getConfigValue, 0), QScriptValue::Undeletable);
 
251
    configObject.setProperty("exists", eng->newFunction(configExists, 0), QScriptValue::Undeletable);
 
252
    configObject.setProperty("loaded", ((scriptConfig.toHash().empty()) ? eng->newVariant((bool)0) : eng->newVariant((bool)1)), QScriptValue::Undeletable);
 
253
    (eng->globalObject()).setProperty("config", configObject);
 
254
}
 
255
 
 
256
void KWin::MetaScripting::supplyConfig(QScriptEngine* eng)
 
257
{
 
258
    KWin::MetaScripting::supplyConfig(eng, QVariant(QHash<QString, QVariant>()));
 
259
}
 
260
 
 
261
void KWin::MetaScripting::valueMerge(QScriptValue& first, QScriptValue second)
 
262
{
 
263
    QScriptValueIterator value_it(second);
 
264
 
 
265
    while (value_it.hasNext()) {
 
266
        value_it.next();
 
267
        first.setProperty(value_it.name(), value_it.value());
 
268
    }
 
269
}
 
270
 
 
271
QScriptValue KWin::MetaScripting::getLazyLogicFunction(QScriptEngine* eng, const QString& type)
 
272
{
 
273
    QScriptValue base = eng->newFunction(KWin::Chelate::lazyLogicGenerate, 0);
 
274
    QScriptValue data = eng->newObject();
 
275
    data.setProperty("lazylogic_type", eng->toScriptValue<QString>(type));
 
276
    base.setData(data);
 
277
    return base;
 
278
}