← Back to branch summary

~ubuntu-branches/ubuntu/utopic/kdevplatform/utopic-proposed

« back to all changes in this revision

Viewing changes to shell/kross/wrappers/krossprojectmodelimpl.h

  • Committer: Package Import Robot
  • Author(s): Scarlett Clark
  • Date: 2014-08-30 03:52:11 UTC
  • mfrom: (0.3.26)
  • Revision ID: package-import@ubuntu.com-20140830035211-wndqlc843eu2v8nk
Tags: 1.7.0-0ubuntu1
* New upstream release
* Add XS-Testsuite: autopkgtest

Show diffs side-by-side

added added

removed removed

Lines of Context:
shell/kross/wrappers/krossprojectmodelimpl.h
1
 
//This is file has been generated by xmltokross,you should not edit this file but the files used to generate it.
2
 
 
3
 
#include <QtCore/QObject>
4
 
#include <QtCore/QVariant>
5
 
#include <kross/core/object.h>
6
 
#include <kross/core/manager.h>
7
 
#include <kross/core/wrapperinterface.h>
8
 
#include <project/projectmodel.h>
9
 
#include <interfaces/iproject.h>
10
 
 
11
 
class KrossImplKDevelopProjectVisitor : public KDevelop::ProjectVisitor
12
 
{
13
 
        public:
14
 
                KrossImplKDevelopProjectVisitor(Kross::Object::Ptr _obj) : obj(_obj) {}
15
 
                void visit(KDevelop::IProject* x0)
16
 
                {
17
 
                        Kross::Object* p=obj.data();
18
 
                        if(!p->methodNames().contains("visit"))
19
 
                                KDevelop::ProjectVisitor::visit(x0);
20
 
                        else
21
 
                                p->callMethod("visit", QVariantList() << qVariantFromValue<QObject*>(x0));
22
 
                }
23
 
 
24
 
                void visit(KDevelop::ProjectBuildFolderItem* x0)
25
 
                {
26
 
                        Kross::Object* p=obj.data();
27
 
                        if(!p->methodNames().contains("visit"))
28
 
                                KDevelop::ProjectVisitor::visit(x0);
29
 
                        else
30
 
                                p->callMethod("visit", QVariantList() << Kross::Manager::self().metaTypeHandler("KDevelop::ProjectBuildFolderItem*")->callHandler(x0));
31
 
                }
32
 
 
33
 
                void visit(KDevelop::ProjectExecutableTargetItem* x0)
34
 
                {
35
 
                        Kross::Object* p=obj.data();
36
 
                        if(!p->methodNames().contains("visit"))
37
 
                                KDevelop::ProjectVisitor::visit(x0);
38
 
                        else
39
 
                                p->callMethod("visit", QVariantList() << Kross::Manager::self().metaTypeHandler("KDevelop::ProjectExecutableTargetItem*")->callHandler(x0));
40
 
                }
41
 
 
42
 
                void visit(KDevelop::ProjectFolderItem* x0)
43
 
                {
44
 
                        Kross::Object* p=obj.data();
45
 
                        if(!p->methodNames().contains("visit"))
46
 
                                KDevelop::ProjectVisitor::visit(x0);
47
 
                        else
48
 
                                p->callMethod("visit", QVariantList() << Kross::Manager::self().metaTypeHandler("KDevelop::ProjectFolderItem*")->callHandler(x0));
49
 
                }
50
 
 
51
 
                void visit(KDevelop::ProjectFileItem* x0)
52
 
                {
53
 
                        Kross::Object* p=obj.data();
54
 
                        if(!p->methodNames().contains("visit"))
55
 
                                KDevelop::ProjectVisitor::visit(x0);
56
 
                        else
57
 
                                p->callMethod("visit", QVariantList() << Kross::Manager::self().metaTypeHandler("KDevelop::ProjectFileItem*")->callHandler(x0));
58
 
                }
59
 
 
60
 
                void visit(KDevelop::ProjectLibraryTargetItem* x0)
61
 
                {
62
 
                        Kross::Object* p=obj.data();
63
 
                        if(!p->methodNames().contains("visit"))
64
 
                                KDevelop::ProjectVisitor::visit(x0);
65
 
                        else
66
 
                                p->callMethod("visit", QVariantList() << Kross::Manager::self().metaTypeHandler("KDevelop::ProjectLibraryTargetItem*")->callHandler(x0));
67
 
                }
68
 
 
69
 
        private:
70
 
                Kross::Object::Ptr obj;
71
 
};
72
 
 
73
 
class KrossImplKDevelopProjectBaseItem : public KDevelop::ProjectBaseItem
74
 
{
75
 
        public:
76
 
                KrossImplKDevelopProjectBaseItem(Kross::Object::Ptr _obj, KDevelop::IProject* x0, const QString& x1, QStandardItem* x2=0) : KDevelop::ProjectBaseItem(x0, x1, x2), obj(_obj) {}
77
 
                KDevelop::ProjectFolderItem* folder() const
78
 
                {
79
 
                        Kross::Object* p=const_cast<Kross::Object*>(obj.constData());
80
 
                        if(!p->methodNames().contains("folder"))
81
 
                                return KDevelop::ProjectBaseItem::folder();
82
 
                        else
83
 
                                return dynamic_cast<KDevelop::ProjectFolderItem*>(p->callMethod("folder").value<QObject*>());
84
 
                }
85
 
 
86
 
                KDevelop::ProjectTargetItem* target() const
87
 
                {
88
 
                        Kross::Object* p=const_cast<Kross::Object*>(obj.constData());
89
 
                        if(!p->methodNames().contains("target"))
90
 
                                return KDevelop::ProjectBaseItem::target();
91
 
                        else
92
 
                                return dynamic_cast<KDevelop::ProjectTargetItem*>(p->callMethod("target").value<QObject*>());
93
 
                }
94
 
 
95
 
                KDevelop::ProjectFileItem* file() const
96
 
                {
97
 
                        Kross::Object* p=const_cast<Kross::Object*>(obj.constData());
98
 
                        if(!p->methodNames().contains("file"))
99
 
                                return KDevelop::ProjectBaseItem::file();
100
 
                        else
101
 
                                return dynamic_cast<KDevelop::ProjectFileItem*>(p->callMethod("file").value<QObject*>());
102
 
                }
103
 
 
104
 
                KDevelop::ProjectExecutableTargetItem* executable() const
105
 
                {
106
 
                        Kross::Object* p=const_cast<Kross::Object*>(obj.constData());
107
 
                        if(!p->methodNames().contains("executable"))
108
 
                                return KDevelop::ProjectBaseItem::executable();
109
 
                        else
110
 
                                return dynamic_cast<KDevelop::ProjectExecutableTargetItem*>(p->callMethod("executable").value<QObject*>());
111
 
                }
112
 
 
113
 
        private:
114
 
                Kross::Object::Ptr obj;
115
 
};
116
 
 
117
 
class KrossImplKDevelopProjectFolderItem : public KDevelop::ProjectFolderItem
118
 
{
119
 
        public:
120
 
                KrossImplKDevelopProjectFolderItem(Kross::Object::Ptr _obj, KDevelop::IProject* x0, const KUrl& x1, QStandardItem* x2=0) : KDevelop::ProjectFolderItem(x0, x1, x2), obj(_obj) {}
121
 
                KDevelop::ProjectFolderItem* folder() const
122
 
                {
123
 
                        Kross::Object* p=const_cast<Kross::Object*>(obj.constData());
124
 
                        if(!p->methodNames().contains("folder"))
125
 
                                return KDevelop::ProjectFolderItem::folder();
126
 
                        else
127
 
                                return dynamic_cast<KDevelop::ProjectFolderItem*>(p->callMethod("folder").value<QObject*>());
128
 
                }
129
 
 
130
 
                int type() const
131
 
                {
132
 
                        Kross::Object* p=const_cast<Kross::Object*>(obj.constData());
133
 
                        if(!p->methodNames().contains("type"))
134
 
                                return KDevelop::ProjectFolderItem::type();
135
 
                        else
136
 
                                return p->callMethod("type").value<int>();
137
 
                }
138
 
                
139
 
        private:
140
 
                Kross::Object::Ptr obj;
141
 
};
142
 
 
143
 
class KrossImplKDevelopProjectBuildFolderItem : public KDevelop::ProjectBuildFolderItem
144
 
{
145
 
        public:
146
 
                KrossImplKDevelopProjectBuildFolderItem(Kross::Object::Ptr _obj, KDevelop::IProject* x0, const KUrl& x1, QStandardItem* x2=0) : KDevelop::ProjectBuildFolderItem(x0, x1, x2), obj(_obj) {}
147
 
                int type() const
148
 
                {
149
 
                        Kross::Object* p=const_cast<Kross::Object*>(obj.constData());
150
 
                        if(!p->methodNames().contains("type"))
151
 
                                return KDevelop::ProjectBuildFolderItem::type();
152
 
                        else
153
 
                                return p->callMethod("type").value<int>();
154
 
                }
155
 
 
156
 
        private:
157
 
                Kross::Object::Ptr obj;
158
 
};
159
 
 
160
 
class KrossImplKDevelopProjectTargetItem : public KDevelop::ProjectTargetItem
161
 
{
162
 
        public:
163
 
                KrossImplKDevelopProjectTargetItem(Kross::Object::Ptr _obj, KDevelop::IProject* x0, const QString& x1, QStandardItem* x2=0) : KDevelop::ProjectTargetItem(x0, x1, x2), obj(_obj) {}
164
 
                int type() const
165
 
                {
166
 
                        Kross::Object* p=const_cast<Kross::Object*>(obj.constData());
167
 
                        if(!p->methodNames().contains("type"))
168
 
                                return KDevelop::ProjectTargetItem::type();
169
 
                        else
170
 
                                return p->callMethod("type").value<int>();
171
 
                }
172
 
 
173
 
                KDevelop::ProjectTargetItem* target() const
174
 
                {
175
 
                        Kross::Object* p=const_cast<Kross::Object*>(obj.constData());
176
 
                        if(!p->methodNames().contains("target"))
177
 
                                return KDevelop::ProjectTargetItem::target();
178
 
                        else
179
 
                                return dynamic_cast<KDevelop::ProjectTargetItem*>(p->callMethod("target").value<QObject*>());
180
 
                }
181
 
 
182
 
        private:
183
 
                Kross::Object::Ptr obj;
184
 
};
185
 
 
186
 
class KrossImplKDevelopProjectExecutableTargetItem : public KDevelop::ProjectExecutableTargetItem
187
 
{
188
 
        public:
189
 
                KrossImplKDevelopProjectExecutableTargetItem(Kross::Object::Ptr _obj, KDevelop::IProject* x0, const QString& x1, QStandardItem* x2=0) : KDevelop::ProjectExecutableTargetItem(x0, x1, x2), obj(_obj) {}
190
 
                KDevelop::ProjectExecutableTargetItem* executable() const
191
 
                {
192
 
                        Kross::Object* p=const_cast<Kross::Object*>(obj.constData());
193
 
                        if(!p->methodNames().contains("executable"))
194
 
                                return KDevelop::ProjectExecutableTargetItem::executable();
195
 
                        else
196
 
                                return dynamic_cast<KDevelop::ProjectExecutableTargetItem*>(p->callMethod("executable").value<QObject*>());
197
 
                }
198
 
 
199
 
                int type() const
200
 
                {
201
 
                        Kross::Object* p=const_cast<Kross::Object*>(obj.constData());
202
 
                        if(!p->methodNames().contains("type"))
203
 
                                return KDevelop::ProjectExecutableTargetItem::type();
204
 
                        else
205
 
                                return p->callMethod("type").value<int>();
206
 
                }
207
 
 
208
 
                KUrl builtUrl() const
209
 
                {
210
 
                        Kross::Object* p=const_cast<Kross::Object*>(obj.constData());
211
 
                        return p->callMethod("builtUrl").value<KUrl>();
212
 
                }
213
 
 
214
 
                KUrl installedUrl() const
215
 
                {
216
 
                        Kross::Object* p=const_cast<Kross::Object*>(obj.constData());
217
 
                        return p->callMethod("installedUrl").value<KUrl>();
218
 
                }
219
 
 
220
 
        private:
221
 
                Kross::Object::Ptr obj;
222
 
};
223
 
 
224
 
class KrossImplKDevelopProjectLibraryTargetItem : public KDevelop::ProjectLibraryTargetItem
225
 
{
226
 
        public:
227
 
                KrossImplKDevelopProjectLibraryTargetItem(Kross::Object::Ptr _obj, KDevelop::IProject* x0, const QString& x1, QStandardItem* x2=0) : KDevelop::ProjectLibraryTargetItem(x0, x1, x2), obj(_obj) {}
228
 
                int type() const
229
 
                {
230
 
                        Kross::Object* p=const_cast<Kross::Object*>(obj.constData());
231
 
                        if(!p->methodNames().contains("type"))
232
 
                                return KDevelop::ProjectLibraryTargetItem::type();
233
 
                        else
234
 
                                return p->callMethod("type").value<int>();
235
 
                }
236
 
 
237
 
        private:
238
 
                Kross::Object::Ptr obj;
239
 
};
240
 
 
241
 
class KrossImplKDevelopProjectFileItem : public KDevelop::ProjectFileItem
242
 
{
243
 
        public:
244
 
                KrossImplKDevelopProjectFileItem(Kross::Object::Ptr _obj, KDevelop::IProject* x0, const KUrl& x1, QStandardItem* x2=0) : KDevelop::ProjectFileItem(x0, x1, x2), obj(_obj) {}
245
 
                int type() const
246
 
                {
247
 
                        Kross::Object* p=const_cast<Kross::Object*>(obj.constData());
248
 
                        if(!p->methodNames().contains("type"))
249
 
                                return KDevelop::ProjectFileItem::type();
250
 
                        else
251
 
                                return p->callMethod("type").value<int>();
252
 
                }
253
 
 
254
 
                KDevelop::ProjectFileItem* file() const
255
 
                {
256
 
                        Kross::Object* p=const_cast<Kross::Object*>(obj.constData());
257
 
                        if(!p->methodNames().contains("file"))
258
 
                                return KDevelop::ProjectFileItem::file();
259
 
                        else
260
 
                                return dynamic_cast<KDevelop::ProjectFileItem*>(p->callMethod("file").value<QObject*>());
261
 
                }
262
 
                
263
 
        private:
264
 
                Kross::Object::Ptr obj;
265
 
};
266
 
 
267
 
class KrossImplKDevelopProjectModel : public KDevelop::ProjectModel
268
 
{
269
 
        public:
270
 
                KrossImplKDevelopProjectModel(Kross::Object::Ptr _obj, QObject* x0=0) : KDevelop::ProjectModel(x0), obj(_obj) {}
271
 
                Qt::ItemFlags flags(const QModelIndex& x0) const
272
 
                {
273
 
                        Kross::Object* p=const_cast<Kross::Object*>(obj.constData());
274
 
                        if(!p->methodNames().contains("flags"))
275
 
                                return KDevelop::ProjectModel::flags(x0);
276
 
//                      else
277
 
//                              return p->callMethod("flags", QVariantList() << QVariant()).value<int>();
278
 
                }
279
 
 
280
 
                void fetchMore(const QModelIndex& x0)
281
 
                {
282
 
                        Kross::Object* p=obj.data();
283
 
                        if(!p->methodNames().contains("fetchMore"))
284
 
                                KDevelop::ProjectModel::fetchMore(x0);
285
 
                        else
286
 
                                p->callMethod("fetchMore", QVariantList() << QVariant());
287
 
                }
288
 
 
289
 
                bool canFetchMore(const QModelIndex& x0) const
290
 
                {
291
 
                        Kross::Object* p=const_cast<Kross::Object*>(obj.constData());
292
 
                        if(!p->methodNames().contains("canFetchMore"))
293
 
                                return KDevelop::ProjectModel::canFetchMore(x0);
294
 
                        else
295
 
                                return p->callMethod("canFetchMore", QVariantList() << QVariant()).value<bool>();
296
 
                }
297
 
 
298
 
        private:
299
 
                Kross::Object::Ptr obj;
300
 
};
301