##// END OF EJS Templates
GIT_REPOSITORIES » LPP » PythonQt
RSS

Clone from https://github.com/Orochimarufan/PythonQt.git

updated old license information and current date...
florianlink -
r133:26c5443b8486
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,43 +1,43
1 1 /*
2 2 *
3 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
3 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
4 4 *
5 5 * This library is free software; you can redistribute it and/or
6 6 * modify it under the terms of the GNU Lesser General Public
7 7 * License as published by the Free Software Foundation; either
8 8 * version 2.1 of the License, or (at your option) any later version.
9 9 *
10 10 * This library is distributed in the hope that it will be useful,
11 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 13 * Lesser General Public License for more details.
14 14 *
15 15 * Further, this software is distributed without any warranty that it is
16 16 * free of the rightful claim of any third person regarding infringement
17 17 * or the like. Any license provided herein, whether implied or
18 18 * otherwise, applies only to this software file. Patent licenses, if
19 19 * any, provided herein do not apply to combinations of this program with
20 20 * other software, or any other product whatsoever.
21 21 *
22 22 * You should have received a copy of the GNU Lesser General Public
23 23 * License along with this library; if not, write to the Free Software
24 24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 25 *
26 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
26 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
27 27 * 28359 Bremen, Germany or:
28 28 *
29 29 * http://www.mevis.de
30 30 *
31 31 */
32 32
33 33 //----------------------------------------------------------------------------------
34 34 /*!
35 35 // \file CustomObjects.cpp
36 36 // \author Florian Link
37 37 // \author Last changed by $Author: florian $
38 38 // \date 2007-4
39 39 */
40 40 //----------------------------------------------------------------------------------
41 41
42 42 #include "CustomObjects.h"
43 43
Show file before | Show file after | Hide comments
@@ -1,149 +1,149
1 1 #ifndef _PYCUSTOMOBJECTS_H
2 2 #define _PYCUSTOMOBJECTS_H
3 3
4 4 /*
5 5 *
6 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
6 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
7 7 *
8 8 * This library is free software; you can redistribute it and/or
9 9 * modify it under the terms of the GNU Lesser General Public
10 10 * License as published by the Free Software Foundation; either
11 11 * version 2.1 of the License, or (at your option) any later version.
12 12 *
13 13 * This library is distributed in the hope that it will be useful,
14 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 16 * Lesser General Public License for more details.
17 17 *
18 18 * Further, this software is distributed without any warranty that it is
19 19 * free of the rightful claim of any third person regarding infringement
20 20 * or the like. Any license provided herein, whether implied or
21 21 * otherwise, applies only to this software file. Patent licenses, if
22 22 * any, provided herein do not apply to combinations of this program with
23 23 * other software, or any other product whatsoever.
24 24 *
25 25 * You should have received a copy of the GNU Lesser General Public
26 26 * License along with this library; if not, write to the Free Software
27 27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 28 *
29 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
29 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
30 30 * 28359 Bremen, Germany or:
31 31 *
32 32 * http://www.mevis.de
33 33 *
34 34 */
35 35
36 36 //----------------------------------------------------------------------------------
37 37 /*!
38 38 // \file CustomObjects.h
39 39 // \author Florian Link
40 40 // \author Last changed by $Author: florian $
41 41 // \date 2007-4
42 42 */
43 43 //----------------------------------------------------------------------------------
44 44
45 45 #include "PythonQt.h"
46 46 #include "PythonQtCppWrapperFactory.h"
47 47 #include <QObject>
48 48
49 49
50 50 // declare our own custom object
51 51 class CustomObject {
52 52 public:
53 53 CustomObject() {}
54 54 CustomObject(const QString& first, const QString& last) { _firstName = first; _lastName = last; }
55 55
56 56 QString _firstName;
57 57 QString _lastName;
58 58
59 59 };
60 60
61 61
62 62 // add a decorator that allows to access the CustomObject from PythonQt
63 63 class CustomObjectWrapper : public QObject {
64 64
65 65 Q_OBJECT
66 66
67 67 public slots:
68 68 // add a constructor
69 69 CustomObject* new_CustomObject(const QString& first, const QString& last) { return new CustomObject(first, last); }
70 70
71 71 // add a destructor
72 72 void delete_CustomObject(CustomObject* o) { delete o; }
73 73
74 74 // add access methods
75 75 QString firstName(CustomObject* o) { return o->_firstName; }
76 76
77 77 QString lastName(CustomObject* o) { return o->_lastName; }
78 78
79 79 void setFirstName(CustomObject* o, const QString& name) { o->_firstName = name; }
80 80
81 81 void setLastName(CustomObject* o, const QString& name) { o->_lastName = name; }
82 82
83 83 };
84 84
85 85
86 86 //------------------------------------------------------------------------------------------------
87 87 // alternative: we create a wrapper factory, which creates a wrapper object for each CPP instance:
88 88 //------------------------------------------------------------------------------------------------
89 89
90 90 // declare our own custom object
91 91 class CustomObject2 {
92 92 public:
93 93 CustomObject2() {}
94 94 CustomObject2(const QString& first, const QString& last) { _firstName = first; _lastName = last; }
95 95
96 96 QString _firstName;
97 97 QString _lastName;
98 98
99 99 };
100 100
101 101
102 102 // add a decorator that allows to access the CustomObject from PythonQt
103 103 class CustomObject2Wrapper : public QObject {
104 104
105 105 Q_OBJECT
106 106
107 107 public:
108 108 CustomObject2Wrapper(CustomObject2* obj) { _ptr = obj; }
109 109
110 110 public slots:
111 111 // add access methods
112 112 QString firstName() { return _ptr->_firstName; }
113 113
114 114 QString lastName() { return _ptr->_lastName; }
115 115
116 116 void setFirstName(const QString& name) { _ptr->_firstName = name; }
117 117
118 118 void setLastName(const QString& name) { _ptr->_lastName = name; }
119 119
120 120 private:
121 121 CustomObject2* _ptr;
122 122 };
123 123
124 124 // additional constructor/destructor for CustomObject2 (optional)
125 125 class CustomObject2Constructor : public QObject {
126 126
127 127 Q_OBJECT
128 128
129 129 public slots:
130 130 // add a constructor
131 131 CustomObject2* new_CustomObject2(const QString& first, const QString& last) { return new CustomObject2(first, last); }
132 132
133 133 // add a destructor
134 134 void delete_CustomObject2(CustomObject2* o) { delete o; }
135 135 };
136 136
137 137 // a factory that can create wrappers for CustomObject2
138 138 class CustomFactory : public PythonQtCppWrapperFactory
139 139 {
140 140 public:
141 141 virtual QObject* create(const QByteArray& name, void *ptr) {
142 142 if (name == "CustomObject2") {
143 143 return new CustomObject2Wrapper((CustomObject2*)ptr);
144 144 }
145 145 return NULL;
146 146 }
147 147 };
148 148
149 149 #endif
Show file before | Show file after | Hide comments
@@ -1,84 +1,84
1 1 /*
2 2 *
3 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
3 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
4 4 *
5 5 * This library is free software; you can redistribute it and/or
6 6 * modify it under the terms of the GNU Lesser General Public
7 7 * License as published by the Free Software Foundation; either
8 8 * version 2.1 of the License, or (at your option) any later version.
9 9 *
10 10 * This library is distributed in the hope that it will be useful,
11 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 13 * Lesser General Public License for more details.
14 14 *
15 15 * Further, this software is distributed without any warranty that it is
16 16 * free of the rightful claim of any third person regarding infringement
17 17 * or the like. Any license provided herein, whether implied or
18 18 * otherwise, applies only to this software file. Patent licenses, if
19 19 * any, provided herein do not apply to combinations of this program with
20 20 * other software, or any other product whatsoever.
21 21 *
22 22 * You should have received a copy of the GNU Lesser General Public
23 23 * License along with this library; if not, write to the Free Software
24 24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 25 *
26 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
26 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
27 27 * 28359 Bremen, Germany or:
28 28 *
29 29 * http://www.mevis.de
30 30 *
31 31 */
32 32
33 33 //----------------------------------------------------------------------------------
34 34 /*!
35 35 // \file PyGuiExample.cpp
36 36 // \author Florian Link
37 37 // \author Last changed by $Author: florian $
38 38 // \date 2007-04
39 39 */
40 40 //----------------------------------------------------------------------------------
41 41
42 42 #include "PythonQt.h"
43 43 #include "gui/PythonQtScriptingConsole.h"
44 44 #include "CustomObjects.h"
45 45
46 46 #include <QApplication>
47 47
48 48 int main( int argc, char **argv )
49 49 {
50 50 QApplication qapp(argc, argv);
51 51
52 52 PythonQt::init(PythonQt::IgnoreSiteModule | PythonQt::RedirectStdOut);
53 53
54 54 PythonQtObjectPtr mainContext = PythonQt::self()->getMainModule();
55 55 PythonQtScriptingConsole console(NULL, mainContext);
56 56
57 57 // -----------------------------------------------------------------
58 58 // Alternative 1: make CustomObject known and use decorators for wrapping:
59 59 // -----------------------------------------------------------------
60 60
61 61 // register the new object as a known classname and add it's wrapper object
62 62 PythonQt::self()->registerCPPClass("CustomObject", "","", PythonQtCreateObject<CustomObjectWrapper>);
63 63
64 64 // -----------------------------------------------------------------
65 65 // Alternative 2: make CustomObject2 known and use a wrapper factory for wrapping:
66 66 // -----------------------------------------------------------------
67 67
68 68 // add a factory that can handle pointers to CustomObject2
69 69 PythonQt::self()->addWrapperFactory(new CustomFactory());
70 70
71 71 // the following is optional and only needed if you want a constructor:
72 72 // register the new object as a known classname
73 73 PythonQt::self()->registerCPPClass("CustomObject2");
74 74 // add a constructor for CustomObject2
75 75 PythonQt::self()->addClassDecorators(new CustomObject2Constructor());
76 76
77 77 mainContext.evalFile(":example.py");
78 78
79 79 console.appendCommandPrompt();
80 80 console.show();
81 81
82 82 return qapp.exec();
83 83 }
84 84
Show file before | Show file after | Hide comments
@@ -1,43 +1,43
1 1 /*
2 2 *
3 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
3 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
4 4 *
5 5 * This library is free software; you can redistribute it and/or
6 6 * modify it under the terms of the GNU Lesser General Public
7 7 * License as published by the Free Software Foundation; either
8 8 * version 2.1 of the License, or (at your option) any later version.
9 9 *
10 10 * This library is distributed in the hope that it will be useful,
11 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 13 * Lesser General Public License for more details.
14 14 *
15 15 * Further, this software is distributed without any warranty that it is
16 16 * free of the rightful claim of any third person regarding infringement
17 17 * or the like. Any license provided herein, whether implied or
18 18 * otherwise, applies only to this software file. Patent licenses, if
19 19 * any, provided herein do not apply to combinations of this program with
20 20 * other software, or any other product whatsoever.
21 21 *
22 22 * You should have received a copy of the GNU Lesser General Public
23 23 * License along with this library; if not, write to the Free Software
24 24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 25 *
26 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
26 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
27 27 * 28359 Bremen, Germany or:
28 28 *
29 29 * http://www.mevis.de
30 30 *
31 31 */
32 32
33 33 //----------------------------------------------------------------------------------
34 34 /*!
35 35 // \file CustomObject.cpp
36 36 // \author Florian Link
37 37 // \author Last changed by $Author: florian $
38 38 // \date 2007-4
39 39 */
40 40 //----------------------------------------------------------------------------------
41 41
42 42 #include "CustomObject.h"
43 43
Show file before | Show file after | Hide comments
@@ -1,85 +1,85
1 1 #ifndef _PYCUSTOMOBJECT_H
2 2 #define _PYCUSTOMOBJECT_H
3 3
4 4 /*
5 5 *
6 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
6 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
7 7 *
8 8 * This library is free software; you can redistribute it and/or
9 9 * modify it under the terms of the GNU Lesser General Public
10 10 * License as published by the Free Software Foundation; either
11 11 * version 2.1 of the License, or (at your option) any later version.
12 12 *
13 13 * This library is distributed in the hope that it will be useful,
14 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 16 * Lesser General Public License for more details.
17 17 *
18 18 * Further, this software is distributed without any warranty that it is
19 19 * free of the rightful claim of any third person regarding infringement
20 20 * or the like. Any license provided herein, whether implied or
21 21 * otherwise, applies only to this software file. Patent licenses, if
22 22 * any, provided herein do not apply to combinations of this program with
23 23 * other software, or any other product whatsoever.
24 24 *
25 25 * You should have received a copy of the GNU Lesser General Public
26 26 * License along with this library; if not, write to the Free Software
27 27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 28 *
29 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
29 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
30 30 * 28359 Bremen, Germany or:
31 31 *
32 32 * http://www.mevis.de
33 33 *
34 34 */
35 35
36 36 //----------------------------------------------------------------------------------
37 37 /*!
38 38 // \file CustomObject.h
39 39 // \author Florian Link
40 40 // \author Last changed by $Author: florian $
41 41 // \date 2007-4
42 42 */
43 43 //----------------------------------------------------------------------------------
44 44
45 45 #include "PythonQt.h"
46 46 #include <QObject>
47 47
48 48
49 49 // declare our own copyable custom object
50 50 class CustomObject {
51 51 public:
52 52 CustomObject() {}
53 53 CustomObject(const QString& first, const QString& last) { _firstName = first; _lastName = last; }
54 54
55 55 QString _firstName;
56 56 QString _lastName;
57 57
58 58 };
59 59
60 60 // register it to the meta type system
61 61 Q_DECLARE_METATYPE(CustomObject)
62 62
63 63 // add a wrapper that allows to access the CustomObject from PythonQt
64 64 class CustomObjectWrapper : public QObject {
65 65
66 66 Q_OBJECT
67 67
68 68 public slots:
69 69 // add a constructor
70 70 CustomObject* new_CustomObject(const QString& first, const QString& last) { return new CustomObject(first, last); }
71 71
72 72 // add access methods
73 73
74 74 QString firstName(CustomObject* o) { return o->_firstName; }
75 75
76 76 QString lastName(CustomObject* o) { return o->_lastName; }
77 77
78 78 void setFirstName(CustomObject* o, const QString& name) { o->_firstName = name; }
79 79
80 80 void setLastName(CustomObject* o, const QString& name) { o->_lastName = name; }
81 81
82 82 };
83 83
84 84
85 85 #endif
Show file before | Show file after | Hide comments
@@ -1,69 +1,69
1 1 /*
2 2 *
3 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
3 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
4 4 *
5 5 * This library is free software; you can redistribute it and/or
6 6 * modify it under the terms of the GNU Lesser General Public
7 7 * License as published by the Free Software Foundation; either
8 8 * version 2.1 of the License, or (at your option) any later version.
9 9 *
10 10 * This library is distributed in the hope that it will be useful,
11 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 13 * Lesser General Public License for more details.
14 14 *
15 15 * Further, this software is distributed without any warranty that it is
16 16 * free of the rightful claim of any third person regarding infringement
17 17 * or the like. Any license provided herein, whether implied or
18 18 * otherwise, applies only to this software file. Patent licenses, if
19 19 * any, provided herein do not apply to combinations of this program with
20 20 * other software, or any other product whatsoever.
21 21 *
22 22 * You should have received a copy of the GNU Lesser General Public
23 23 * License along with this library; if not, write to the Free Software
24 24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 25 *
26 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
26 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
27 27 * 28359 Bremen, Germany or:
28 28 *
29 29 * http://www.mevis.de
30 30 *
31 31 */
32 32
33 33 //----------------------------------------------------------------------------------
34 34 /*!
35 35 // \file PyGuiExample.cpp
36 36 // \author Florian Link
37 37 // \author Last changed by $Author: florian $
38 38 // \date 2007-04
39 39 */
40 40 //----------------------------------------------------------------------------------
41 41
42 42 #include "PythonQt.h"
43 43 #include "gui/PythonQtScriptingConsole.h"
44 44 #include "CustomObject.h"
45 45
46 46 #include <QApplication>
47 47
48 48 int main( int argc, char **argv )
49 49 {
50 50 QApplication qapp(argc, argv);
51 51
52 52 PythonQt::init(PythonQt::IgnoreSiteModule | PythonQt::RedirectStdOut);
53 53
54 54 PythonQtObjectPtr mainContext = PythonQt::self()->getMainModule();
55 55 PythonQtScriptingConsole console(NULL, mainContext);
56 56
57 57 // register the type with QMetaType
58 58 qRegisterMetaType<CustomObject>("CustomObject");
59 59 // add a wrapper object for the new variant type
60 60 PythonQt::self()->registerCPPClass("CustomObject","","", PythonQtCreateObject<CustomObjectWrapper>);
61 61
62 62 mainContext.evalFile(":example.py");
63 63
64 64 console.appendCommandPrompt();
65 65 console.show();
66 66
67 67 return qapp.exec();
68 68 }
69 69
Show file before | Show file after | Hide comments
@@ -1,43 +1,43
1 1 /*
2 2 *
3 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
3 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
4 4 *
5 5 * This library is free software; you can redistribute it and/or
6 6 * modify it under the terms of the GNU Lesser General Public
7 7 * License as published by the Free Software Foundation; either
8 8 * version 2.1 of the License, or (at your option) any later version.
9 9 *
10 10 * This library is distributed in the hope that it will be useful,
11 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 13 * Lesser General Public License for more details.
14 14 *
15 15 * Further, this software is distributed without any warranty that it is
16 16 * free of the rightful claim of any third person regarding infringement
17 17 * or the like. Any license provided herein, whether implied or
18 18 * otherwise, applies only to this software file. Patent licenses, if
19 19 * any, provided herein do not apply to combinations of this program with
20 20 * other software, or any other product whatsoever.
21 21 *
22 22 * You should have received a copy of the GNU Lesser General Public
23 23 * License along with this library; if not, write to the Free Software
24 24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 25 *
26 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
26 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
27 27 * 28359 Bremen, Germany or:
28 28 *
29 29 * http://www.mevis.de
30 30 *
31 31 */
32 32
33 33 //----------------------------------------------------------------------------------
34 34 /*!
35 35 // \file PyExampleObject.cpp
36 36 // \author Florian Link
37 37 // \author Last changed by $Author: florian $
38 38 // \date 2006-10
39 39 */
40 40 //----------------------------------------------------------------------------------
41 41
42 42 #include "PyExampleDecorators.h"
43 43
Show file before | Show file after | Hide comments
@@ -1,95 +1,95
1 1 #ifndef _PYEXAMPLEDECORATORS_H
2 2 #define _PYEXAMPLEDECORATORS_H
3 3
4 4 /*
5 5 *
6 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
6 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
7 7 *
8 8 * This library is free software; you can redistribute it and/or
9 9 * modify it under the terms of the GNU Lesser General Public
10 10 * License as published by the Free Software Foundation; either
11 11 * version 2.1 of the License, or (at your option) any later version.
12 12 *
13 13 * This library is distributed in the hope that it will be useful,
14 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 16 * Lesser General Public License for more details.
17 17 *
18 18 * Further, this software is distributed without any warranty that it is
19 19 * free of the rightful claim of any third person regarding infringement
20 20 * or the like. Any license provided herein, whether implied or
21 21 * otherwise, applies only to this software file. Patent licenses, if
22 22 * any, provided herein do not apply to combinations of this program with
23 23 * other software, or any other product whatsoever.
24 24 *
25 25 * You should have received a copy of the GNU Lesser General Public
26 26 * License along with this library; if not, write to the Free Software
27 27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 28 *
29 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
29 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
30 30 * 28359 Bremen, Germany or:
31 31 *
32 32 * http://www.mevis.de
33 33 *
34 34 */
35 35
36 36 //----------------------------------------------------------------------------------
37 37 /*!
38 38 // \file PyExampleDecorators.h
39 39 // \author Florian Link
40 40 // \author Last changed by $Author: florian $
41 41 // \date 2007-4
42 42 */
43 43 //----------------------------------------------------------------------------------
44 44
45 45 #include "PythonQt.h"
46 46 #include <QDebug>
47 47 #include <QObject>
48 48 #include <QPushButton>
49 49
50 50 // an example CPP object
51 51 class YourCPPObject {
52 52 public:
53 53 YourCPPObject(int arg1, float arg2) { a = arg1; b = arg2; }
54 54
55 55 float doSomething(int arg1) { return arg1*a*b; };
56 56
57 57 private:
58 58
59 59 int a;
60 60 float b;
61 61 };
62 62
63 63 // an example decorator
64 64 class PyExampleDecorators : public QObject
65 65 {
66 66 Q_OBJECT
67 67
68 68 public slots:
69 69 // add a constructor to QSize variant that takes a QPoint
70 70 QSize* new_QSize(const QPoint& p) { return new QSize(p.x(), p.y()); }
71 71
72 72 // add a constructor for QPushButton that takes a text and a parent widget
73 73 QPushButton* new_QPushButton(const QString& text, QWidget* parent=NULL) { return new QPushButton(text, parent); }
74 74
75 75 // add a constructor for a CPP object
76 76 YourCPPObject* new_YourCPPObject(int arg1, float arg2) { return new YourCPPObject(arg1, arg2); }
77 77
78 78 // add a destructor for a CPP object
79 79 void delete_YourCPPObject(YourCPPObject* obj) { delete obj; }
80 80
81 81 // add a static method to QWidget
82 82 QWidget* static_QWidget_mouseGrabber() { return QWidget::mouseGrabber(); }
83 83
84 84 // add an additional slot to QWidget (make move() callable, which is not declared as a slot in QWidget)
85 85 void move(QWidget* w, const QPoint& p) { w->move(p); }
86 86
87 87 // add an additional slot to QWidget, overloading the above move method
88 88 void move(QWidget* w, int x, int y) { w->move(x,y); }
89 89
90 90 // add a method to your own CPP object
91 91 int doSomething(YourCPPObject* obj, int arg1) { return obj->doSomething(arg1); }
92 92 };
93 93
94 94
95 95 #endif
Show file before | Show file after | Hide comments
@@ -1,68 +1,68
1 1 /*
2 2 *
3 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
3 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
4 4 *
5 5 * This library is free software; you can redistribute it and/or
6 6 * modify it under the terms of the GNU Lesser General Public
7 7 * License as published by the Free Software Foundation; either
8 8 * version 2.1 of the License, or (at your option) any later version.
9 9 *
10 10 * This library is distributed in the hope that it will be useful,
11 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 13 * Lesser General Public License for more details.
14 14 *
15 15 * Further, this software is distributed without any warranty that it is
16 16 * free of the rightful claim of any third person regarding infringement
17 17 * or the like. Any license provided herein, whether implied or
18 18 * otherwise, applies only to this software file. Patent licenses, if
19 19 * any, provided herein do not apply to combinations of this program with
20 20 * other software, or any other product whatsoever.
21 21 *
22 22 * You should have received a copy of the GNU Lesser General Public
23 23 * License along with this library; if not, write to the Free Software
24 24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 25 *
26 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
26 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
27 27 * 28359 Bremen, Germany or:
28 28 *
29 29 * http://www.mevis.de
30 30 *
31 31 */
32 32
33 33 //----------------------------------------------------------------------------------
34 34 /*!
35 35 // \file PyGuiExample.cpp
36 36 // \author Florian Link
37 37 // \author Last changed by $Author: florian $
38 38 // \date 2007-04
39 39 */
40 40 //----------------------------------------------------------------------------------
41 41
42 42 #include "PythonQt.h"
43 43 #include "gui/PythonQtScriptingConsole.h"
44 44 #include "PyExampleDecorators.h"
45 45
46 46 #include <QApplication>
47 47
48 48 int main( int argc, char **argv )
49 49 {
50 50 QApplication qapp(argc, argv);
51 51
52 52 PythonQt::init(PythonQt::IgnoreSiteModule | PythonQt::RedirectStdOut);
53 53
54 54 PythonQtObjectPtr mainContext = PythonQt::self()->getMainModule();
55 55 PythonQtScriptingConsole console(NULL, mainContext);
56 56
57 57 PythonQt::self()->addDecorators(new PyExampleDecorators());
58 58 PythonQt::self()->registerClass(&QPushButton::staticMetaObject);
59 59 PythonQt::self()->registerCPPClass("YourCPPObject");
60 60
61 61 mainContext.evalFile(":example.py");
62 62
63 63 console.appendCommandPrompt();
64 64 console.show();
65 65
66 66 return qapp.exec();
67 67 }
68 68
Show file before | Show file after | Hide comments
@@ -1,101 +1,101
1 1 /*
2 2 *
3 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
3 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
4 4 *
5 5 * This library is free software; you can redistribute it and/or
6 6 * modify it under the terms of the GNU Lesser General Public
7 7 * License as published by the Free Software Foundation; either
8 8 * version 2.1 of the License, or (at your option) any later version.
9 9 *
10 10 * This library is distributed in the hope that it will be useful,
11 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 13 * Lesser General Public License for more details.
14 14 *
15 15 * Further, this software is distributed without any warranty that it is
16 16 * free of the rightful claim of any third person regarding infringement
17 17 * or the like. Any license provided herein, whether implied or
18 18 * otherwise, applies only to this software file. Patent licenses, if
19 19 * any, provided herein do not apply to combinations of this program with
20 20 * other software, or any other product whatsoever.
21 21 *
22 22 * You should have received a copy of the GNU Lesser General Public
23 23 * License along with this library; if not, write to the Free Software
24 24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 25 *
26 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
26 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
27 27 * 28359 Bremen, Germany or:
28 28 *
29 29 * http://www.mevis.de
30 30 *
31 31 */
32 32
33 33 //----------------------------------------------------------------------------------
34 34 /*!
35 35 // \file PythonQtTests.cpp
36 36 // \author Florian Link
37 37 // \author Last changed by $Author: florian $
38 38 // \date 2006-05
39 39 */
40 40 //----------------------------------------------------------------------------------
41 41
42 42 #include "PythonQt.h"
43 43 #include <QApplication>
44 44 #include <QTextBrowser>
45 45 #include <QLayout>
46 46 #include <QGroupBox>
47 47 #include <QPushButton>
48 48 #include <QLineEdit>
49 49
50 50 int main( int argc, char **argv )
51 51 {
52 52 QApplication qapp(argc, argv);
53 53
54 54 // init PythonQt and Python
55 55 PythonQt::init();
56 56
57 57 // get the __main__ python module
58 58 PythonQtObjectPtr mainModule = PythonQt::self()->getMainModule();
59 59
60 60 // evaluate a simple python script and receive the result a qvariant:
61 61 QVariant result = mainModule.evalScript("19*2+4", Py_eval_input);
62 62
63 63 // Create object from python, hold onto reference in C++:
64 64 PythonQtObjectPtr tag = mainModule.evalScript("EyeD3Tagger()\n", Py_eval_input);
65 65 Q_ASSERT(!tag.isNull());
66 66
67 67 // call python methods from C++
68 68 tag.call("setFileName", QVariantList() << "t.mp3");
69 69 QVariant fn = tag.call("fileName", QVariantList());
70 70 Q_ASSERT(fn.toString() == QString("t.mp3"));
71 71
72 72 // create a small Qt GUI
73 73 QVBoxLayout* vbox = new QVBoxLayout;
74 74 QGroupBox* box = new QGroupBox;
75 75 QTextBrowser* browser = new QTextBrowser(box);
76 76 QLineEdit* edit = new QLineEdit(box);
77 77 QPushButton* button = new QPushButton(box);
78 78 button->setObjectName("button1");
79 79 edit->setObjectName("edit");
80 80 browser->setObjectName("browser");
81 81 vbox->addWidget(browser);
82 82 vbox->addWidget(edit);
83 83 vbox->addWidget(button);
84 84 box->setLayout(vbox);
85 85
86 86 // make the groupbox to the python under the name "box"
87 87 mainModule.addObject("box", box);
88 88
89 89 // evaluate the python script which is defined in the resources
90 90 mainModule.evalFile(":GettingStarted.py");
91 91
92 92 // define a python method that appends the passed text to the browser
93 93 mainModule.evalScript("def appendText(text):\n box.browser.append(text)");
94 94 // shows how to call the method with a text that will be append to the browser
95 95 mainModule.call("appendText", QVariantList() << "The ultimate answer is ");
96 96
97 97
98 98
99 99 return qapp.exec();
100 100 }
101 101
Show file before | Show file after | Hide comments
@@ -1,68 +1,68
1 1 /*
2 2 *
3 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
3 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
4 4 *
5 5 * This library is free software; you can redistribute it and/or
6 6 * modify it under the terms of the GNU Lesser General Public
7 7 * License as published by the Free Software Foundation; either
8 8 * version 2.1 of the License, or (at your option) any later version.
9 9 *
10 10 * This library is distributed in the hope that it will be useful,
11 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 13 * Lesser General Public License for more details.
14 14 *
15 15 * Further, this software is distributed without any warranty that it is
16 16 * free of the rightful claim of any third person regarding infringement
17 17 * or the like. Any license provided herein, whether implied or
18 18 * otherwise, applies only to this software file. Patent licenses, if
19 19 * any, provided herein do not apply to combinations of this program with
20 20 * other software, or any other product whatsoever.
21 21 *
22 22 * You should have received a copy of the GNU Lesser General Public
23 23 * License along with this library; if not, write to the Free Software
24 24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 25 *
26 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
26 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
27 27 * 28359 Bremen, Germany or:
28 28 *
29 29 * http://www.mevis.de
30 30 *
31 31 */
32 32
33 33 //----------------------------------------------------------------------------------
34 34 /*!
35 35 // \file PyGuiExample.cpp
36 36 // \author Florian Link
37 37 // \author Last changed by $Author: florian $
38 38 // \date 2007-04
39 39 */
40 40 //----------------------------------------------------------------------------------
41 41
42 42 #include "PythonQt.h"
43 43 #include "PythonQt_QtAll.h"
44 44 #include "gui/PythonQtScriptingConsole.h"
45 45
46 46 #include <QApplication>
47 47 #include <QWidget>
48 48 #include <QMainWindow>
49 49 #include <QPushButton>
50 50 #include <QLayout>
51 51
52 52
53 53 int main( int argc, char **argv )
54 54 {
55 55 QApplication qapp(argc, argv);
56 56
57 57 PythonQt::init(PythonQt::IgnoreSiteModule | PythonQt::RedirectStdOut);
58 58 PythonQt_QtAll::init();
59 59
60 60 PythonQtObjectPtr mainContext = PythonQt::self()->getMainModule();
61 61 PythonQtScriptingConsole console(NULL, mainContext);
62 62
63 63 mainContext.evalFile(":example.py");
64 64
65 65 console.show();
66 66 return qapp.exec();
67 67 }
68 68
Show file before | Show file after | Hide comments
@@ -1,90 +1,90
1 1 /*
2 2 *
3 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
3 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
4 4 *
5 5 * This library is free software; you can redistribute it and/or
6 6 * modify it under the terms of the GNU Lesser General Public
7 7 * License as published by the Free Software Foundation; either
8 8 * version 2.1 of the License, or (at your option) any later version.
9 9 *
10 10 * This library is distributed in the hope that it will be useful,
11 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 13 * Lesser General Public License for more details.
14 14 *
15 15 * Further, this software is distributed without any warranty that it is
16 16 * free of the rightful claim of any third person regarding infringement
17 17 * or the like. Any license provided herein, whether implied or
18 18 * otherwise, applies only to this software file. Patent licenses, if
19 19 * any, provided herein do not apply to combinations of this program with
20 20 * other software, or any other product whatsoever.
21 21 *
22 22 * You should have received a copy of the GNU Lesser General Public
23 23 * License along with this library; if not, write to the Free Software
24 24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 25 *
26 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
26 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
27 27 * 28359 Bremen, Germany or:
28 28 *
29 29 * http://www.mevis.de
30 30 *
31 31 */
32 32
33 33 //----------------------------------------------------------------------------------
34 34 /*!
35 35 // \file PyGuiExample.cpp
36 36 // \author Florian Link
37 37 // \author Last changed by $Author: florian $
38 38 // \date 2007-04
39 39 */
40 40 //----------------------------------------------------------------------------------
41 41
42 42 #include "PythonQt.h"
43 43 #include "PythonQt_QtAll.h"
44 44 #include "gui/PythonQtScriptingConsole.h"
45 45
46 46 #include <QApplication>
47 47 #include <QDir>
48 48 #include <QMessageBox>
49 49
50 50
51 51 int main( int argc, char **argv )
52 52 {
53 53 QApplication qapp(argc, argv);
54 54
55 55 PythonQt::init(PythonQt::IgnoreSiteModule | PythonQt::RedirectStdOut);
56 56 PythonQt_QtAll::init();
57 57
58 58 PythonQtObjectPtr mainContext = PythonQt::self()->getMainModule();
59 59
60 60 bool showConsole = false;
61 61 QStringList files;
62 62 for (int i = 1; i < argc; i++) {
63 63 QString arg = argv[i];
64 64 QString argLower = arg.toLower();
65 65 if (argLower == "-console" || argLower == "-c") {
66 66 showConsole = true;
67 67 } else {
68 68 QString file = arg;
69 69 QFileInfo info(file);
70 70 if (info.exists()) {
71 71 files << info.absoluteFilePath();
72 72 // add the file's absolute path for local importing
73 73 PythonQt::self()->addSysPath(info.absolutePath());
74 74 } else {
75 75 QMessageBox::warning(NULL, "PyLauncher", QString("File does not exist: %1").arg(file));
76 76 }
77 77 }
78 78 }
79 79 PythonQtScriptingConsole console(NULL, mainContext);
80 80
81 81 foreach(QString file, files) {
82 82 mainContext.evalFile(file);
83 83 }
84 84 if (showConsole || console.hadError()) {
85 85 console.show();
86 86 }
87 87
88 88 return qapp.exec();
89 89 }
90 90
Show file before | Show file after | Hide comments
@@ -1,87 +1,87
1 1 /*
2 2 *
3 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
3 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
4 4 *
5 5 * This library is free software; you can redistribute it and/or
6 6 * modify it under the terms of the GNU Lesser General Public
7 7 * License as published by the Free Software Foundation; either
8 8 * version 2.1 of the License, or (at your option) any later version.
9 9 *
10 10 * This library is distributed in the hope that it will be useful,
11 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 13 * Lesser General Public License for more details.
14 14 *
15 15 * Further, this software is distributed without any warranty that it is
16 16 * free of the rightful claim of any third person regarding infringement
17 17 * or the like. Any license provided herein, whether implied or
18 18 * otherwise, applies only to this software file. Patent licenses, if
19 19 * any, provided herein do not apply to combinations of this program with
20 20 * other software, or any other product whatsoever.
21 21 *
22 22 * You should have received a copy of the GNU Lesser General Public
23 23 * License along with this library; if not, write to the Free Software
24 24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 25 *
26 26 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
27 27 * 28359 Bremen, Germany or:
28 28 *
29 29 * http://www.mevis.de
30 30 *
31 31 */
32 32
33 33 //----------------------------------------------------------------------------------
34 34 /*!
35 35 // \file PyExampleObject.cpp
36 36 // \author Florian Link
37 37 // \author Last changed by $Author: florian $
38 38 // \date 2006-10
39 39 */
40 40 //----------------------------------------------------------------------------------
41 41
42 42 #include "PyExampleObject.h"
43 43 #include <QMessageBox>
44 44 #include <QDir>
45 45
46 46 PyExampleObject::PyExampleObject():QObject(NULL)
47 47 {
48 48 }
49 49
50 50 PyObject* PyExampleObject::getMainModule() {
51 51 return PythonQt::self()->getMainModule();
52 52 }
53 53
54 54 void PyExampleObject::showInformation(const QString& str)
55 55 {
56 56 QMessageBox::information ( NULL, "Test", str);
57 57 }
58 58
59 59 QStringList PyExampleObject::readDirectory(const QString& dir)
60 60 {
61 61 QDir d(dir);
62 62 return d.entryList();
63 63 }
64 64
65 65 QMainWindow* PyExampleObject::createWindow()
66 66 {
67 67 QMainWindow* m = new QMainWindow();
68 68 QPushButton* b = new QPushButton(m);
69 69 b->setObjectName("button1");
70 70
71 71 m->show();
72 72 return m;
73 73 }
74 74
75 75 QObject* PyExampleObject::findChild(QObject* o, const QString& name)
76 76 {
77 77 return qFindChild<QObject*>(o, name);
78 78 }
79 79
80 80 QVariantMap PyExampleObject::testMap()
81 81 {
82 82 QVariantMap m;
83 83 m.insert("a", QStringList() << "test1" << "test2");
84 84 m.insert("b", 12);
85 85 m.insert("c", 12.);
86 86 return m;
87 87 }
Show file before | Show file after | Hide comments
@@ -1,79 +1,79
1 1 #ifndef _PYEXAMPLEOBJECT_H
2 2 #define _PYEXAMPLEOBJECT_H
3 3
4 4 /*
5 5 *
6 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
6 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
7 7 *
8 8 * This library is free software; you can redistribute it and/or
9 9 * modify it under the terms of the GNU Lesser General Public
10 10 * License as published by the Free Software Foundation; either
11 11 * version 2.1 of the License, or (at your option) any later version.
12 12 *
13 13 * This library is distributed in the hope that it will be useful,
14 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 16 * Lesser General Public License for more details.
17 17 *
18 18 * Further, this software is distributed without any warranty that it is
19 19 * free of the rightful claim of any third person regarding infringement
20 20 * or the like. Any license provided herein, whether implied or
21 21 * otherwise, applies only to this software file. Patent licenses, if
22 22 * any, provided herein do not apply to combinations of this program with
23 23 * other software, or any other product whatsoever.
24 24 *
25 25 * You should have received a copy of the GNU Lesser General Public
26 26 * License along with this library; if not, write to the Free Software
27 27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 28 *
29 29 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
30 30 * 28359 Bremen, Germany or:
31 31 *
32 32 * http://www.mevis.de
33 33 *
34 34 */
35 35
36 36 //----------------------------------------------------------------------------------
37 37 /*!
38 38 // \file PyExampleObject.h
39 39 // \author Florian Link
40 40 // \author Last changed by $Author: florian $
41 41 // \date 2006-10
42 42 */
43 43 //----------------------------------------------------------------------------------
44 44
45 45 #include "PythonQt.h"
46 46
47 47 #include <QObject>
48 48 #include <QStringList>
49 49 #include <QMainWindow>
50 50 #include <QPushButton>
51 51 #include <QVariant>
52 52 #include <QLayout>
53 53
54 54
55 55 class PyExampleObject : public QObject {
56 56
57 57 Q_OBJECT
58 58
59 59 public:
60 60 PyExampleObject();
61 61
62 62 public slots:
63 63
64 64 //! example for passing a PyObject directly from Qt to Python (without extra mashalling)
65 65 PyObject* getMainModule();
66 66
67 67 void showInformation(const QString& str);
68 68
69 69 QStringList readDirectory(const QString& dir);
70 70
71 71 QMainWindow* createWindow();
72 72
73 73 QObject* findChild(QObject* o, const QString& name);
74 74
75 75 QVariantMap testMap();
76 76
77 77 };
78 78
79 79 #endif
Show file before | Show file after | Hide comments
@@ -1,74 +1,74
1 1 /*
2 2 *
3 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
3 * Copyright (C) MeVis Medical Solutions AG All Rights Reserved.
4 4 *
5 5 * This library is free software; you can redistribute it and/or
6 6 * modify it under the terms of the GNU Lesser General Public
7 7 * License as published by the Free Software Foundation; either
8 8 * version 2.1 of the License, or (at your option) any later version.
9 9 *
10 10 * This library is distributed in the hope that it will be useful,
11 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 13 * Lesser General Public License for more details.
14 14 *
15 15 * Further, this software is distributed without any warranty that it is
16 16 * free of the rightful claim of any third person regarding infringement
17 17 * or the like. Any license provided herein, whether implied or
18 18 * otherwise, applies only to this software file. Patent licenses, if
19 19 * any, provided herein do not apply to combinations of this program with
20 20 * other software, or any other product whatsoever.
21 21 *
22 22 * You should have received a copy of the GNU Lesser General Public
23 23 * License along with this library; if not, write to the Free Software
24 24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 25 *
26 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
26 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
27 27 * 28359 Bremen, Germany or:
28 28 *
29 29 * http://www.mevis.de
30 30 *
31 31 */
32 32
33 33 //----------------------------------------------------------------------------------
34 34 /*!
35 35 // \file PythonQtTests.cpp
36 36 // \author Florian Link
37 37 // \author Last changed by $Author: florian $
38 38 // \date 2006-05
39 39 */
40 40 //----------------------------------------------------------------------------------
41 41
42 42 #include "PythonQt.h"
43 43 #include "PythonQt_QtAll.h"
44 44
45 45 #include "PyExampleObject.h"
46 46 #include "gui/PythonQtScriptingConsole.h"
47 47
48 48 #include <QApplication>
49 49 #include <QWidget>
50 50 #include <QMainWindow>
51 51 #include <QPushButton>
52 52 #include <QLayout>
53 53
54 54
55 55 int main( int argc, char **argv )
56 56 {
57 57 QApplication qapp(argc, argv);
58 58
59 59 PythonQt::init(PythonQt::IgnoreSiteModule | PythonQt::RedirectStdOut);
60 60 PythonQt_QtAll::init();
61 61
62 62 PythonQtObjectPtr mainContext = PythonQt::self()->getMainModule();
63 63 PythonQtScriptingConsole console(NULL, mainContext);
64 64
65 65 // add a QObject to the namespace of the main python context
66 66 PyExampleObject example;
67 67 mainContext.addObject("example", &example);
68 68
69 69 mainContext.evalFile(":example.py");
70 70
71 71 console.show();
72 72 return qapp.exec();
73 73 }
74 74
Show file before | Show file after | Hide comments
@@ -1,67 +1,67
1 1 /*
2 2 *
3 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
3 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
4 4 *
5 5 * This library is free software; you can redistribute it and/or
6 6 * modify it under the terms of the GNU Lesser General Public
7 7 * License as published by the Free Software Foundation; either
8 8 * version 2.1 of the License, or (at your option) any later version.
9 9 *
10 10 * This library is distributed in the hope that it will be useful,
11 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 13 * Lesser General Public License for more details.
14 14 *
15 15 * Further, this software is distributed without any warranty that it is
16 16 * free of the rightful claim of any third person regarding infringement
17 17 * or the like. Any license provided herein, whether implied or
18 18 * otherwise, applies only to this software file. Patent licenses, if
19 19 * any, provided herein do not apply to combinations of this program with
20 20 * other software, or any other product whatsoever.
21 21 *
22 22 * You should have received a copy of the GNU Lesser General Public
23 23 * License along with this library; if not, write to the Free Software
24 24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 25 *
26 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
26 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
27 27 * 28359 Bremen, Germany or:
28 28 *
29 29 * http://www.mevis.de
30 30 *
31 31 */
32 32
33 33 #include "PythonQt_QtAll.h"
34 34
35 35 #include "PythonQt.h"
36 36
37 37 void PythonQt_init_QtGui(PyObject*);
38 38 void PythonQt_init_QtSvg(PyObject*);
39 39 void PythonQt_init_QtSql(PyObject*);
40 40 void PythonQt_init_QtNetwork(PyObject*);
41 41 void PythonQt_init_QtCore(PyObject*);
42 42 void PythonQt_init_QtWebKit(PyObject*);
43 43 void PythonQt_init_QtOpenGL(PyObject*);
44 44 void PythonQt_init_QtXml(PyObject*);
45 45 void PythonQt_init_QtXmlPatterns(PyObject*);
46 46 void PythonQt_init_QtUiTools(PyObject*);
47 47 void PythonQt_init_QtPhonon(PyObject*);
48 48
49 49 namespace PythonQt_QtAll
50 50 {
51 51 PYTHONQT_QTALL_EXPORT void init() {
52 52 PythonQt_init_QtCore(0);
53 53 PythonQt_init_QtNetwork(0);
54 54 PythonQt_init_QtGui(0);
55 55 PythonQt_init_QtXml(0);
56 56 PythonQt_init_QtSvg(0);
57 57 PythonQt_init_QtSql(0);
58 58 PythonQt_init_QtWebKit(0);
59 59 PythonQt_init_QtOpenGL(0);
60 60 PythonQt_init_QtUiTools(0);
61 61 // Does not compile yet:
62 62 // PythonQt_init_QtXmlPatterns(0);
63 63 // PythonQt_init_QtPhonon(0);
64 64 };
65 65 };
66 66
67 67
Show file before | Show file after | Hide comments
@@ -1,52 +1,52
1 1 #ifndef _PYTHONQT_QTALL_H
2 2 #define _PYTHONQT_QTALL_H
3 3
4 4 /*
5 5 *
6 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
6 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
7 7 *
8 8 * This library is free software; you can redistribute it and/or
9 9 * modify it under the terms of the GNU Lesser General Public
10 10 * License as published by the Free Software Foundation; either
11 11 * version 2.1 of the License, or (at your option) any later version.
12 12 *
13 13 * This library is distributed in the hope that it will be useful,
14 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 16 * Lesser General Public License for more details.
17 17 *
18 18 * Further, this software is distributed without any warranty that it is
19 19 * free of the rightful claim of any third person regarding infringement
20 20 * or the like. Any license provided herein, whether implied or
21 21 * otherwise, applies only to this software file. Patent licenses, if
22 22 * any, provided herein do not apply to combinations of this program with
23 23 * other software, or any other product whatsoever.
24 24 *
25 25 * You should have received a copy of the GNU Lesser General Public
26 26 * License along with this library; if not, write to the Free Software
27 27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 28 *
29 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
29 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
30 30 * 28359 Bremen, Germany or:
31 31 *
32 32 * http://www.mevis.de
33 33 *
34 34 */
35 35
36 36 #ifdef WIN32
37 37 #ifdef PYTHONQT_QTALL_EXPORTS
38 38 #define PYTHONQT_QTALL_EXPORT __declspec(dllexport)
39 39 #else
40 40 #define PYTHONQT_QTALL_EXPORT __declspec(dllimport)
41 41 #endif
42 42 #else
43 43 #define PYTHONQT_QTALL_EXPORT
44 44 #endif
45 45
46 46 namespace PythonQt_QtAll
47 47 {
48 48 //! initialize the Qt binding
49 49 PYTHONQT_QTALL_EXPORT void init();
50 50 };
51 51
52 52 #endif
Show file before | Show file after | Hide comments
@@ -1,1220 +1,1220
1 1 /*
2 2 *
3 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
3 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
4 4 *
5 5 * This library is free software; you can redistribute it and/or
6 6 * modify it under the terms of the GNU Lesser General Public
7 7 * License as published by the Free Software Foundation; either
8 8 * version 2.1 of the License, or (at your option) any later version.
9 9 *
10 10 * This library is distributed in the hope that it will be useful,
11 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 13 * Lesser General Public License for more details.
14 14 *
15 15 * Further, this software is distributed without any warranty that it is
16 16 * free of the rightful claim of any third person regarding infringement
17 17 * or the like. Any license provided herein, whether implied or
18 18 * otherwise, applies only to this software file. Patent licenses, if
19 19 * any, provided herein do not apply to combinations of this program with
20 20 * other software, or any other product whatsoever.
21 21 *
22 22 * You should have received a copy of the GNU Lesser General Public
23 23 * License along with this library; if not, write to the Free Software
24 24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 25 *
26 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
26 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
27 27 * 28359 Bremen, Germany or:
28 28 *
29 29 * http://www.mevis.de
30 30 *
31 31 */
32 32
33 33 //----------------------------------------------------------------------------------
34 34 /*!
35 35 // \file PythonQt.cpp
36 36 // \author Florian Link
37 37 // \author Last changed by $Author: florian $
38 38 // \date 2006-05
39 39 */
40 40 //----------------------------------------------------------------------------------
41 41
42 42 #include "PythonQt.h"
43 43 #include "PythonQtImporter.h"
44 44 #include "PythonQtClassInfo.h"
45 45 #include "PythonQtMethodInfo.h"
46 46 #include "PythonQtSignalReceiver.h"
47 47 #include "PythonQtConversion.h"
48 48 #include "PythonQtStdOut.h"
49 49 #include "PythonQtCppWrapperFactory.h"
50 50 #include "PythonQtVariants.h"
51 51 #include "PythonQtStdDecorators.h"
52 52 #include "PythonQtQFileImporter.h"
53 53 #include <pydebug.h>
54 54 #include <vector>
55 55
56 56 PythonQt* PythonQt::_self = NULL;
57 57 int PythonQt::_uniqueModuleCount = 0;
58 58
59 59 void PythonQt_init_QtGuiBuiltin(PyObject*);
60 60 void PythonQt_init_QtCoreBuiltin(PyObject*);
61 61
62 62 void PythonQt::init(int flags, const QByteArray& pythonQtModuleName)
63 63 {
64 64 if (!_self) {
65 65 _self = new PythonQt(flags, pythonQtModuleName);
66 66
67 67 PythonQtMethodInfo::addParameterTypeAlias("QObjectList", "QList<QObject*>");
68 68 qRegisterMetaType<QList<QObject*> >("QList<void*>");
69 69
70 70 PythonQtRegisterToolClassesTemplateConverter(int);
71 71 PythonQtRegisterToolClassesTemplateConverter(float);
72 72 PythonQtRegisterToolClassesTemplateConverter(double);
73 73 PythonQtRegisterToolClassesTemplateConverter(qint32);
74 74 PythonQtRegisterToolClassesTemplateConverter(quint32);
75 75 PythonQtRegisterToolClassesTemplateConverter(qint64);
76 76 PythonQtRegisterToolClassesTemplateConverter(quint64);
77 77 // TODO: which other POD types should be available for QList etc.
78 78
79 79 PythonQt::self()->addDecorators(new PythonQtStdDecorators());
80 80
81 81 PythonQt_init_QtCoreBuiltin(NULL);
82 82 PythonQt_init_QtGuiBuiltin(NULL);
83 83
84 84 PythonQtRegisterToolClassesTemplateConverter(QByteArray);
85 85 PythonQtRegisterToolClassesTemplateConverter(QDate);
86 86 PythonQtRegisterToolClassesTemplateConverter(QTime);
87 87 PythonQtRegisterToolClassesTemplateConverter(QDateTime);
88 88 PythonQtRegisterToolClassesTemplateConverter(QUrl);
89 89 PythonQtRegisterToolClassesTemplateConverter(QLocale);
90 90 PythonQtRegisterToolClassesTemplateConverter(QRect);
91 91 PythonQtRegisterToolClassesTemplateConverter(QRectF);
92 92 PythonQtRegisterToolClassesTemplateConverter(QSize);
93 93 PythonQtRegisterToolClassesTemplateConverter(QSizeF);
94 94 PythonQtRegisterToolClassesTemplateConverter(QLine);
95 95 PythonQtRegisterToolClassesTemplateConverter(QLineF);
96 96 PythonQtRegisterToolClassesTemplateConverter(QPoint);
97 97 PythonQtRegisterToolClassesTemplateConverter(QPointF);
98 98 PythonQtRegisterToolClassesTemplateConverter(QRegExp);
99 99
100 100 PythonQtRegisterToolClassesTemplateConverter(QFont);
101 101 PythonQtRegisterToolClassesTemplateConverter(QPixmap);
102 102 PythonQtRegisterToolClassesTemplateConverter(QBrush);
103 103 PythonQtRegisterToolClassesTemplateConverter(QColor);
104 104 PythonQtRegisterToolClassesTemplateConverter(QPalette);
105 105 PythonQtRegisterToolClassesTemplateConverter(QIcon);
106 106 PythonQtRegisterToolClassesTemplateConverter(QImage);
107 107 PythonQtRegisterToolClassesTemplateConverter(QPolygon);
108 108 PythonQtRegisterToolClassesTemplateConverter(QRegion);
109 109 PythonQtRegisterToolClassesTemplateConverter(QBitmap);
110 110 PythonQtRegisterToolClassesTemplateConverter(QCursor);
111 111 PythonQtRegisterToolClassesTemplateConverter(QSizePolicy);
112 112 PythonQtRegisterToolClassesTemplateConverter(QKeySequence);
113 113 PythonQtRegisterToolClassesTemplateConverter(QPen);
114 114 PythonQtRegisterToolClassesTemplateConverter(QTextLength);
115 115 PythonQtRegisterToolClassesTemplateConverter(QTextFormat);
116 116 PythonQtRegisterToolClassesTemplateConverter(QMatrix);
117 117
118 118
119 119 PyObject* pack = PythonQt::priv()->packageByName("QtCore");
120 120 PyObject* pack2 = PythonQt::priv()->packageByName("Qt");
121 121 PyObject* qtNamespace = PythonQt::priv()->getClassInfo("Qt")->pythonQtClassWrapper();
122 122 const char* names[16] = {"SIGNAL", "SLOT", "qAbs", "qBound","qDebug","qWarning","qCritical","qFatal"
123 123 ,"qFuzzyCompare", "qMax","qMin","qRound","qRound64","qVersion","qrand","qsrand"};
124 124 for (unsigned int i = 0;i<16; i++) {
125 125 PyObject* obj = PyObject_GetAttrString(qtNamespace, names[i]);
126 126 if (obj) {
127 127 PyModule_AddObject(pack, names[i], obj);
128 128 Py_INCREF(obj);
129 129 PyModule_AddObject(pack2, names[i], obj);
130 130 } else {
131 131 std::cerr << "method not found " << names[i];
132 132 }
133 133 }
134 134 }
135 135 }
136 136
137 137 void PythonQt::cleanup()
138 138 {
139 139 if (_self) {
140 140 delete _self;
141 141 _self = NULL;
142 142 }
143 143 }
144 144
145 145 PythonQt::PythonQt(int flags, const QByteArray& pythonQtModuleName)
146 146 {
147 147 _p = new PythonQtPrivate;
148 148 _p->_initFlags = flags;
149 149
150 150 _p->_PythonQtObjectPtr_metaId = qRegisterMetaType<PythonQtObjectPtr>("PythonQtObjectPtr");
151 151
152 152 Py_SetProgramName("PythonQt");
153 153 if (flags & IgnoreSiteModule) {
154 154 // this prevents the automatic importing of Python site files
155 155 Py_NoSiteFlag = 1;
156 156 }
157 157 Py_Initialize();
158 158
159 159 // add our own python object types for qt object slots
160 160 if (PyType_Ready(&PythonQtSlotFunction_Type) < 0) {
161 161 std::cerr << "could not initialize PythonQtSlotFunction_Type" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
162 162 }
163 163 Py_INCREF(&PythonQtSlotFunction_Type);
164 164
165 165 // according to Python docs, set the type late here, since it can not safely be stored in the struct when declaring it
166 166 PythonQtClassWrapper_Type.tp_base = &PyType_Type;
167 167 // add our own python object types for classes
168 168 if (PyType_Ready(&PythonQtClassWrapper_Type) < 0) {
169 169 std::cerr << "could not initialize PythonQtClassWrapper_Type" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
170 170 }
171 171 Py_INCREF(&PythonQtClassWrapper_Type);
172 172
173 173 // add our own python object types for CPP instances
174 174 if (PyType_Ready(&PythonQtInstanceWrapper_Type) < 0) {
175 175 PythonQt::handleError();
176 176 std::cerr << "could not initialize PythonQtInstanceWrapper_Type" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
177 177 }
178 178 Py_INCREF(&PythonQtInstanceWrapper_Type);
179 179
180 180 // add our own python object types for redirection of stdout
181 181 if (PyType_Ready(&PythonQtStdOutRedirectType) < 0) {
182 182 std::cerr << "could not initialize PythonQtStdOutRedirectType" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
183 183 }
184 184 Py_INCREF(&PythonQtStdOutRedirectType);
185 185
186 186 initPythonQtModule(flags & RedirectStdOut, pythonQtModuleName);
187 187
188 188 _p->setupSharedLibrarySuffixes();
189 189
190 190 }
191 191
192 192 PythonQt::~PythonQt() {
193 193 delete _p;
194 194 _p = NULL;
195 195 }
196 196
197 197 PythonQtPrivate::~PythonQtPrivate() {
198 198 delete _defaultImporter;
199 199 _defaultImporter = NULL;
200 200
201 201 {
202 202 QHashIterator<QByteArray, PythonQtClassInfo *> i(_knownClassInfos);
203 203 while (i.hasNext()) {
204 204 delete i.next().value();
205 205 }
206 206 }
207 207 PythonQtConv::global_valueStorage.clear();
208 208 PythonQtConv::global_ptrStorage.clear();
209 209 PythonQtConv::global_variantStorage.clear();
210 210
211 211 PythonQtMethodInfo::cleanupCachedMethodInfos();
212 212 }
213 213
214 214 PythonQtImportFileInterface* PythonQt::importInterface()
215 215 {
216 216 return _self->_p->_importInterface?_self->_p->_importInterface:_self->_p->_defaultImporter;
217 217 }
218 218
219 219 void PythonQt::qObjectNoLongerWrappedCB(QObject* o)
220 220 {
221 221 if (_self->_p->_noLongerWrappedCB) {
222 222 (*_self->_p->_noLongerWrappedCB)(o);
223 223 };
224 224 }
225 225
226 226 void PythonQt::registerClass(const QMetaObject* metaobject, const char* package, PythonQtQObjectCreatorFunctionCB* wrapperCreator, PythonQtShellSetInstanceWrapperCB* shell)
227 227 {
228 228 _p->registerClass(metaobject, package, wrapperCreator, shell);
229 229 }
230 230
231 231 void PythonQtPrivate::registerClass(const QMetaObject* metaobject, const char* package, PythonQtQObjectCreatorFunctionCB* wrapperCreator, PythonQtShellSetInstanceWrapperCB* shell, PyObject* module, int typeSlots)
232 232 {
233 233 // we register all classes in the hierarchy
234 234 const QMetaObject* m = metaobject;
235 235 bool first = true;
236 236 while (m) {
237 237 PythonQtClassInfo* info = lookupClassInfoAndCreateIfNotPresent(m->className());
238 238 if (!info->pythonQtClassWrapper()) {
239 239 info->setTypeSlots(typeSlots);
240 240 info->setupQObject(m);
241 241 createPythonQtClassWrapper(info, package, module);
242 242 if (m->superClass()) {
243 243 PythonQtClassInfo* parentInfo = lookupClassInfoAndCreateIfNotPresent(m->superClass()->className());
244 244 info->addParentClass(PythonQtClassInfo::ParentClassInfo(parentInfo));
245 245 }
246 246 }
247 247 if (first) {
248 248 first = false;
249 249 if (wrapperCreator) {
250 250 info->setDecoratorProvider(wrapperCreator);
251 251 }
252 252 if (shell) {
253 253 info->setShellSetInstanceWrapperCB(shell);
254 254 }
255 255 }
256 256 m = m->superClass();
257 257 }
258 258 }
259 259
260 260 void PythonQtPrivate::createPythonQtClassWrapper(PythonQtClassInfo* info, const char* package, PyObject* module)
261 261 {
262 262 PyObject* pack = module?module:packageByName(package);
263 263 PyObject* pyobj = (PyObject*)createNewPythonQtClassWrapper(info, pack);
264 264 PyModule_AddObject(pack, info->className(), pyobj);
265 265 if (!module && package && strncmp(package,"Qt",2)==0) {
266 266 // since PyModule_AddObject steals the reference, we need a incref once more...
267 267 Py_INCREF(pyobj);
268 268 // put all qt objects into Qt as well
269 269 PyModule_AddObject(packageByName("Qt"), info->className(), pyobj);
270 270 }
271 271 info->setPythonQtClassWrapper(pyobj);
272 272 }
273 273
274 274 PyObject* PythonQtPrivate::wrapQObject(QObject* obj)
275 275 {
276 276 if (!obj) {
277 277 Py_INCREF(Py_None);
278 278 return Py_None;
279 279 }
280 280 PythonQtInstanceWrapper* wrap = findWrapperAndRemoveUnused(obj);
281 281 if (!wrap) {
282 282 // smuggling it in...
283 283 PythonQtClassInfo* classInfo = _knownClassInfos.value(obj->metaObject()->className());
284 284 if (!classInfo || classInfo->pythonQtClassWrapper()==NULL) {
285 285 registerClass(obj->metaObject());
286 286 classInfo = _knownClassInfos.value(obj->metaObject()->className());
287 287 }
288 288 wrap = createNewPythonQtInstanceWrapper(obj, classInfo);
289 289 // mlabDebugConst("MLABPython","new qobject wrapper added " << " " << wrap->_obj->className() << " " << wrap->classInfo()->wrappedClassName().latin1());
290 290 } else {
291 291 Py_INCREF(wrap);
292 292 // mlabDebugConst("MLABPython","qobject wrapper reused " << wrap->_obj->className() << " " << wrap->classInfo()->wrappedClassName().latin1());
293 293 }
294 294 return (PyObject*)wrap;
295 295 }
296 296
297 297 PyObject* PythonQtPrivate::wrapPtr(void* ptr, const QByteArray& name)
298 298 {
299 299 if (!ptr) {
300 300 Py_INCREF(Py_None);
301 301 return Py_None;
302 302 }
303 303
304 304 PythonQtInstanceWrapper* wrap = findWrapperAndRemoveUnused(ptr);
305 305 if (!wrap) {
306 306 PythonQtClassInfo* info = _knownClassInfos.value(name);
307 307 if (!info) {
308 308 // maybe it is a PyObject, which we can return directly
309 309 if (name == "PyObject") {
310 310 PyObject* p = (PyObject*)ptr;
311 311 Py_INCREF(p);
312 312 return p;
313 313 }
314 314
315 315 // we do not know the metaobject yet, but we might know it by it's name:
316 316 if (_knownQObjectClassNames.find(name)!=_knownQObjectClassNames.end()) {
317 317 // yes, we know it, so we can convert to QObject
318 318 QObject* qptr = (QObject*)ptr;
319 319 registerClass(qptr->metaObject());
320 320 info = _knownClassInfos.value(qptr->metaObject()->className());
321 321 }
322 322 }
323 323 if (info && info->isQObject()) {
324 324 QObject* qptr = (QObject*)ptr;
325 325 // if the object is a derived object, we want to switch the class info to the one of the derived class:
326 326 if (name!=(qptr->metaObject()->className())) {
327 327 registerClass(qptr->metaObject());
328 328 info = _knownClassInfos.value(qptr->metaObject()->className());
329 329 }
330 330 wrap = createNewPythonQtInstanceWrapper(qptr, info);
331 331 // mlabDebugConst("MLABPython","new qobject wrapper added " << " " << wrap->_obj->className() << " " << wrap->classInfo()->wrappedClassName().latin1());
332 332 return (PyObject*)wrap;
333 333 }
334 334
335 335 // not a known QObject, so try our wrapper factory:
336 336 QObject* wrapper = NULL;
337 337 for (int i=0; i<_cppWrapperFactories.size(); i++) {
338 338 wrapper = _cppWrapperFactories.at(i)->create(name, ptr);
339 339 if (wrapper) {
340 340 break;
341 341 }
342 342 }
343 343
344 344 if (info) {
345 345 // try to downcast in the class hierarchy, which will modify info and ptr if it is successfull
346 346 ptr = info->castDownIfPossible(ptr, &info);
347 347 }
348 348
349 349 if (!info || info->pythonQtClassWrapper()==NULL) {
350 350 // still unknown, register as CPP class
351 351 registerCPPClass(name.constData());
352 352 info = _knownClassInfos.value(name);
353 353 }
354 354 if (wrapper && (info->metaObject() != wrapper->metaObject())) {
355 355 // if we a have a QObject wrapper and the metaobjects do not match, set the metaobject again!
356 356 info->setMetaObject(wrapper->metaObject());
357 357 }
358 358 wrap = createNewPythonQtInstanceWrapper(wrapper, info, ptr);
359 359 // mlabDebugConst("MLABPython","new c++ wrapper added " << wrap->_wrappedPtr << " " << wrap->_obj->className() << " " << wrap->classInfo()->wrappedClassName().latin1());
360 360 } else {
361 361 Py_INCREF(wrap);
362 362 //mlabDebugConst("MLABPython","c++ wrapper reused " << wrap->_wrappedPtr << " " << wrap->_obj->className() << " " << wrap->classInfo()->wrappedClassName().latin1());
363 363 }
364 364 return (PyObject*)wrap;
365 365 }
366 366
367 367 PyObject* PythonQtPrivate::dummyTuple() {
368 368 static PyObject* dummyTuple = NULL;
369 369 if (dummyTuple==NULL) {
370 370 dummyTuple = PyTuple_New(1);
371 371 PyTuple_SET_ITEM(dummyTuple, 0 , PyString_FromString("dummy"));
372 372 }
373 373 return dummyTuple;
374 374 }
375 375
376 376
377 377 PythonQtInstanceWrapper* PythonQtPrivate::createNewPythonQtInstanceWrapper(QObject* obj, PythonQtClassInfo* info, void* wrappedPtr) {
378 378 // call the associated class type to create a new instance...
379 379 PythonQtInstanceWrapper* result = (PythonQtInstanceWrapper*)PyObject_Call(info->pythonQtClassWrapper(), dummyTuple(), NULL);
380 380
381 381 result->setQObject(obj);
382 382 result->_wrappedPtr = wrappedPtr;
383 383 result->_ownedByPythonQt = false;
384 384 result->_useQMetaTypeDestroy = false;
385 385
386 386 if (wrappedPtr) {
387 387 _wrappedObjects.insert(wrappedPtr, result);
388 388 } else {
389 389 _wrappedObjects.insert(obj, result);
390 390 if (obj->parent()== NULL && _wrappedCB) {
391 391 // tell someone who is interested that the qobject is wrapped the first time, if it has no parent
392 392 (*_wrappedCB)(obj);
393 393 }
394 394 }
395 395 return result;
396 396 }
397 397
398 398 PythonQtClassWrapper* PythonQtPrivate::createNewPythonQtClassWrapper(PythonQtClassInfo* info, PyObject* parentModule) {
399 399 PythonQtClassWrapper* result;
400 400
401 401 PyObject* className = PyString_FromString(info->className());
402 402
403 403 PyObject* baseClasses = PyTuple_New(1);
404 404 PyTuple_SET_ITEM(baseClasses, 0, (PyObject*)&PythonQtInstanceWrapper_Type);
405 405
406 406 PyObject* typeDict = PyDict_New();
407 407 PyObject* moduleName = PyObject_GetAttrString(parentModule, "__name__");
408 408 PyDict_SetItemString(typeDict, "__module__", moduleName);
409 409
410 410 PyObject* args = Py_BuildValue("OOO", className, baseClasses, typeDict);
411 411
412 412 // set the class info so that PythonQtClassWrapper_new can read it
413 413 _currentClassInfoForClassWrapperCreation = info;
414 414 // create the new type object by calling the type
415 415 result = (PythonQtClassWrapper *)PyObject_Call((PyObject *)&PythonQtClassWrapper_Type, args, NULL);
416 416
417 417 Py_DECREF(baseClasses);
418 418 Py_DECREF(typeDict);
419 419 Py_DECREF(args);
420 420 Py_DECREF(className);
421 421
422 422 return result;
423 423 }
424 424
425 425 PyObject* PythonQtPrivate::createEnumValueInstance(PyObject* enumType, unsigned int enumValue)
426 426 {
427 427 PyObject* args = Py_BuildValue("(i)", enumValue);
428 428 PyObject* result = PyObject_Call(enumType, args, NULL);
429 429 Py_DECREF(args);
430 430 return result;
431 431 }
432 432
433 433 PyObject* PythonQtPrivate::createNewPythonQtEnumWrapper(const char* enumName, PyObject* parentObject) {
434 434 PyObject* result;
435 435
436 436 PyObject* className = PyString_FromString(enumName);
437 437
438 438 PyObject* baseClasses = PyTuple_New(1);
439 439 PyTuple_SET_ITEM(baseClasses, 0, (PyObject*)&PyInt_Type);
440 440
441 441 PyObject* module = PyObject_GetAttrString(parentObject, "__module__");
442 442 PyObject* typeDict = PyDict_New();
443 443 PyDict_SetItemString(typeDict, "__module__", module);
444 444
445 445 PyObject* args = Py_BuildValue("OOO", className, baseClasses, typeDict);
446 446
447 447 // create the new int derived type object by calling the core type
448 448 result = PyObject_Call((PyObject *)&PyType_Type, args, NULL);
449 449
450 450 Py_DECREF(baseClasses);
451 451 Py_DECREF(typeDict);
452 452 Py_DECREF(args);
453 453 Py_DECREF(className);
454 454
455 455 return result;
456 456 }
457 457
458 458 PythonQtSignalReceiver* PythonQt::getSignalReceiver(QObject* obj)
459 459 {
460 460 PythonQtSignalReceiver* r = _p->_signalReceivers[obj];
461 461 if (!r) {
462 462 r = new PythonQtSignalReceiver(obj);
463 463 _p->_signalReceivers.insert(obj, r);
464 464 }
465 465 return r;
466 466 }
467 467
468 468 bool PythonQt::addSignalHandler(QObject* obj, const char* signal, PyObject* module, const QString& objectname)
469 469 {
470 470 bool flag = false;
471 471 PythonQtObjectPtr callable = lookupCallable(module, objectname);
472 472 if (callable) {
473 473 PythonQtSignalReceiver* r = getSignalReceiver(obj);
474 474 flag = r->addSignalHandler(signal, callable);
475 475 if (!flag) {
476 476 // signal not found
477 477 }
478 478 } else {
479 479 // callable not found
480 480 }
481 481 return flag;
482 482 }
483 483
484 484 bool PythonQt::addSignalHandler(QObject* obj, const char* signal, PyObject* receiver)
485 485 {
486 486 bool flag = false;
487 487 PythonQtSignalReceiver* r = getSignalReceiver(obj);
488 488 if (r) {
489 489 flag = r->addSignalHandler(signal, receiver);
490 490 }
491 491 return flag;
492 492 }
493 493
494 494 bool PythonQt::removeSignalHandler(QObject* obj, const char* signal, PyObject* module, const QString& objectname)
495 495 {
496 496 bool flag = false;
497 497 PythonQtObjectPtr callable = lookupCallable(module, objectname);
498 498 if (callable) {
499 499 PythonQtSignalReceiver* r = _p->_signalReceivers[obj];
500 500 if (r) {
501 501 flag = r->removeSignalHandler(signal, callable);
502 502 }
503 503 } else {
504 504 // callable not found
505 505 }
506 506 return flag;
507 507 }
508 508
509 509 bool PythonQt::removeSignalHandler(QObject* obj, const char* signal, PyObject* receiver)
510 510 {
511 511 bool flag = false;
512 512 PythonQtSignalReceiver* r = _p->_signalReceivers[obj];
513 513 if (r) {
514 514 flag = r->removeSignalHandler(signal, receiver);
515 515 }
516 516 return flag;
517 517 }
518 518
519 519 PythonQtObjectPtr PythonQt::lookupCallable(PyObject* module, const QString& name)
520 520 {
521 521 PythonQtObjectPtr p = lookupObject(module, name);
522 522 if (p) {
523 523 if (PyCallable_Check(p)) {
524 524 return p;
525 525 }
526 526 }
527 527 PyErr_Clear();
528 528 return NULL;
529 529 }
530 530
531 531 PythonQtObjectPtr PythonQt::lookupObject(PyObject* module, const QString& name)
532 532 {
533 533 QStringList l = name.split('.');
534 534 PythonQtObjectPtr p = module;
535 535 PythonQtObjectPtr prev;
536 536 QString s;
537 537 QByteArray b;
538 538 for (QStringList::ConstIterator i = l.begin(); i!=l.end() && p; ++i) {
539 539 prev = p;
540 540 b = (*i).toLatin1();
541 541 if (PyDict_Check(p)) {
542 542 p = PyDict_GetItemString(p, b.data());
543 543 } else {
544 544 p.setNewRef(PyObject_GetAttrString(p, b.data()));
545 545 }
546 546 }
547 547 PyErr_Clear();
548 548 return p;
549 549 }
550 550
551 551 PythonQtObjectPtr PythonQt::getMainModule() {
552 552 //both borrowed
553 553 PythonQtObjectPtr dict = PyImport_GetModuleDict();
554 554 return PyDict_GetItemString(dict, "__main__");
555 555 }
556 556
557 557 QVariant PythonQt::evalCode(PyObject* object, PyObject* pycode) {
558 558 QVariant result;
559 559 if (pycode) {
560 560 PyObject* dict = NULL;
561 561 if (PyModule_Check(object)) {
562 562 dict = PyModule_GetDict(object);
563 563 } else if (PyDict_Check(object)) {
564 564 dict = object;
565 565 }
566 566 PyObject* r = NULL;
567 567 if (dict) {
568 568 r = PyEval_EvalCode((PyCodeObject*)pycode, dict , dict);
569 569 }
570 570 if (r) {
571 571 result = PythonQtConv::PyObjToQVariant(r);
572 572 Py_DECREF(r);
573 573 } else {
574 574 handleError();
575 575 }
576 576 } else {
577 577 handleError();
578 578 }
579 579 return result;
580 580 }
581 581
582 582 QVariant PythonQt::evalScript(PyObject* object, const QString& script, int start)
583 583 {
584 584 QVariant result;
585 585 PythonQtObjectPtr p;
586 586 PyObject* dict = NULL;
587 587 if (PyModule_Check(object)) {
588 588 dict = PyModule_GetDict(object);
589 589 } else if (PyDict_Check(object)) {
590 590 dict = object;
591 591 }
592 592 if (dict) {
593 593 p.setNewRef(PyRun_String(script.toLatin1().data(), start, dict, dict));
594 594 }
595 595 if (p) {
596 596 result = PythonQtConv::PyObjToQVariant(p);
597 597 } else {
598 598 handleError();
599 599 }
600 600 return result;
601 601 }
602 602
603 603 void PythonQt::evalFile(PyObject* module, const QString& filename)
604 604 {
605 605 PythonQtObjectPtr code = parseFile(filename);
606 606 if (code) {
607 607 evalCode(module, code);
608 608 } else {
609 609 handleError();
610 610 }
611 611 }
612 612
613 613 PythonQtObjectPtr PythonQt::parseFile(const QString& filename)
614 614 {
615 615 PythonQtObjectPtr p;
616 616 p.setNewRef(PythonQtImport::getCodeFromPyc(filename));
617 617 if (!p) {
618 618 handleError();
619 619 }
620 620 return p;
621 621 }
622 622
623 623 PythonQtObjectPtr PythonQt::createModuleFromFile(const QString& name, const QString& filename)
624 624 {
625 625 PythonQtObjectPtr code = parseFile(filename);
626 626 PythonQtObjectPtr module = _p->createModule(name, code);
627 627 return module;
628 628 }
629 629
630 630 PythonQtObjectPtr PythonQt::createModuleFromScript(const QString& name, const QString& script)
631 631 {
632 632 PyErr_Clear();
633 633 QString scriptCode = script;
634 634 if (scriptCode.isEmpty()) {
635 635 // we always need at least a linefeed
636 636 scriptCode = "\n";
637 637 }
638 638 PythonQtObjectPtr pycode;
639 639 pycode.setNewRef(Py_CompileString((char*)scriptCode.toLatin1().data(), "", Py_file_input));
640 640 PythonQtObjectPtr module = _p->createModule(name, pycode);
641 641 return module;
642 642 }
643 643
644 644 PythonQtObjectPtr PythonQt::createUniqueModule()
645 645 {
646 646 static QString pyQtStr("PythonQt_module");
647 647 QString moduleName = pyQtStr+QString::number(_uniqueModuleCount++);
648 648 return createModuleFromScript(moduleName);
649 649 }
650 650
651 651 void PythonQt::addObject(PyObject* object, const QString& name, QObject* qObject)
652 652 {
653 653 if (PyModule_Check(object)) {
654 654 PyModule_AddObject(object, name.toLatin1().data(), _p->wrapQObject(qObject));
655 655 } else if (PyDict_Check(object)) {
656 656 PyDict_SetItemString(object, name.toLatin1().data(), _p->wrapQObject(qObject));
657 657 } else {
658 658 PyObject_SetAttrString(object, name.toLatin1().data(), _p->wrapQObject(qObject));
659 659 }
660 660 }
661 661
662 662 void PythonQt::addVariable(PyObject* object, const QString& name, const QVariant& v)
663 663 {
664 664 if (PyModule_Check(object)) {
665 665 PyModule_AddObject(object, name.toLatin1().data(), PythonQtConv::QVariantToPyObject(v));
666 666 } else if (PyDict_Check(object)) {
667 667 PyDict_SetItemString(object, name.toLatin1().data(), PythonQtConv::QVariantToPyObject(v));
668 668 } else {
669 669 PyObject_SetAttrString(object, name.toLatin1().data(), PythonQtConv::QVariantToPyObject(v));
670 670 }
671 671 }
672 672
673 673 void PythonQt::removeVariable(PyObject* object, const QString& name)
674 674 {
675 675 if (PyDict_Check(object)) {
676 676 PyDict_DelItemString(object, name.toLatin1().data());
677 677 } else {
678 678 PyObject_DelAttrString(object, name.toLatin1().data());
679 679 }
680 680 }
681 681
682 682 QVariant PythonQt::getVariable(PyObject* object, const QString& objectname)
683 683 {
684 684 QVariant result;
685 685 PythonQtObjectPtr obj = lookupObject(object, objectname);
686 686 if (obj) {
687 687 result = PythonQtConv::PyObjToQVariant(obj);
688 688 }
689 689 return result;
690 690 }
691 691
692 692 QStringList PythonQt::introspection(PyObject* module, const QString& objectname, PythonQt::ObjectType type)
693 693 {
694 694 QStringList results;
695 695
696 696 PythonQtObjectPtr object;
697 697 if (objectname.isEmpty()) {
698 698 object = module;
699 699 } else {
700 700 object = lookupObject(module, objectname);
701 701 if (!object && type == CallOverloads) {
702 702 PyObject* dict = lookupObject(module, "__builtins__");
703 703 if (dict) {
704 704 object = PyDict_GetItemString(dict, objectname.toLatin1().constData());
705 705 }
706 706 }
707 707 }
708 708
709 709 if (object) {
710 710 if (type == CallOverloads) {
711 711 if (PythonQtSlotFunction_Check(object)) {
712 712 PythonQtSlotFunctionObject* o = (PythonQtSlotFunctionObject*)object.object();
713 713 PythonQtSlotInfo* info = o->m_ml;
714 714
715 715 while (info) {
716 716 results << info->fullSignature();
717 717 info = info->nextInfo();
718 718 }
719 719 } else if (object->ob_type == &PythonQtClassWrapper_Type) {
720 720 PythonQtClassWrapper* o = (PythonQtClassWrapper*)object.object();
721 721 PythonQtSlotInfo* info = o->classInfo()->constructors();
722 722
723 723 while (info) {
724 724 results << info->fullSignature();
725 725 info = info->nextInfo();
726 726 }
727 727 } else {
728 728 //TODO: use pydoc!
729 729 PyObject* doc = PyObject_GetAttrString(object, "__doc__");
730 730 if (doc) {
731 731 results << PyString_AsString(doc);
732 732 Py_DECREF(doc);
733 733 }
734 734 }
735 735 } else {
736 736 PyObject* keys = NULL;
737 737 bool isDict = false;
738 738 if (PyDict_Check(object)) {
739 739 keys = PyDict_Keys(object);
740 740 isDict = true;
741 741 } else {
742 742 keys = PyObject_Dir(object);
743 743 }
744 744 if (keys) {
745 745 int count = PyList_Size(keys);
746 746 PyObject* key;
747 747 PyObject* value;
748 748 QString keystr;
749 749 for (int i = 0;i<count;i++) {
750 750 key = PyList_GetItem(keys,i);
751 751 if (isDict) {
752 752 value = PyDict_GetItem(object, key);
753 753 Py_INCREF(value);
754 754 } else {
755 755 value = PyObject_GetAttr(object, key);
756 756 }
757 757 if (!value) continue;
758 758 keystr = PyString_AsString(key);
759 759 static const QString underscoreStr("__tmp");
760 760 if (!keystr.startsWith(underscoreStr)) {
761 761 switch (type) {
762 762 case Anything:
763 763 results << keystr;
764 764 break;
765 765 case Class:
766 766 if (value->ob_type == &PyClass_Type) {
767 767 results << keystr;
768 768 }
769 769 break;
770 770 case Variable:
771 771 if (value->ob_type != &PyClass_Type
772 772 && value->ob_type != &PyCFunction_Type
773 773 && value->ob_type != &PyFunction_Type
774 774 && value->ob_type != &PyModule_Type
775 775 ) {
776 776 results << keystr;
777 777 }
778 778 break;
779 779 case Function:
780 780 if (value->ob_type == &PyFunction_Type ||
781 781 value->ob_type == &PyMethod_Type
782 782 ) {
783 783 results << keystr;
784 784 }
785 785 break;
786 786 case Module:
787 787 if (value->ob_type == &PyModule_Type) {
788 788 results << keystr;
789 789 }
790 790 break;
791 791 default:
792 792 std::cerr << "PythonQt: introspection: unknown case" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
793 793 }
794 794 }
795 795 Py_DECREF(value);
796 796 }
797 797 Py_DECREF(keys);
798 798 }
799 799 }
800 800 }
801 801 return results;
802 802 }
803 803
804 804 QVariant PythonQt::call(PyObject* object, const QString& name, const QVariantList& args)
805 805 {
806 806 PythonQtObjectPtr callable = lookupCallable(object, name);
807 807 if (callable) {
808 808 return call(callable, args);
809 809 } else {
810 810 return QVariant();
811 811 }
812 812 }
813 813
814 814 QVariant PythonQt::call(PyObject* callable, const QVariantList& args)
815 815 {
816 816 QVariant r;
817 817 PythonQtObjectPtr result;
818 818 result.setNewRef(callAndReturnPyObject(callable, args));
819 819 if (result) {
820 820 r = PythonQtConv::PyObjToQVariant(result);
821 821 } else {
822 822 PythonQt::self()->handleError();
823 823 }
824 824 return r;
825 825 }
826 826
827 827 PyObject* PythonQt::callAndReturnPyObject(PyObject* callable, const QVariantList& args)
828 828 {
829 829 PyObject* result = NULL;
830 830 if (callable) {
831 831 PythonQtObjectPtr pargs;
832 832 int count = args.size();
833 833 if (count>0) {
834 834 pargs.setNewRef(PyTuple_New(count));
835 835 }
836 836 bool err = false;
837 837 // transform QVariants to Python
838 838 for (int i = 0; i < count; i++) {
839 839 PyObject* arg = PythonQtConv::QVariantToPyObject(args.at(i));
840 840 if (arg) {
841 841 // steals reference, no unref
842 842 PyTuple_SetItem(pargs, i,arg);
843 843 } else {
844 844 err = true;
845 845 break;
846 846 }
847 847 }
848 848
849 849 if (!err) {
850 850 PyErr_Clear();
851 851 result = PyObject_CallObject(callable, pargs);
852 852 }
853 853 }
854 854 return result;
855 855 }
856 856
857 857 void PythonQt::addInstanceDecorators(QObject* o)
858 858 {
859 859 _p->addDecorators(o, PythonQtPrivate::InstanceDecorator);
860 860 }
861 861
862 862 void PythonQt::addClassDecorators(QObject* o)
863 863 {
864 864 _p->addDecorators(o, PythonQtPrivate::StaticDecorator | PythonQtPrivate::ConstructorDecorator | PythonQtPrivate::DestructorDecorator);
865 865 }
866 866
867 867 void PythonQt::addDecorators(QObject* o)
868 868 {
869 869 _p->addDecorators(o, PythonQtPrivate::AllDecorators);
870 870 }
871 871
872 872 void PythonQt::registerQObjectClassNames(const QStringList& names)
873 873 {
874 874 _p->registerQObjectClassNames(names);
875 875 }
876 876
877 877 void PythonQt::setImporter(PythonQtImportFileInterface* importInterface)
878 878 {
879 879 _p->_importInterface = importInterface;
880 880 PythonQtImport::init();
881 881 }
882 882
883 883 void PythonQt::setImporterIgnorePaths(const QStringList& paths)
884 884 {
885 885 _p->_importIgnorePaths = paths;
886 886 }
887 887
888 888 const QStringList& PythonQt::getImporterIgnorePaths()
889 889 {
890 890 return _p->_importIgnorePaths;
891 891 }
892 892
893 893 void PythonQt::addWrapperFactory(PythonQtCppWrapperFactory* factory)
894 894 {
895 895 _p->_cppWrapperFactories.append(factory);
896 896 }
897 897
898 898 //---------------------------------------------------------------------------------------------------
899 899 PythonQtPrivate::PythonQtPrivate()
900 900 {
901 901 _importInterface = NULL;
902 902 _defaultImporter = new PythonQtQFileImporter;
903 903 _noLongerWrappedCB = NULL;
904 904 _wrappedCB = NULL;
905 905 _currentClassInfoForClassWrapperCreation = NULL;
906 906 }
907 907
908 908 void PythonQtPrivate::setupSharedLibrarySuffixes()
909 909 {
910 910 _sharedLibrarySuffixes.clear();
911 911 PythonQtObjectPtr imp;
912 912 imp.setNewRef(PyImport_ImportModule("imp"));
913 913 int cExtensionCode = imp.getVariable("C_EXTENSION").toInt();
914 914 QVariant result = imp.call("get_suffixes");
915 915 foreach (QVariant entry, result.toList()) {
916 916 QVariantList suffixEntry = entry.toList();
917 917 if (suffixEntry.count()==3) {
918 918 int code = suffixEntry.at(2).toInt();
919 919 if (code == cExtensionCode) {
920 920 _sharedLibrarySuffixes << suffixEntry.at(0).toString();
921 921 }
922 922 }
923 923 }
924 924 }
925 925
926 926 PythonQtClassInfo* PythonQtPrivate::currentClassInfoForClassWrapperCreation()
927 927 {
928 928 PythonQtClassInfo* info = _currentClassInfoForClassWrapperCreation;
929 929 _currentClassInfoForClassWrapperCreation = NULL;
930 930 return info;
931 931 }
932 932
933 933 void PythonQtPrivate::addDecorators(QObject* o, int decoTypes)
934 934 {
935 935 o->setParent(this);
936 936 int numMethods = o->metaObject()->methodCount();
937 937 for (int i = 0; i < numMethods; i++) {
938 938 QMetaMethod m = o->metaObject()->method(i);
939 939 if ((m.methodType() == QMetaMethod::Method ||
940 940 m.methodType() == QMetaMethod::Slot) && m.access() == QMetaMethod::Public) {
941 941 if (qstrncmp(m.signature(), "new_", 4)==0) {
942 942 if ((decoTypes & ConstructorDecorator) == 0) continue;
943 943 const PythonQtMethodInfo* info = PythonQtMethodInfo::getCachedMethodInfo(m, NULL);
944 944 if (info->parameters().at(0).isPointer) {
945 945 QByteArray signature = m.signature();
946 946 QByteArray nameOfClass = signature.mid(4, signature.indexOf('(')-4);
947 947 PythonQtClassInfo* classInfo = lookupClassInfoAndCreateIfNotPresent(nameOfClass);
948 948 PythonQtSlotInfo* newSlot = new PythonQtSlotInfo(NULL, m, i, o, PythonQtSlotInfo::ClassDecorator);
949 949 classInfo->addConstructor(newSlot);
950 950 }
951 951 } else if (qstrncmp(m.signature(), "delete_", 7)==0) {
952 952 if ((decoTypes & DestructorDecorator) == 0) continue;
953 953 QByteArray signature = m.signature();
954 954 QByteArray nameOfClass = signature.mid(7, signature.indexOf('(')-7);
955 955 PythonQtClassInfo* classInfo = lookupClassInfoAndCreateIfNotPresent(nameOfClass);
956 956 PythonQtSlotInfo* newSlot = new PythonQtSlotInfo(NULL, m, i, o, PythonQtSlotInfo::ClassDecorator);
957 957 classInfo->setDestructor(newSlot);
958 958 } else if (qstrncmp(m.signature(), "static_", 7)==0) {
959 959 if ((decoTypes & StaticDecorator) == 0) continue;
960 960 QByteArray signature = m.signature();
961 961 QByteArray nameOfClass = signature.mid(signature.indexOf('_')+1);
962 962 nameOfClass = nameOfClass.mid(0, nameOfClass.indexOf('_'));
963 963 PythonQtClassInfo* classInfo = lookupClassInfoAndCreateIfNotPresent(nameOfClass);
964 964 PythonQtSlotInfo* newSlot = new PythonQtSlotInfo(NULL, m, i, o, PythonQtSlotInfo::ClassDecorator);
965 965 classInfo->addDecoratorSlot(newSlot);
966 966 } else {
967 967 if ((decoTypes & InstanceDecorator) == 0) continue;
968 968 const PythonQtMethodInfo* info = PythonQtMethodInfo::getCachedMethodInfo(m, NULL);
969 969 if (info->parameters().count()>1) {
970 970 PythonQtMethodInfo::ParameterInfo p = info->parameters().at(1);
971 971 if (p.isPointer) {
972 972 PythonQtClassInfo* classInfo = lookupClassInfoAndCreateIfNotPresent(p.name);
973 973 PythonQtSlotInfo* newSlot = new PythonQtSlotInfo(NULL, m, i, o, PythonQtSlotInfo::InstanceDecorator);
974 974 classInfo->addDecoratorSlot(newSlot);
975 975 }
976 976 }
977 977 }
978 978 }
979 979 }
980 980 }
981 981
982 982 void PythonQtPrivate::registerQObjectClassNames(const QStringList& names)
983 983 {
984 984 foreach(QString name, names) {
985 985 _knownQObjectClassNames.insert(name.toLatin1(), true);
986 986 }
987 987 }
988 988
989 989 void PythonQtPrivate::removeSignalEmitter(QObject* obj)
990 990 {
991 991 _signalReceivers.remove(obj);
992 992 }
993 993
994 994 bool PythonQt::handleError()
995 995 {
996 996 bool flag = false;
997 997 if (PyErr_Occurred()) {
998 998
999 999 // currently we just print the error and the stderr handler parses the errors
1000 1000 PyErr_Print();
1001 1001
1002 1002 /*
1003 1003 // EXTRA: the format of the ptype and ptraceback is not really documented, so I use PyErr_Print() above
1004 1004 PyObject *ptype;
1005 1005 PyObject *pvalue;
1006 1006 PyObject *ptraceback;
1007 1007 PyErr_Fetch( &ptype, &pvalue, &ptraceback);
1008 1008
1009 1009 Py_XDECREF(ptype);
1010 1010 Py_XDECREF(pvalue);
1011 1011 Py_XDECREF(ptraceback);
1012 1012 */
1013 1013 PyErr_Clear();
1014 1014 flag = true;
1015 1015 }
1016 1016 return flag;
1017 1017 }
1018 1018
1019 1019 void PythonQt::addSysPath(const QString& path)
1020 1020 {
1021 1021 PythonQtObjectPtr sys;
1022 1022 sys.setNewRef(PyImport_ImportModule("sys"));
1023 1023 PythonQtObjectPtr obj = lookupObject(sys, "path");
1024 1024 PyList_Insert(obj, 0, PythonQtConv::QStringToPyObject(path));
1025 1025 }
1026 1026
1027 1027 void PythonQt::overwriteSysPath(const QStringList& paths)
1028 1028 {
1029 1029 PythonQtObjectPtr sys;
1030 1030 sys.setNewRef(PyImport_ImportModule("sys"));
1031 1031 PyModule_AddObject(sys, "path", PythonQtConv::QStringListToPyList(paths));
1032 1032 }
1033 1033
1034 1034 void PythonQt::setModuleImportPath(PyObject* module, const QStringList& paths)
1035 1035 {
1036 1036 PyModule_AddObject(module, "__path__", PythonQtConv::QStringListToPyList(paths));
1037 1037 }
1038 1038
1039 1039 void PythonQt::stdOutRedirectCB(const QString& str)
1040 1040 {
1041 1041 emit PythonQt::self()->pythonStdOut(str);
1042 1042 }
1043 1043
1044 1044 void PythonQt::stdErrRedirectCB(const QString& str)
1045 1045 {
1046 1046 emit PythonQt::self()->pythonStdErr(str);
1047 1047 }
1048 1048
1049 1049 void PythonQt::setQObjectWrappedCallback(PythonQtQObjectWrappedCB* cb)
1050 1050 {
1051 1051 _p->_wrappedCB = cb;
1052 1052 }
1053 1053
1054 1054 void PythonQt::setQObjectNoLongerWrappedCallback(PythonQtQObjectNoLongerWrappedCB* cb)
1055 1055 {
1056 1056 _p->_noLongerWrappedCB = cb;
1057 1057 }
1058 1058
1059 1059
1060 1060
1061 1061 static PyMethodDef PythonQtMethods[] = {
1062 1062 {NULL, NULL, 0, NULL}
1063 1063 };
1064 1064
1065 1065 void PythonQt::initPythonQtModule(bool redirectStdOut, const QByteArray& pythonQtModuleName)
1066 1066 {
1067 1067 QByteArray name = "PythonQt";
1068 1068 if (!pythonQtModuleName.isEmpty()) {
1069 1069 name = pythonQtModuleName;
1070 1070 }
1071 1071 _p->_pythonQtModule = Py_InitModule(name.constData(), PythonQtMethods);
1072 1072 _p->_pythonQtModuleName = name;
1073 1073
1074 1074 if (redirectStdOut) {
1075 1075 PythonQtObjectPtr sys;
1076 1076 PythonQtObjectPtr out;
1077 1077 PythonQtObjectPtr err;
1078 1078 sys.setNewRef(PyImport_ImportModule("sys"));
1079 1079 // create a redirection object for stdout and stderr
1080 1080 out = PythonQtStdOutRedirectType.tp_new(&PythonQtStdOutRedirectType,NULL, NULL);
1081 1081 ((PythonQtStdOutRedirect*)out.object())->_cb = stdOutRedirectCB;
1082 1082 err = PythonQtStdOutRedirectType.tp_new(&PythonQtStdOutRedirectType,NULL, NULL);
1083 1083 ((PythonQtStdOutRedirect*)err.object())->_cb = stdErrRedirectCB;
1084 1084 // replace the built in file objects with our own objects
1085 1085 PyModule_AddObject(sys, "stdout", out);
1086 1086 PyModule_AddObject(sys, "stderr", err);
1087 1087 }
1088 1088 }
1089 1089
1090 1090 void PythonQt::registerCPPClass(const char* typeName, const char* parentTypeName, const char* package, PythonQtQObjectCreatorFunctionCB* wrapperCreator, PythonQtShellSetInstanceWrapperCB* shell)
1091 1091 {
1092 1092 _p->registerCPPClass(typeName, parentTypeName, package, wrapperCreator, shell);
1093 1093 }
1094 1094
1095 1095
1096 1096 PythonQtClassInfo* PythonQtPrivate::lookupClassInfoAndCreateIfNotPresent(const char* typeName)
1097 1097 {
1098 1098 PythonQtClassInfo* info = _knownClassInfos.value(typeName);
1099 1099 if (!info) {
1100 1100 info = new PythonQtClassInfo();
1101 1101 info->setupCPPObject(typeName);
1102 1102 _knownClassInfos.insert(typeName, info);
1103 1103 }
1104 1104 return info;
1105 1105 }
1106 1106
1107 1107 void PythonQt::addPolymorphicHandler(const char* typeName, PythonQtPolymorphicHandlerCB* cb)
1108 1108 {
1109 1109 _p->addPolymorphicHandler(typeName, cb);
1110 1110 }
1111 1111
1112 1112 void PythonQtPrivate::addPolymorphicHandler(const char* typeName, PythonQtPolymorphicHandlerCB* cb)
1113 1113 {
1114 1114 PythonQtClassInfo* info = lookupClassInfoAndCreateIfNotPresent(typeName);
1115 1115 info->addPolymorphicHandler(cb);
1116 1116 }
1117 1117
1118 1118 bool PythonQt::addParentClass(const char* typeName, const char* parentTypeName, int upcastingOffset)
1119 1119 {
1120 1120 return _p->addParentClass(typeName, parentTypeName, upcastingOffset);
1121 1121 }
1122 1122
1123 1123 bool PythonQtPrivate::addParentClass(const char* typeName, const char* parentTypeName, int upcastingOffset)
1124 1124 {
1125 1125 PythonQtClassInfo* info = _knownClassInfos.value(typeName);
1126 1126 if (info) {
1127 1127 PythonQtClassInfo* parentInfo = lookupClassInfoAndCreateIfNotPresent(parentTypeName);
1128 1128 info->addParentClass(PythonQtClassInfo::ParentClassInfo(parentInfo, upcastingOffset));
1129 1129 return true;
1130 1130 } else {
1131 1131 return false;
1132 1132 }
1133 1133 }
1134 1134
1135 1135 void PythonQtPrivate::registerCPPClass(const char* typeName, const char* parentTypeName, const char* package, PythonQtQObjectCreatorFunctionCB* wrapperCreator, PythonQtShellSetInstanceWrapperCB* shell, PyObject* module, int typeSlots)
1136 1136 {
1137 1137 PythonQtClassInfo* info = lookupClassInfoAndCreateIfNotPresent(typeName);
1138 1138 if (!info->pythonQtClassWrapper()) {
1139 1139 info->setTypeSlots(typeSlots);
1140 1140 info->setupCPPObject(typeName);
1141 1141 createPythonQtClassWrapper(info, package, module);
1142 1142 }
1143 1143 if (parentTypeName && strcmp(parentTypeName,"")!=0) {
1144 1144 addParentClass(typeName, parentTypeName, 0);
1145 1145 }
1146 1146 if (wrapperCreator) {
1147 1147 info->setDecoratorProvider(wrapperCreator);
1148 1148 }
1149 1149 if (shell) {
1150 1150 info->setShellSetInstanceWrapperCB(shell);
1151 1151 }
1152 1152 }
1153 1153
1154 1154 PyObject* PythonQtPrivate::packageByName(const char* name)
1155 1155 {
1156 1156 if (name==NULL || name[0]==0) {
1157 1157 name = "private";
1158 1158 }
1159 1159 PyObject* v = _packages.value(name);
1160 1160 if (!v) {
1161 1161 v = PyImport_AddModule((_pythonQtModuleName + "." + name).constData());
1162 1162 _packages.insert(name, v);
1163 1163 // AddObject steals the reference, so increment it!
1164 1164 Py_INCREF(v);
1165 1165 PyModule_AddObject(_pythonQtModule, name, v);
1166 1166 }
1167 1167 return v;
1168 1168 }
1169 1169
1170 1170 void PythonQtPrivate::handleVirtualOverloadReturnError(const char* signature, const PythonQtMethodInfo* methodInfo, PyObject* result)
1171 1171 {
1172 1172 QString error = "Return value '" + PythonQtConv::PyObjGetString(result) + "' can not be converted to expected C++ type '" + methodInfo->parameters().at(0).name + "' as return value of virtual method " + signature;
1173 1173 PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
1174 1174 PythonQt::self()->handleError();
1175 1175 }
1176 1176
1177 1177 PyObject* PythonQt::helpCalled(PythonQtClassInfo* info)
1178 1178 {
1179 1179 if (_p->_initFlags & ExternalHelp) {
1180 1180 emit pythonHelpRequest(QByteArray(info->className()));
1181 1181 return Py_BuildValue("");
1182 1182 } else {
1183 1183 return PyString_FromString(info->help().toLatin1().data());
1184 1184 }
1185 1185 }
1186 1186
1187 1187 void PythonQtPrivate::removeWrapperPointer(void* obj)
1188 1188 {
1189 1189 _wrappedObjects.remove(obj);
1190 1190 }
1191 1191
1192 1192 void PythonQtPrivate::addWrapperPointer(void* obj, PythonQtInstanceWrapper* wrapper)
1193 1193 {
1194 1194 _wrappedObjects.insert(obj, wrapper);
1195 1195 }
1196 1196
1197 1197 PythonQtInstanceWrapper* PythonQtPrivate::findWrapperAndRemoveUnused(void* obj)
1198 1198 {
1199 1199 PythonQtInstanceWrapper* wrap = _wrappedObjects.value(obj);
1200 1200 if (wrap && !wrap->_wrappedPtr && wrap->_obj == NULL) {
1201 1201 // this is a wrapper whose QObject was already removed due to destruction
1202 1202 // so the obj pointer has to be a new QObject with the same address...
1203 1203 // we remove the old one and set the copy to NULL
1204 1204 wrap->_objPointerCopy = NULL;
1205 1205 removeWrapperPointer(obj);
1206 1206 wrap = NULL;
1207 1207 }
1208 1208 return wrap;
1209 1209 }
1210 1210
1211 1211 PythonQtObjectPtr PythonQtPrivate::createModule(const QString& name, PyObject* pycode)
1212 1212 {
1213 1213 PythonQtObjectPtr result;
1214 1214 if (pycode) {
1215 1215 result.setNewRef(PyImport_ExecCodeModule((char*)name.toLatin1().data(), pycode));
1216 1216 } else {
1217 1217 PythonQt::self()->handleError();
1218 1218 }
1219 1219 return result;
1220 1220 }
Show file before | Show file after | Hide comments
@@ -1,579 +1,579
1 1 #ifndef _PYTHONQT_H
2 2 #define _PYTHONQT_H
3 3
4 4 /*
5 5 *
6 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
6 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
7 7 *
8 8 * This library is free software; you can redistribute it and/or
9 9 * modify it under the terms of the GNU Lesser General Public
10 10 * License as published by the Free Software Foundation; either
11 11 * version 2.1 of the License, or (at your option) any later version.
12 12 *
13 13 * This library is distributed in the hope that it will be useful,
14 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 16 * Lesser General Public License for more details.
17 17 *
18 18 * Further, this software is distributed without any warranty that it is
19 19 * free of the rightful claim of any third person regarding infringement
20 20 * or the like. Any license provided herein, whether implied or
21 21 * otherwise, applies only to this software file. Patent licenses, if
22 22 * any, provided herein do not apply to combinations of this program with
23 23 * other software, or any other product whatsoever.
24 24 *
25 25 * You should have received a copy of the GNU Lesser General Public
26 26 * License along with this library; if not, write to the Free Software
27 27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 28 *
29 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
29 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
30 30 * 28359 Bremen, Germany or:
31 31 *
32 32 * http://www.mevis.de
33 33 *
34 34 */
35 35
36 36 //----------------------------------------------------------------------------------
37 37 /*!
38 38 // \file PythonQt.h
39 39 // \author Florian Link
40 40 // \author Last changed by $Author: florian $
41 41 // \date 2006-05
42 42 */
43 43 //----------------------------------------------------------------------------------
44 44
45 45 #include "PythonQtSystem.h"
46 46 #include "PythonQtInstanceWrapper.h"
47 47 #include "PythonQtClassWrapper.h"
48 48 #include "PythonQtSlot.h"
49 49 #include "PythonQtObjectPtr.h"
50 50 #include <QObject>
51 51 #include <QVariant>
52 52 #include <QList>
53 53 #include <QHash>
54 54 #include <QByteArray>
55 55 #include <QStringList>
56 56 #include <QtDebug>
57 57 #include <iostream>
58 58
59 59
60 60 class PythonQtClassInfo;
61 61 class PythonQtPrivate;
62 62 class PythonQtMethodInfo;
63 63 class PythonQtSignalReceiver;
64 64 class PythonQtImportFileInterface;
65 65 class PythonQtCppWrapperFactory;
66 66 class PythonQtQFileImporter;
67 67
68 68 typedef void PythonQtQObjectWrappedCB(QObject* object);
69 69 typedef void PythonQtQObjectNoLongerWrappedCB(QObject* object);
70 70 typedef void* PythonQtPolymorphicHandlerCB(const void *ptr, char **class_name);
71 71
72 72 typedef void PythonQtShellSetInstanceWrapperCB(void* object, PythonQtInstanceWrapper* wrapper);
73 73
74 74 template<class T> void PythonQtSetInstanceWrapperOnShell(void* object, PythonQtInstanceWrapper* wrapper) { ((T*)object)->_wrapper = wrapper; };
75 75
76 76 //! returns the offset that needs to be added to upcast an object of type T1 to T2
77 77 template<class T1, class T2> int PythonQtUpcastingOffset() {
78 78 return (((char*)(static_cast<T2*>(reinterpret_cast<T1*>(0x100)))) - ((char*)reinterpret_cast<T1*>(0x100)));
79 79 }
80 80
81 81 //! callback to create a QObject lazily
82 82 typedef QObject* PythonQtQObjectCreatorFunctionCB();
83 83
84 84 //! helper template to create a derived QObject class
85 85 template<class T> QObject* PythonQtCreateObject() { return new T(); };
86 86
87 87 //! the main interface to the Python Qt binding, realized as a singleton
88 88 class PYTHONQT_EXPORT PythonQt : public QObject {
89 89
90 90 Q_OBJECT
91 91
92 92 public:
93 93 enum InitFlags {
94 94 RedirectStdOut = 1, //!<< sets if the std out/err is redirected to pythonStdOut() and pythonStdErr() signals
95 95 IgnoreSiteModule = 2, //!<< sets if Python should ignore the site module
96 96 ExternalHelp = 4 //!<< sets if help() calls on PythonQt modules are forwarded to the pythonHelpRequest() signal
97 97 };
98 98
99 99 //! flags that tell PythonQt which operators to expect on the registered type
100 100 enum TypeSlots {
101 101 Type_Add = 1,
102 102 Type_Subtract = 1 << 1,
103 103 Type_Multiply = 1 << 2,
104 104 Type_Divide = 1 << 3,
105 105 Type_Mod = 1 << 4,
106 106 Type_And = 1 << 5,
107 107 Type_Or = 1 << 6,
108 108 Type_Xor = 1 << 7,
109 109 Type_LShift = 1 << 8,
110 110 Type_RShift = 1 << 9,
111 111
112 112 Type_InplaceAdd = 1 << 10,
113 113 Type_InplaceSubtract = 1 << 11,
114 114 Type_InplaceMultiply = 1 << 12,
115 115 Type_InplaceDivide = 1 << 13,
116 116 Type_InplaceMod = 1 << 14,
117 117 Type_InplaceAnd = 1 << 15,
118 118 Type_InplaceOr = 1 << 16,
119 119 Type_InplaceXor = 1 << 17,
120 120 Type_InplaceLShift = 1 << 18,
121 121 Type_InplaceRShift = 1 << 19,
122 122
123 123 // Not yet needed/nicely mappable/generated...
124 124 //Type_Positive = 1 << 29,
125 125 //Type_Negative = 1 << 29,
126 126 //Type_Abs = 1 << 29,
127 127 //Type_Hash = 1 << 29,
128 128
129 129 Type_Invert = 1 << 29,
130 130 Type_RichCompare = 1 << 30,
131 131 Type_NonZero = 1 << 31,
132 132
133 133 };
134 134
135 135 //! initialize the python qt binding (flags are a or combination of InitFlags), if \c pythonQtModuleName is given
136 136 //! it defines the name of the python module that PythonQt will add, otherwise "PythonQt" is used.
137 137 //! This can be used to e.g. pass in PySide or PyQt4 to make it more compatible.
138 138 static void init(int flags = IgnoreSiteModule | RedirectStdOut, const QByteArray& pythonQtModuleName = QByteArray());
139 139
140 140 //! cleanup
141 141 static void cleanup();
142 142
143 143 //! get the singleton instance
144 144 static PythonQt* self() { return _self; }
145 145
146 146 //-----------------------------------------------------------------------------
147 147 // Public API:
148 148
149 149 //! defines the object types for introspection
150 150 enum ObjectType {
151 151 Class,
152 152 Function,
153 153 Variable,
154 154 Module,
155 155 Anything,
156 156 CallOverloads
157 157 };
158 158
159 159 //! overwrite the python sys path (call this directly after PythonQt::init() if you want to change the std python sys path)
160 160 void overwriteSysPath(const QStringList& paths);
161 161
162 162 //! prepend a path to sys.path to allow importing from it
163 163 void addSysPath(const QString& path);
164 164
165 165 //! sets the __path__ list of a module to the given list (important for local imports)
166 166 void setModuleImportPath(PyObject* module, const QStringList& paths);
167 167
168 168 //! get the __main__ module of python
169 169 PythonQtObjectPtr getMainModule();
170 170
171 171 //! registers a QObject derived class to PythonQt (this is implicitly called by addObject as well)
172 172 /* Since Qt4 does not offer a way to detect if a given classname is derived from QObject and thus has a QMetaObject,
173 173 you MUST register all your QObject derived classes here when you want them to be detected in signal and slot calls */
174 174 void registerClass(const QMetaObject* metaobject, const char* package = NULL, PythonQtQObjectCreatorFunctionCB* wrapperCreator = NULL, PythonQtShellSetInstanceWrapperCB* shell = NULL);
175 175
176 176 //! add a wrapper object for the given QMetaType typeName, also does an addClassDecorators() to add constructors for variants
177 177 //! (ownership of wrapper is passed to PythonQt)
178 178 /*! Make sure that you have done a qRegisterMetaType first, if typeName is a user type!
179 179
180 180 This will add a wrapper object that is used to make calls to the given classname \c typeName.
181 181 All slots that take a pointer to typeName as the first argument will be callable from Python on
182 182 a variant object that contains such a type.
183 183 */
184 184 void registerCPPClass(const char* typeName, const char* parentTypeName = NULL, const char* package = NULL, PythonQtQObjectCreatorFunctionCB* wrapperCreator = NULL, PythonQtShellSetInstanceWrapperCB* shell = NULL);
185 185
186 186 //! as an alternative to registerClass, you can tell PythonQt the names of QObject derived classes
187 187 //! and it will register the classes when it first sees a pointer to such a derived class
188 188 void registerQObjectClassNames(const QStringList& names);
189 189
190 190 //! add a parent class relation to the \c given typeName, the upcastingOffset is needed for multiple inheritance
191 191 //! and can be calculated using PythonQtUpcastingOffset<type,parentType>(), which also verifies that
192 192 //! type is really derived from parentType.
193 193 //! Returns false if the typeName was not yet registered.
194 194 bool addParentClass(const char* typeName, const char* parentTypeName, int upcastingOffset=0);
195 195
196 196 //! add a handler for polymorphic downcasting
197 197 void addPolymorphicHandler(const char* typeName, PythonQtPolymorphicHandlerCB* cb);
198 198
199 199 //! parses the given file and returns the python code object, this can then be used to call evalCode()
200 200 PythonQtObjectPtr parseFile(const QString& filename);
201 201
202 202 //! evaluates the given code and returns the result value (use Py_Compile etc. to create pycode from string)
203 203 //! If pycode is NULL, a python error is printed.
204 204 QVariant evalCode(PyObject* object, PyObject* pycode);
205 205
206 206 //! evaluates the given script code and returns the result value
207 207 QVariant evalScript(PyObject* object, const QString& script, int start = Py_file_input);
208 208
209 209 //! evaluates the given script code from file
210 210 void evalFile(PyObject* object, const QString& filename);
211 211
212 212 //! creates the new module \c name and evaluates the given file in the context of that module
213 213 //! If the \c script is empty, the module contains no initial code. You can use evalScript/evalCode to add code
214 214 //! to a module later on.
215 215 //! The user needs to make sure that the \c name is unique in the python module dictionary.
216 216 PythonQtObjectPtr createModuleFromFile(const QString& name, const QString& filename);
217 217
218 218 //! creates the new module \c name and evaluates the given script in the context of that module.
219 219 //! If the \c script is empty, the module contains no initial code. You can use evalScript/evalCode to add code
220 220 //! to a module later on.
221 221 //! The user needs to make sure that the \c name is unique in the python module dictionary.
222 222 PythonQtObjectPtr createModuleFromScript(const QString& name, const QString& script = QString());
223 223
224 224 //! create a uniquely named module, you can use evalFile or evalScript to populate the module with
225 225 //! script code
226 226 PythonQtObjectPtr createUniqueModule();
227 227
228 228 //@{ Signal handlers
229 229
230 230 //! add a signal handler to the given \c signal of \c obj and connect it to a callable \c objectname in module
231 231 bool addSignalHandler(QObject* obj, const char* signal, PyObject* module, const QString& objectname);
232 232
233 233 //! remove a signal handler from the given \c signal of \c obj
234 234 bool removeSignalHandler(QObject* obj, const char* signal, PyObject* module, const QString& objectname);
235 235
236 236 //! add a signal handler to the given \c signal of \c obj and connect it to a callable \c receiver
237 237 bool addSignalHandler(QObject* obj, const char* signal, PyObject* receiver);
238 238
239 239 //! remove a signal handler from the given \c signal of \c obj
240 240 bool removeSignalHandler(QObject* obj, const char* signal, PyObject* receiver);
241 241
242 242 //@}
243 243
244 244 //@{ Variable access
245 245
246 246 //! add the given \c qObject to the python \c object as a variable with \c name (it can be removed via clearVariable)
247 247 void addObject(PyObject* object, const QString& name, QObject* qObject);
248 248
249 249 //! add the given variable to the object
250 250 void addVariable(PyObject* object, const QString& name, const QVariant& v);
251 251
252 252 //! remove the given variable
253 253 void removeVariable(PyObject* module, const QString& name);
254 254
255 255 //! get the variable with the \c name of the \c object, returns an invalid QVariant on error
256 256 QVariant getVariable(PyObject* object, const QString& name);
257 257
258 258 //! read vars etc. in scope of an \c object, optional looking inside of an object \c objectname
259 259 QStringList introspection(PyObject* object, const QString& objectname, ObjectType type);
260 260
261 261 //! returns the found callable object or NULL
262 262 //! @return new reference
263 263 PythonQtObjectPtr lookupCallable(PyObject* object, const QString& name);
264 264
265 265 //@}
266 266
267 267 //@{ Calling of python callables
268 268
269 269 //! call the given python \c callable in the scope of object, returns the result converted to a QVariant
270 270 QVariant call(PyObject* object, const QString& callable, const QVariantList& args = QVariantList());
271 271
272 272 //! call the given python object, returns the result converted to a QVariant
273 273 QVariant call(PyObject* callable, const QVariantList& args = QVariantList());
274 274
275 275 //! call the given python object, returns the result as new PyObject
276 276 PyObject* callAndReturnPyObject(PyObject* callable, const QVariantList& args = QVariantList());
277 277
278 278 //@}
279 279
280 280 //@{ Decorations, constructors, wrappers...
281 281
282 282
283 283 //! add an object whose slots will be used as decorator slots for
284 284 //! other QObjects or CPP classes. The slots need to follow the
285 285 //! convention that the first argument is a pointer to the wrapped object.
286 286 //! (ownership is passed to PythonQt)
287 287 /*!
288 288 Example:
289 289
290 290 A slot with the signature
291 291
292 292 \code
293 293 bool doSomething(QWidget* w, int a)
294 294 \endcode
295 295
296 296 will extend QWidget instances (and derived classes) with a "bool doSomething(int a)" slot
297 297 that will be called with the concrete instance as first argument.
298 298 So in Python you can now e.g. call
299 299
300 300 \code
301 301 someWidget.doSomething(12)
302 302 \endcode
303 303
304 304 without QWidget really having this method. This allows to easily make normal methods
305 305 of Qt classes callable by forwarding them with such decorator slots
306 306 or to make CPP classes (which are not derived from QObject) callable from Python.
307 307 */
308 308 void addInstanceDecorators(QObject* o);
309 309
310 310 //! add an object whose slots will be used as decorator slots for
311 311 //! class objects (ownership is passed to PythonQt)
312 312 /*!
313 313 The slots need to follow the following convention:
314 314 - SomeClass* new_SomeClass(...)
315 315 - QVariant new_SomeClass(...)
316 316 - void delete_SomeClass(SomeClass*)
317 317 - ... static_SomeClass_someName(...)
318 318
319 319 This will add:
320 320 - a constructor
321 321 - a constructor which generates a QVariant
322 322 - a destructor (only useful for CPP objects)
323 323 - a static decorator slot which will be available on the MetaObject (visible in PythonQt module)
324 324
325 325 */
326 326 void addClassDecorators(QObject* o);
327 327
328 328 //! this will add the object both as class and instance decorator (ownership is passed to PythonQt)
329 329 void addDecorators(QObject* o);
330 330
331 331 //! add the given factory to PythonQt (ownership stays with caller)
332 332 void addWrapperFactory(PythonQtCppWrapperFactory* factory);
333 333
334 334 //@}
335 335
336 336 //@{ Custom importer (to replace internal import implementation of python)
337 337
338 338 //! replace the internal import implementation and use the supplied interface to load files (both py and pyc files)
339 339 //! (this method should be called directly after initialization of init() and before calling overwriteSysPath().
340 340 //! On the first call to this method, it will install a generic PythonQt importer in Pythons "path_hooks".
341 341 //! This is not reversible, so even setting setImporter(NULL) afterwards will
342 342 //! keep the custom PythonQt importer with a QFile default import interface.
343 343 //! Subsequent python import calls will make use of the passed importInterface
344 344 //! which forwards all import calls to the given \c importInterface.
345 345 //! Passing NULL will install a default QFile importer.
346 346 //! (\c importInterface ownership stays with caller)
347 347 void setImporter(PythonQtImportFileInterface* importInterface);
348 348
349 349 //! this installs the default QFile importer (which effectively does a setImporter(NULL))
350 350 //! (without calling setImporter or installDefaultImporter at least once, the default python import
351 351 //! mechanism is in place)
352 352 //! the default importer allows to import files from anywhere QFile can read from,
353 353 //! including the Qt resource system using ":". Keep in mind that you need to extend
354 354 //! "sys.path" with ":" to be able to import from the Qt resources.
355 355 void installDefaultImporter() { setImporter(NULL); }
356 356
357 357 //! set paths that the importer should ignore
358 358 void setImporterIgnorePaths(const QStringList& paths);
359 359
360 360 //! get paths that the importer should ignore
361 361 const QStringList& getImporterIgnorePaths();
362 362
363 363 //@}
364 364
365 365 //! get access to internal data (should not be used on the public API, but is used by some C functions)
366 366 static PythonQtPrivate* priv() { return _self->_p; }
367 367
368 368 //! get access to the file importer (if set)
369 369 static PythonQtImportFileInterface* importInterface();
370 370
371 371 //! handle a python error, call this when a python function fails. If no error occurred, it returns false.
372 372 //! The error is currently just output to the python stderr, future version might implement better trace printing
373 373 bool handleError();
374 374
375 375 //! set a callback that is called when a QObject with parent == NULL is wrapped by pythonqt
376 376 void setQObjectWrappedCallback(PythonQtQObjectWrappedCB* cb);
377 377 //! set a callback that is called when a QObject with parent == NULL is no longer wrapped by pythonqt
378 378 void setQObjectNoLongerWrappedCallback(PythonQtQObjectNoLongerWrappedCB* cb);
379 379
380 380 //! call the callback if it is set
381 381 static void qObjectNoLongerWrappedCB(QObject* o);
382 382
383 383 signals:
384 384 //! emitted when python outputs something to stdout (and redirection is turned on)
385 385 void pythonStdOut(const QString& str);
386 386 //! emitted when python outputs something to stderr (and redirection is turned on)
387 387 void pythonStdErr(const QString& str);
388 388
389 389 //! emitted when help() is called on a PythonQt object and \c ExternalHelp is enabled
390 390 void pythonHelpRequest(const QByteArray& cppClassName);
391 391
392 392
393 393 public:
394 394 //! called by internal help methods
395 395 PyObject* helpCalled(PythonQtClassInfo* info);
396 396
397 397 //! returns the found object or NULL
398 398 //! @return new reference
399 399 PythonQtObjectPtr lookupObject(PyObject* module, const QString& name);
400 400
401 401 private:
402 402 void initPythonQtModule(bool redirectStdOut, const QByteArray& pythonQtModuleName);
403 403
404 404 //! callback for stdout redirection, emits pythonStdOut signal
405 405 static void stdOutRedirectCB(const QString& str);
406 406 //! callback for stderr redirection, emits pythonStdErr signal
407 407 static void stdErrRedirectCB(const QString& str);
408 408
409 409 //! get (and create if not available) the signal receiver of that QObject, signal receiver is made child of the passed \c obj
410 410 PythonQtSignalReceiver* getSignalReceiver(QObject* obj);
411 411
412 412 PythonQt(int flags, const QByteArray& pythonQtModuleName);
413 413 ~PythonQt();
414 414
415 415 static PythonQt* _self;
416 416 static int _uniqueModuleCount;
417 417
418 418 PythonQtPrivate* _p;
419 419
420 420 };
421 421
422 422 //! internal PythonQt details
423 423 class PYTHONQT_EXPORT PythonQtPrivate : public QObject {
424 424
425 425 Q_OBJECT
426 426
427 427 public:
428 428 PythonQtPrivate();
429 429 ~PythonQtPrivate();
430 430
431 431 enum DecoratorTypes {
432 432 StaticDecorator = 1,
433 433 ConstructorDecorator = 2,
434 434 DestructorDecorator = 4,
435 435 InstanceDecorator = 8,
436 436 AllDecorators = 0xffff
437 437 };
438 438
439 439 //! get the suffixes that are used for shared libraries
440 440 const QStringList& sharedLibrarySuffixes() { return _sharedLibrarySuffixes; }
441 441
442 442 //! returns if the id is the id for PythonQtObjectPtr
443 443 bool isPythonQtObjectPtrMetaId(int id) { return _PythonQtObjectPtr_metaId == id; }
444 444
445 445 //! add the wrapper pointer (for reuse if the same obj appears while wrapper still exists)
446 446 void addWrapperPointer(void* obj, PythonQtInstanceWrapper* wrapper);
447 447 //! remove the wrapper ptr again
448 448 void removeWrapperPointer(void* obj);
449 449
450 450 //! add parent class relation
451 451 bool addParentClass(const char* typeName, const char* parentTypeName, int upcastingOffset);
452 452
453 453 //! add a handler for polymorphic downcasting
454 454 void addPolymorphicHandler(const char* typeName, PythonQtPolymorphicHandlerCB* cb);
455 455
456 456 //! lookup existing classinfo and return new if not yet present
457 457 PythonQtClassInfo* lookupClassInfoAndCreateIfNotPresent(const char* typeName);
458 458
459 459 //! called when a signal emitting QObject is destroyed to remove the signal handler from the hash map
460 460 void removeSignalEmitter(QObject* obj);
461 461
462 462 //! wrap the given QObject into a Python object (or return existing wrapper!)
463 463 PyObject* wrapQObject(QObject* obj);
464 464
465 465 //! wrap the given ptr into a Python object (or return existing wrapper!) if there is a known QObject of that name or a known wrapper in the factory
466 466 PyObject* wrapPtr(void* ptr, const QByteArray& name);
467 467
468 468 //! registers a QObject derived class to PythonQt (this is implicitly called by addObject as well)
469 469 /* Since Qt4 does not offer a way to detect if a given classname is derived from QObject and thus has a QMetaObject,
470 470 you MUST register all your QObject derived classes here when you want them to be detected in signal and slot calls */
471 471 void registerClass(const QMetaObject* metaobject, const char* package = NULL, PythonQtQObjectCreatorFunctionCB* wrapperCreator = NULL, PythonQtShellSetInstanceWrapperCB* shell = NULL, PyObject* module = NULL, int typeSlots = 0);
472 472
473 473 //! add a wrapper object for the given QMetaType typeName, also does an addClassDecorators() to add constructors for variants
474 474 //! (ownership of wrapper is passed to PythonQt)
475 475 /*! Make sure that you have done a qRegisterMetaType first, if typeName is a user type!
476 476
477 477 This will add a wrapper object that is used to make calls to the given classname \c typeName.
478 478 All slots that take a pointer to typeName as the first argument will be callable from Python on
479 479 a variant object that contains such a type.
480 480 */
481 481 void registerCPPClass(const char* typeName, const char* parentTypeName = NULL, const char* package = NULL, PythonQtQObjectCreatorFunctionCB* wrapperCreator = NULL, PythonQtShellSetInstanceWrapperCB* shell = NULL, PyObject* module = NULL, int typeSlots = 0);
482 482
483 483 //! as an alternative to registerClass, you can tell PythonQt the names of QObject derived classes
484 484 //! and it will register the classes when it first sees a pointer to such a derived class
485 485 void registerQObjectClassNames(const QStringList& names);
486 486
487 487 //! add a decorator object
488 488 void addDecorators(QObject* o, int decoTypes);
489 489
490 490 //! helper method that creates a PythonQtClassWrapper object (returns a new reference)
491 491 PythonQtClassWrapper* createNewPythonQtClassWrapper(PythonQtClassInfo* info, PyObject* module);
492 492
493 493 //! create a new instance of the given enum type with given value (returns a new reference)
494 494 static PyObject* createEnumValueInstance(PyObject* enumType, unsigned int enumValue);
495 495
496 496 //! helper that creates a new int derived class that represents the enum of the given name (returns a new reference)
497 497 static PyObject* createNewPythonQtEnumWrapper(const char* enumName, PyObject* parentObject);
498 498
499 499 //! helper method that creates a PythonQtInstanceWrapper object and registers it in the object map
500 500 PythonQtInstanceWrapper* createNewPythonQtInstanceWrapper(QObject* obj, PythonQtClassInfo* info, void* wrappedPtr = NULL);
501 501
502 502 //! get the class info for a meta object (if available)
503 503 PythonQtClassInfo* getClassInfo(const QMetaObject* meta) { return _knownClassInfos.value(meta->className()); }
504 504
505 505 //! get the class info for a meta object (if available)
506 506 PythonQtClassInfo* getClassInfo(const QByteArray& className) { return _knownClassInfos.value(className); }
507 507
508 508 //! creates the new module from the given pycode
509 509 PythonQtObjectPtr createModule(const QString& name, PyObject* pycode);
510 510
511 511 //! get the current class info (for the next PythonQtClassWrapper that is created) and reset it to NULL again
512 512 PythonQtClassInfo* currentClassInfoForClassWrapperCreation();
513 513
514 514 //! the dummy tuple (which is empty and may be used to detected that a wrapper is called from internal wrapper creation
515 515 static PyObject* dummyTuple();
516 516
517 517 //! called by virtual overloads when a python return value can not be converted to the required Qt type
518 518 void handleVirtualOverloadReturnError(const char* signature, const PythonQtMethodInfo* methodInfo, PyObject* result);
519 519
520 520 //! get access to the PythonQt module
521 521 PythonQtObjectPtr pythonQtModule() const { return _pythonQtModule; }
522 522
523 523 private:
524 524 //! Setup the shared library suffixes by getting them from the "imp" module.
525 525 void setupSharedLibrarySuffixes();
526 526
527 527 //! create a new pythonqt class wrapper and place it in the pythonqt module
528 528 void createPythonQtClassWrapper(PythonQtClassInfo* info, const char* package, PyObject* module = NULL);
529 529
530 530 //! get/create new package module (the returned object is a borrowed reference)
531 531 PyObject* packageByName(const char* name);
532 532
533 533 //! get the wrapper for a given pointer (and remove a wrapper of an already destroyed qobject)
534 534 PythonQtInstanceWrapper* findWrapperAndRemoveUnused(void* obj);
535 535
536 536 //! stores pointer to PyObject mapping of wrapped QObjects AND C++ objects
537 537 QHash<void* , PythonQtInstanceWrapper *> _wrappedObjects;
538 538
539 539 //! stores the meta info of known Qt classes
540 540 QHash<QByteArray, PythonQtClassInfo *> _knownClassInfos;
541 541
542 542 //! names of qobject derived classes that can be casted to qobject savely
543 543 QHash<QByteArray, bool> _knownQObjectClassNames;
544 544
545 545 //! stores signal receivers for QObjects
546 546 QHash<QObject* , PythonQtSignalReceiver *> _signalReceivers;
547 547
548 548 //! the PythonQt python module
549 549 PythonQtObjectPtr _pythonQtModule;
550 550
551 551 //! the name of the PythonQt python module
552 552 QByteArray _pythonQtModuleName;
553 553
554 554 //! the importer interface (if set)
555 555 PythonQtImportFileInterface* _importInterface;
556 556
557 557 //! the default importer
558 558 PythonQtQFileImporter* _defaultImporter;
559 559
560 560 PythonQtQObjectNoLongerWrappedCB* _noLongerWrappedCB;
561 561 PythonQtQObjectWrappedCB* _wrappedCB;
562 562
563 563 QStringList _importIgnorePaths;
564 564 QStringList _sharedLibrarySuffixes;
565 565
566 566 //! the cpp object wrapper factories
567 567 QList<PythonQtCppWrapperFactory*> _cppWrapperFactories;
568 568
569 569 QHash<QByteArray, PyObject*> _packages;
570 570
571 571 PythonQtClassInfo* _currentClassInfoForClassWrapperCreation;
572 572
573 573 int _initFlags;
574 574 int _PythonQtObjectPtr_metaId;
575 575
576 576 friend class PythonQt;
577 577 };
578 578
579 579 #endif
Show file before | Show file after | Hide comments
@@ -1,849 +1,849
1 1 /*
2 2 *
3 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
3 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
4 4 *
5 5 * This library is free software; you can redistribute it and/or
6 6 * modify it under the terms of the GNU Lesser General Public
7 7 * License as published by the Free Software Foundation; either
8 8 * version 2.1 of the License, or (at your option) any later version.
9 9 *
10 10 * This library is distributed in the hope that it will be useful,
11 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 13 * Lesser General Public License for more details.
14 14 *
15 15 * Further, this software is distributed without any warranty that it is
16 16 * free of the rightful claim of any third person regarding infringement
17 17 * or the like. Any license provided herein, whether implied or
18 18 * otherwise, applies only to this software file. Patent licenses, if
19 19 * any, provided herein do not apply to combinations of this program with
20 20 * other software, or any other product whatsoever.
21 21 *
22 22 * You should have received a copy of the GNU Lesser General Public
23 23 * License along with this library; if not, write to the Free Software
24 24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 25 *
26 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
26 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
27 27 * 28359 Bremen, Germany or:
28 28 *
29 29 * http://www.mevis.de
30 30 *
31 31 */
32 32
33 33 //----------------------------------------------------------------------------------
34 34 /*!
35 35 // \file PythonQt.cpp
36 36 // \author Florian Link
37 37 // \author Last changed by $Author: florian $
38 38 // \date 2006-05
39 39 */
40 40 //----------------------------------------------------------------------------------
41 41
42 42 #include "PythonQtClassInfo.h"
43 43 #include "PythonQtMethodInfo.h"
44 44 #include "PythonQt.h"
45 45 #include <QMetaMethod>
46 46 #include <QMetaObject>
47 47 #include <QMetaEnum>
48 48
49 49 QHash<QByteArray, int> PythonQtMethodInfo::_parameterTypeDict;
50 50
51 51 PythonQtClassInfo::PythonQtClassInfo() {
52 52 _meta = NULL;
53 53 _constructors = NULL;
54 54 _destructor = NULL;
55 55 _decoratorProvider = NULL;
56 56 _decoratorProviderCB = NULL;
57 57 _pythonQtClassWrapper = NULL;
58 58 _shellSetInstanceWrapperCB = NULL;
59 59 _metaTypeId = -1;
60 60 _typeSlots = 0;
61 61 _isQObject = false;
62 62 _enumsCreated = false;
63 63 }
64 64
65 65 PythonQtClassInfo::~PythonQtClassInfo()
66 66 {
67 67 clearCachedMembers();
68 68
69 69 if (_constructors) {
70 70 _constructors->deleteOverloadsAndThis();
71 71 }
72 72 if (_destructor) {
73 73 _destructor->deleteOverloadsAndThis();
74 74 }
75 75 foreach(PythonQtSlotInfo* info, _decoratorSlots) {
76 76 info->deleteOverloadsAndThis();
77 77 }
78 78 }
79 79
80 80 void PythonQtClassInfo::setupQObject(const QMetaObject* meta)
81 81 {
82 82 // _wrappedClassName is already set earlier in the class setup
83 83 _isQObject = true;
84 84 _meta = meta;
85 85 }
86 86
87 87 void PythonQtClassInfo::setupCPPObject(const QByteArray& classname)
88 88 {
89 89 _isQObject = false;
90 90 _wrappedClassName = classname;
91 91 _metaTypeId = QMetaType::type(classname);
92 92 }
93 93
94 94 void PythonQtClassInfo::clearCachedMembers()
95 95 {
96 96 QHashIterator<QByteArray, PythonQtMemberInfo> i(_cachedMembers);
97 97 while (i.hasNext()) {
98 98 PythonQtMemberInfo member = i.next().value();
99 99 if (member._type== PythonQtMemberInfo::Slot) {
100 100 PythonQtSlotInfo* info = member._slot;
101 101 while (info) {
102 102 PythonQtSlotInfo* next = info->nextInfo();
103 103 delete info;
104 104 info = next;
105 105 }
106 106 }
107 107 }
108 108 }
109 109
110 110 int PythonQtClassInfo::findCharOffset(const char* sigStart, char someChar)
111 111 {
112 112 const char* sigEnd = sigStart;
113 113 char c;
114 114 do {
115 115 c = *sigEnd++;
116 116 } while (c!=someChar && c!=0);
117 117 return sigEnd-sigStart-1;
118 118 }
119 119
120 120 bool PythonQtClassInfo::lookForPropertyAndCache(const char* memberName)
121 121 {
122 122 if (!_meta) return false;
123 123
124 124 bool found = false;
125 125 bool nameMapped = false;
126 126 const char* attributeName = memberName;
127 127 // look for properties
128 128 int i = _meta->indexOfProperty(attributeName);
129 129 if (i==-1) {
130 130 // try to map name to objectName
131 131 if (qstrcmp(attributeName, "name")==0) {
132 132 attributeName = "objectName";
133 133 nameMapped = true;
134 134 i = _meta->indexOfProperty(attributeName);
135 135 }
136 136 }
137 137 if (i!=-1) {
138 138 PythonQtMemberInfo newInfo(_meta->property(i));
139 139 _cachedMembers.insert(attributeName, newInfo);
140 140 if (nameMapped) {
141 141 _cachedMembers.insert(memberName, newInfo);
142 142 }
143 143 #ifdef PYTHONQT_DEBUG
144 144 std::cout << "caching property " << memberName << " on " << _meta->className() << std::endl;
145 145 #endif
146 146 found = true;
147 147 }
148 148 return found;
149 149 }
150 150
151 151 PythonQtSlotInfo* PythonQtClassInfo::recursiveFindDecoratorSlotsFromDecoratorProvider(const char* memberName, PythonQtSlotInfo* inputInfo, bool &found, QHash<QByteArray, PythonQtMemberInfo>& memberCache, int upcastingOffset)
152 152 {
153 153 inputInfo = findDecoratorSlotsFromDecoratorProvider(memberName, inputInfo, found, memberCache, upcastingOffset);
154 154 foreach(const ParentClassInfo& info, _parentClasses) {
155 155 inputInfo = info._parent->recursiveFindDecoratorSlotsFromDecoratorProvider(memberName, inputInfo, found, memberCache, upcastingOffset+info._upcastingOffset);
156 156 }
157 157 return inputInfo;
158 158 }
159 159
160 160 PythonQtSlotInfo* PythonQtClassInfo::findDecoratorSlotsFromDecoratorProvider(const char* memberName, PythonQtSlotInfo* tail, bool &found, QHash<QByteArray, PythonQtMemberInfo>& memberCache, int upcastingOffset) {
161 161 QObject* decoratorProvider = decorator();
162 162 int memberNameLen = strlen(memberName);
163 163 if (decoratorProvider) {
164 164 //qDebug()<< "looking " << decoratorProvider->metaObject()->className() << " " << memberName << " " << upcastingOffset;
165 165 const QMetaObject* meta = decoratorProvider->metaObject();
166 166 int numMethods = meta->methodCount();
167 167 int startFrom = QObject::staticMetaObject.methodCount();
168 168 for (int i = startFrom; i < numMethods; i++) {
169 169 QMetaMethod m = meta->method(i);
170 170 if ((m.methodType() == QMetaMethod::Method ||
171 171 m.methodType() == QMetaMethod::Slot) && m.access() == QMetaMethod::Public) {
172 172
173 173 const char* sigStart = m.signature();
174 174 bool isClassDeco = false;
175 175 if (qstrncmp(sigStart, "static_", 7)==0) {
176 176 // skip the static_classname_ part of the string
177 177 sigStart += 7 + 1 + strlen(className());
178 178 isClassDeco = true;
179 179 } else if (qstrncmp(sigStart, "new_", 4)==0) {
180 180 isClassDeco = true;
181 181 } else if (qstrncmp(sigStart, "delete_", 7)==0) {
182 182 isClassDeco = true;
183 183 }
184 184 // find the first '('
185 185 int offset = findCharOffset(sigStart, '(');
186 186
187 187 // XXX no checking is currently done if the slots have correct first argument or not...
188 188
189 189 // check if same length and same name
190 190 if (memberNameLen == offset && qstrncmp(memberName, sigStart, offset)==0) {
191 191 found = true;
192 192 PythonQtSlotInfo* info = new PythonQtSlotInfo(this, m, i, decoratorProvider, isClassDeco?PythonQtSlotInfo::ClassDecorator:PythonQtSlotInfo::InstanceDecorator);
193 193 info->setUpcastingOffset(upcastingOffset);
194 194 //qDebug()<< "adding " << decoratorProvider->metaObject()->className() << " " << memberName << " " << upcastingOffset;
195 195 if (tail) {
196 196 tail->setNextInfo(info);
197 197 } else {
198 198 PythonQtMemberInfo newInfo(info);
199 199 memberCache.insert(memberName, newInfo);
200 200 }
201 201 tail = info;
202 202 }
203 203 }
204 204 }
205 205 }
206 206
207 207 tail = findDecoratorSlots(memberName, memberNameLen, tail, found, memberCache, upcastingOffset);
208 208
209 209 return tail;
210 210 }
211 211
212 212 bool PythonQtClassInfo::lookForMethodAndCache(const char* memberName)
213 213 {
214 214 bool found = false;
215 215 int memberNameLen = strlen(memberName);
216 216 PythonQtSlotInfo* tail = NULL;
217 217 if (_meta) {
218 218 int numMethods = _meta->methodCount();
219 219 for (int i = 0; i < numMethods; i++) {
220 220 QMetaMethod m = _meta->method(i);
221 221 if (((m.methodType() == QMetaMethod::Method ||
222 222 m.methodType() == QMetaMethod::Slot) && m.access() == QMetaMethod::Public)
223 223 || m.methodType()==QMetaMethod::Signal) {
224 224
225 225 const char* sigStart = m.signature();
226 226 // find the first '('
227 227 int offset = findCharOffset(sigStart, '(');
228 228
229 229 // check if same length and same name
230 230 if (memberNameLen == offset && qstrncmp(memberName, sigStart, offset)==0) {
231 231 found = true;
232 232 PythonQtSlotInfo* info = new PythonQtSlotInfo(this, m, i);
233 233 if (tail) {
234 234 tail->setNextInfo(info);
235 235 } else {
236 236 PythonQtMemberInfo newInfo(info);
237 237 _cachedMembers.insert(memberName, newInfo);
238 238 }
239 239 tail = info;
240 240 }
241 241 }
242 242 }
243 243 }
244 244
245 245 // look for dynamic decorators in this class and in derived classes
246 246 tail = recursiveFindDecoratorSlotsFromDecoratorProvider(memberName, tail, found, _cachedMembers, 0);
247 247
248 248 return found;
249 249 }
250 250
251 251 bool PythonQtClassInfo::lookForEnumAndCache(const QMetaObject* meta, const char* memberName)
252 252 {
253 253 bool found = false;
254 254 // look for enum values
255 255 int enumCount = meta->enumeratorCount();
256 256 for (int i=0;i<enumCount; i++) {
257 257 QMetaEnum e = meta->enumerator(i);
258 258 // we do not want flags, they will cause our values to appear two times
259 259 if (e.isFlag()) continue;
260 260
261 261 for (int j=0; j < e.keyCount(); j++) {
262 262 if (qstrcmp(e.key(j), memberName)==0) {
263 263 PyObject* enumType = findEnumWrapper(e.name());
264 264 if (enumType) {
265 265 PythonQtObjectPtr enumValuePtr;
266 266 enumValuePtr.setNewRef(PythonQtPrivate::createEnumValueInstance(enumType, e.value(j)));
267 267 PythonQtMemberInfo newInfo(enumValuePtr);
268 268 _cachedMembers.insert(memberName, newInfo);
269 269 #ifdef PYTHONQT_DEBUG
270 270 std::cout << "caching enum " << memberName << " on " << meta->className() << std::endl;
271 271 #endif
272 272 found = true;
273 273 break;
274 274 } else {
275 275 std::cout << "enum " << e.name() << " not found on " << className() << std::endl;
276 276 }
277 277 }
278 278 }
279 279 }
280 280 return found;
281 281 }
282 282
283 283 PythonQtMemberInfo PythonQtClassInfo::member(const char* memberName)
284 284 {
285 285 PythonQtMemberInfo info = _cachedMembers.value(memberName);
286 286 if (info._type != PythonQtMemberInfo::Invalid) {
287 287 return info;
288 288 } else {
289 289 bool found = false;
290 290
291 291 found = lookForPropertyAndCache(memberName);
292 292 if (!found) {
293 293 found = lookForMethodAndCache(memberName);
294 294 }
295 295 if (!found) {
296 296 if (_meta) {
297 297 // check enums in our meta object directly
298 298 found = lookForEnumAndCache(_meta, memberName);
299 299 }
300 300 if (!found) {
301 301 // check enums in the class hierachy of CPP classes
302 302 // look for dynamic decorators in this class and in derived classes
303 303 QList<QObject*> decoObjects;
304 304 recursiveCollectDecoratorObjects(decoObjects);
305 305 foreach(QObject* deco, decoObjects) {
306 306 // call on ourself for caching, but with different metaObject():
307 307 found = lookForEnumAndCache(deco->metaObject(), memberName);
308 308 if (found) {
309 309 break;
310 310 }
311 311 }
312 312 }
313 313 }
314 314 if (!found) {
315 315 // maybe it is an enum wrapper?
316 316 PyObject* p = findEnumWrapper(memberName);
317 317 if (p) {
318 318 info._type = PythonQtMemberInfo::EnumWrapper;
319 319 info._enumWrapper = p;
320 320 _cachedMembers.insert(memberName, info);
321 321 found = true;
322 322 }
323 323 }
324 324 if (!found) {
325 325 // since python keywords can not be looked up, we check if the name contains a single trailing _
326 326 // and remove that and look again, so that we e.g. find exec on an exec_ lookup
327 327 QByteArray mbrName(memberName);
328 328 if ((mbrName.length()>2) &&
329 329 (mbrName.at(mbrName.length()-1) == '_') &&
330 330 (mbrName.at(mbrName.length()-2) != '_')) {
331 331 mbrName = mbrName.mid(0,mbrName.length()-1);
332 332 found = lookForMethodAndCache(mbrName.constData());
333 333 if (found) {
334 334 return _cachedMembers.value(mbrName);
335 335 }
336 336 }
337 337 }
338 338 if (!found) {
339 339 // we store a NotFound member, so that we get a quick result for non existing members (e.g. operator_equal lookup)
340 340 info._type = PythonQtMemberInfo::NotFound;
341 341 _cachedMembers.insert(memberName, info);
342 342 }
343 343 }
344 344
345 345 return _cachedMembers.value(memberName);
346 346 }
347 347
348 348 void PythonQtClassInfo::recursiveCollectDecoratorObjects(QList<QObject*>& decoratorObjects) {
349 349 QObject* deco = decorator();
350 350 if (deco) {
351 351 decoratorObjects.append(deco);
352 352 }
353 353 foreach(const ParentClassInfo& info, _parentClasses) {
354 354 info._parent->recursiveCollectDecoratorObjects(decoratorObjects);
355 355 }
356 356 }
357 357
358 358 void PythonQtClassInfo::recursiveCollectClassInfos(QList<PythonQtClassInfo*>& classInfoObjects) {
359 359 classInfoObjects.append(this);
360 360 foreach(const ParentClassInfo& info, _parentClasses) {
361 361 info._parent->recursiveCollectClassInfos(classInfoObjects);
362 362 }
363 363 }
364 364
365 365 PythonQtSlotInfo* PythonQtClassInfo::findDecoratorSlots(const char* memberName, int memberNameLen, PythonQtSlotInfo* tail, bool &found, QHash<QByteArray, PythonQtMemberInfo>& memberCache, int upcastingOffset)
366 366 {
367 367 QListIterator<PythonQtSlotInfo*> it(_decoratorSlots);
368 368 while (it.hasNext()) {
369 369
370 370 PythonQtSlotInfo* infoOrig = it.next();
371 371
372 372 const char* sigStart = infoOrig->metaMethod()->signature();
373 373 if (qstrncmp("static_", sigStart, 7)==0) {
374 374 sigStart += 7;
375 375 sigStart += findCharOffset(sigStart, '_')+1;
376 376 }
377 377 int offset = findCharOffset(sigStart, '(');
378 378 if (memberNameLen == offset && qstrncmp(memberName, sigStart, offset)==0) {
379 379 //make a copy, otherwise we will have trouble on overloads!
380 380 PythonQtSlotInfo* info = new PythonQtSlotInfo(*infoOrig);
381 381 info->setUpcastingOffset(upcastingOffset);
382 382 found = true;
383 383 if (tail) {
384 384 tail->setNextInfo(info);
385 385 } else {
386 386 PythonQtMemberInfo newInfo(info);
387 387 memberCache.insert(memberName, newInfo);
388 388 }
389 389 tail = info;
390 390 }
391 391 }
392 392 return tail;
393 393 }
394 394
395 395 void PythonQtClassInfo::listDecoratorSlotsFromDecoratorProvider(QStringList& list, bool metaOnly) {
396 396 QObject* decoratorProvider = decorator();
397 397 if (decoratorProvider) {
398 398 const QMetaObject* meta = decoratorProvider->metaObject();
399 399 int numMethods = meta->methodCount();
400 400 int startFrom = QObject::staticMetaObject.methodCount();
401 401 for (int i = startFrom; i < numMethods; i++) {
402 402 QMetaMethod m = meta->method(i);
403 403 if ((m.methodType() == QMetaMethod::Method ||
404 404 m.methodType() == QMetaMethod::Slot) && m.access() == QMetaMethod::Public) {
405 405
406 406 const char* sigStart = m.signature();
407 407 bool isClassDeco = false;
408 408 if (qstrncmp(sigStart, "static_", 7)==0) {
409 409 // skip the static_classname_ part of the string
410 410 sigStart += 7 + 1 + strlen(className());
411 411 isClassDeco = true;
412 412 } else if (qstrncmp(sigStart, "new_", 4)==0) {
413 413 continue;
414 414 } else if (qstrncmp(sigStart, "delete_", 7)==0) {
415 415 continue;
416 416 } else if (qstrncmp(sigStart, "py_", 3)==0) {
417 417 // hide everything that starts with py_
418 418 continue;
419 419 }
420 420 // find the first '('
421 421 int offset = findCharOffset(sigStart, '(');
422 422
423 423 // XXX no checking is currently done if the slots have correct first argument or not...
424 424 if (!metaOnly || isClassDeco) {
425 425 list << QString::fromLatin1(sigStart, offset);
426 426 }
427 427 }
428 428 }
429 429 }
430 430
431 431 // look for global decorator slots
432 432 QListIterator<PythonQtSlotInfo*> it(_decoratorSlots);
433 433 while (it.hasNext()) {
434 434 PythonQtSlotInfo* slot = it.next();
435 435 if (metaOnly) {
436 436 if (slot->isClassDecorator()) {
437 437 QByteArray first = slot->slotName();
438 438 if (first.startsWith("static_")) {
439 439 int idx = first.indexOf('_');
440 440 idx = first.indexOf('_', idx+1);
441 441 first = first.mid(idx+1);
442 442 }
443 443 list << first;
444 444 }
445 445 } else {
446 446 list << slot->slotName();
447 447 }
448 448 }
449 449 }
450 450
451 451 QStringList PythonQtClassInfo::propertyList()
452 452 {
453 453 QStringList l;
454 454 if (_isQObject && _meta) {
455 455 int i;
456 456 int numProperties = _meta->propertyCount();
457 457 for (i = 0; i < numProperties; i++) {
458 458 QMetaProperty p = _meta->property(i);
459 459 l << QString(p.name());
460 460 }
461 461 }
462 462 return l;
463 463 }
464 464
465 465 QStringList PythonQtClassInfo::memberList(bool metaOnly)
466 466 {
467 467 decorator();
468 468
469 469 QStringList l;
470 470 QString h;
471 471 if (_isQObject && _meta && !metaOnly) {
472 472 l = propertyList();
473 473 }
474 474
475 475 // normal slots of QObject (or wrapper QObject)
476 476 if (!metaOnly && _meta) {
477 477 int numMethods = _meta->methodCount();
478 478 bool skipQObj = !_isQObject;
479 479 for (int i = skipQObj?QObject::staticMetaObject.methodCount():0; i < numMethods; i++) {
480 480 QMetaMethod m = _meta->method(i);
481 481 if (((m.methodType() == QMetaMethod::Method ||
482 482 m.methodType() == QMetaMethod::Slot) && m.access() == QMetaMethod::Public)
483 483 || m.methodType()==QMetaMethod::Signal) {
484 484 QByteArray signa(m.signature());
485 485 signa = signa.left(signa.indexOf('('));
486 486 l << signa;
487 487 }
488 488 }
489 489 }
490 490
491 491 {
492 492 // look for dynamic decorators in this class and in derived classes
493 493 QList<PythonQtClassInfo*> infos;
494 494 recursiveCollectClassInfos(infos);
495 495 foreach(PythonQtClassInfo* info, infos) {
496 496 info->listDecoratorSlotsFromDecoratorProvider(l, metaOnly);
497 497 }
498 498 }
499 499
500 500 // List enumerator keys...
501 501 QList<const QMetaObject*> enumMetaObjects;
502 502 if (_meta) {
503 503 enumMetaObjects << _meta;
504 504 }
505 505 // check enums in the class hierachy of CPP classes
506 506 QList<QObject*> decoObjects;
507 507 recursiveCollectDecoratorObjects(decoObjects);
508 508 foreach(QObject* deco, decoObjects) {
509 509 enumMetaObjects << deco->metaObject();
510 510 }
511 511
512 512 foreach(const QMetaObject* meta, enumMetaObjects) {
513 513 for (int i = 0; i<meta->enumeratorCount(); i++) {
514 514 QMetaEnum e = meta->enumerator(i);
515 515 l << e.name();
516 516 // we do not want flags, they will cause our values to appear two times
517 517 if (e.isFlag()) continue;
518 518
519 519 for (int j=0; j < e.keyCount(); j++) {
520 520 l << QString(e.key(j));
521 521 }
522 522 }
523 523 }
524 524
525 525 return QSet<QString>::fromList(l).toList();
526 526 }
527 527
528 528 const char* PythonQtClassInfo::className()
529 529 {
530 530 return _wrappedClassName.constData();
531 531 }
532 532
533 533 void* PythonQtClassInfo::castTo(void* ptr, const char* classname)
534 534 {
535 535 if (ptr==NULL) {
536 536 return NULL;
537 537 }
538 538 if (_wrappedClassName == classname) {
539 539 return ptr;
540 540 }
541 541 foreach(const ParentClassInfo& info, _parentClasses) {
542 542 void* result = info._parent->castTo((char*)ptr + info._upcastingOffset, classname);
543 543 if (result) {
544 544 return result;
545 545 }
546 546 }
547 547 return NULL;
548 548 }
549 549
550 550 bool PythonQtClassInfo::inherits(const char* name)
551 551 {
552 552 if (_wrappedClassName == name) {
553 553 return true;
554 554 }
555 555 foreach(const ParentClassInfo& info, _parentClasses) {
556 556 if (info._parent->inherits(name)) {
557 557 return true;
558 558 }
559 559 }
560 560 return false;
561 561 }
562 562
563 563 bool PythonQtClassInfo::inherits(PythonQtClassInfo* classInfo)
564 564 {
565 565 if (classInfo == this) {
566 566 return true;
567 567 }
568 568 foreach(const ParentClassInfo& info, _parentClasses) {
569 569 if (info._parent->inherits(classInfo)) {
570 570 return true;
571 571 }
572 572 }
573 573 return false;
574 574 }
575 575
576 576 QString PythonQtClassInfo::help()
577 577 {
578 578 decorator();
579 579 QString h;
580 580 h += QString("--- ") + QString(className()) + QString(" ---\n");
581 581
582 582 if (_isQObject) {
583 583 h += "Properties:\n";
584 584
585 585 int i;
586 586 int numProperties = _meta->propertyCount();
587 587 for (i = 0; i < numProperties; i++) {
588 588 QMetaProperty p = _meta->property(i);
589 589 h += QString(p.name()) + " (" + QString(p.typeName()) + " )\n";
590 590 }
591 591 }
592 592
593 593 if (constructors()) {
594 594 h += "Constructors:\n";
595 595 PythonQtSlotInfo* constr = constructors();
596 596 while (constr) {
597 597 h += constr->fullSignature() + "\n";
598 598 constr = constr->nextInfo();
599 599 }
600 600 }
601 601
602 602 h += "Slots:\n";
603 603 h += "QString help()\n";
604 604 h += "QString className()\n";
605 605
606 606 if (_meta) {
607 607 int numMethods = _meta->methodCount();
608 608 for (int i = 0; i < numMethods; i++) {
609 609 QMetaMethod m = _meta->method(i);
610 610 if ((m.methodType() == QMetaMethod::Method ||
611 611 m.methodType() == QMetaMethod::Slot) && m.access() == QMetaMethod::Public) {
612 612 PythonQtSlotInfo slot(this, m, i);
613 613 h += slot.fullSignature()+ "\n";
614 614 }
615 615 }
616 616 }
617 617
618 618 // TODO xxx : decorators and enums from decorator() are missing...
619 619 // maybe we can reuse memberlist()?
620 620
621 621 if (_meta && _meta->enumeratorCount()) {
622 622 h += "Enums:\n";
623 623 for (int i = 0; i<_meta->enumeratorCount(); i++) {
624 624 QMetaEnum e = _meta->enumerator(i);
625 625 h += QString(e.name()) + " {";
626 626 for (int j=0; j < e.keyCount(); j++) {
627 627 if (j) { h+= ", "; }
628 628 h += e.key(j);
629 629 }
630 630 h += " }\n";
631 631 }
632 632 }
633 633
634 634 if (_isQObject && _meta) {
635 635 int numMethods = _meta->methodCount();
636 636 if (numMethods>0) {
637 637 h += "Signals:\n";
638 638 for (int i = 0; i < numMethods; i++) {
639 639 QMetaMethod m = _meta->method(i);
640 640 if (m.methodType() == QMetaMethod::Signal) {
641 641 h += QString(m.signature()) + "\n";
642 642 }
643 643 }
644 644 }
645 645 }
646 646 return h;
647 647 }
648 648
649 649 PythonQtSlotInfo* PythonQtClassInfo::constructors()
650 650 {
651 651 if (!_constructors) {
652 652 // force creation of lazy decorator, which will register the decorators
653 653 decorator();
654 654 }
655 655 return _constructors;
656 656 }
657 657
658 658 PythonQtSlotInfo* PythonQtClassInfo::destructor()
659 659 {
660 660 if (!_destructor) {
661 661 // force creation of lazy decorator, which will register the decorators
662 662 decorator();
663 663 }
664 664 return _destructor;
665 665 }
666 666
667 667 void PythonQtClassInfo::addConstructor(PythonQtSlotInfo* info)
668 668 {
669 669 PythonQtSlotInfo* prev = constructors();
670 670 if (prev) {
671 671 info->setNextInfo(prev->nextInfo());
672 672 prev->setNextInfo(info);
673 673 } else {
674 674 _constructors = info;
675 675 }
676 676 }
677 677
678 678 void PythonQtClassInfo::addDecoratorSlot(PythonQtSlotInfo* info)
679 679 {
680 680 _decoratorSlots.append(info);
681 681 }
682 682
683 683 void PythonQtClassInfo::setDestructor(PythonQtSlotInfo* info)
684 684 {
685 685 if (_destructor) {
686 686 _destructor->deleteOverloadsAndThis();
687 687 }
688 688 _destructor = info;
689 689 }
690 690
691 691 void PythonQtClassInfo::setMetaObject(const QMetaObject* meta)
692 692 {
693 693 _meta = meta;
694 694 clearCachedMembers();
695 695 }
696 696
697 697 QObject* PythonQtClassInfo::decorator()
698 698 {
699 699 if (!_decoratorProvider && _decoratorProviderCB) {
700 700 _decoratorProvider = (*_decoratorProviderCB)();
701 701 if (_decoratorProvider) {
702 702 _decoratorProvider->setParent(PythonQt::priv());
703 703 // setup enums early, since they might be needed by the constructor decorators:
704 704 if (!_enumsCreated) {
705 705 createEnumWrappers();
706 706 }
707 707 PythonQt::priv()->addDecorators(_decoratorProvider, PythonQtPrivate::ConstructorDecorator | PythonQtPrivate::DestructorDecorator);
708 708 }
709 709 }
710 710 // check if enums need to be created and create them if they are not yet created
711 711 if (!_enumsCreated) {
712 712 createEnumWrappers();
713 713 }
714 714 return _decoratorProvider;
715 715 }
716 716
717 717 bool PythonQtClassInfo::hasOwnerMethodButNoOwner(void* object)
718 718 {
719 719 PythonQtMemberInfo info = member("py_hasOwner");
720 720 if (info._type == PythonQtMemberInfo::Slot) {
721 721 void* obj = object;
722 722 bool result = false;
723 723 void* args[2];
724 724 args[0] = &result;
725 725 args[1] = &obj;
726 726 info._slot->decorator()->qt_metacall(QMetaObject::InvokeMetaMethod, info._slot->slotIndex(), args);
727 727 return !result;
728 728 } else {
729 729 return false;
730 730 }
731 731 }
732 732
733 733 void* PythonQtClassInfo::recursiveCastDownIfPossible(void* ptr, char** resultClassName)
734 734 {
735 735 if (!_polymorphicHandlers.isEmpty()) {
736 736 foreach(PythonQtPolymorphicHandlerCB* cb, _polymorphicHandlers) {
737 737 void* resultPtr = (*cb)(ptr, resultClassName);
738 738 if (resultPtr) {
739 739 return resultPtr;
740 740 }
741 741 }
742 742 }
743 743 foreach(const ParentClassInfo& info, _parentClasses) {
744 744 if (!info._parent->isQObject()) {
745 745 void* resultPtr = info._parent->recursiveCastDownIfPossible((char*)ptr + info._upcastingOffset, resultClassName);
746 746 if (resultPtr) {
747 747 return resultPtr;
748 748 }
749 749 }
750 750 }
751 751 return NULL;
752 752 }
753 753
754 754 void* PythonQtClassInfo::castDownIfPossible(void* ptr, PythonQtClassInfo** resultClassInfo)
755 755 {
756 756 char* className;
757 757 // this would do downcasting recursively...
758 758 // void* resultPtr = recursiveCastDownIfPossible(ptr, &className);
759 759
760 760 // we only do downcasting on the base object, not on the whole inheritance tree...
761 761 void* resultPtr = NULL;
762 762 if (!_polymorphicHandlers.isEmpty()) {
763 763 foreach(PythonQtPolymorphicHandlerCB* cb, _polymorphicHandlers) {
764 764 resultPtr = (*cb)(ptr, &className);
765 765 if (resultPtr) {
766 766 break;
767 767 }
768 768 }
769 769 }
770 770 if (resultPtr) {
771 771 *resultClassInfo = PythonQt::priv()->getClassInfo(className);
772 772 } else {
773 773 *resultClassInfo = this;
774 774 resultPtr = ptr;
775 775 }
776 776 return resultPtr;
777 777 }
778 778
779 779 PyObject* PythonQtClassInfo::findEnumWrapper(const QByteArray& name, PythonQtClassInfo* localScope, bool* isLocalEnum)
780 780 {
781 781 if (isLocalEnum) {
782 782 *isLocalEnum = true;
783 783 }
784 784 int scopePos = name.lastIndexOf("::");
785 785 if (scopePos != -1) {
786 786 if (isLocalEnum) {
787 787 *isLocalEnum = false;
788 788 }
789 789 // split into scope and enum name
790 790 QByteArray enumScope = name.mid(0,scopePos);
791 791 QByteArray enumName = name.mid(scopePos+2);
792 792 PythonQtClassInfo* info = PythonQt::priv()->getClassInfo(enumScope);
793 793 if (info) {
794 794 return info->findEnumWrapper(enumName);
795 795 } else{
796 796 return NULL;
797 797 }
798 798 }
799 799 if (localScope) {
800 800 return localScope->findEnumWrapper(name);
801 801 } else {
802 802 return NULL;
803 803 }
804 804 }
805 805
806 806 void PythonQtClassInfo::createEnumWrappers(const QMetaObject* meta)
807 807 {
808 808 for (int i = meta->enumeratorOffset();i<meta->enumeratorCount();i++) {
809 809 QMetaEnum e = meta->enumerator(i);
810 810 PythonQtObjectPtr p;
811 811 p.setNewRef(PythonQtPrivate::createNewPythonQtEnumWrapper(e.name(), _pythonQtClassWrapper));
812 812 _enumWrappers.append(p);
813 813 }
814 814 }
815 815
816 816 void PythonQtClassInfo::createEnumWrappers()
817 817 {
818 818 if (!_enumsCreated) {
819 819 _enumsCreated = true;
820 820 if (_meta) {
821 821 createEnumWrappers(_meta);
822 822 }
823 823 if (decorator()) {
824 824 createEnumWrappers(decorator()->metaObject());
825 825 }
826 826 foreach(const ParentClassInfo& info, _parentClasses) {
827 827 info._parent->createEnumWrappers();
828 828 }
829 829 }
830 830 }
831 831
832 832 PyObject* PythonQtClassInfo::findEnumWrapper(const char* name) {
833 833 // force enum creation
834 834 if (!_enumsCreated) {
835 835 createEnumWrappers();
836 836 }
837 837 foreach(const PythonQtObjectPtr& p, _enumWrappers) {
838 838 const char* className = ((PyTypeObject*)p.object())->tp_name;
839 839 if (qstrcmp(className, name)==0) {
840 840 return p.object();
841 841 }
842 842 }
843 843 foreach(const ParentClassInfo& info, _parentClasses) {
844 844 PyObject* p = info._parent->findEnumWrapper(name);
845 845 if (p) return p;
846 846 }
847 847 return NULL;
848 848 }
849 849
Show file before | Show file after | Hide comments
@@ -1,262 +1,262
1 1 #ifndef _PYTHONQTCLASSINFO_H
2 2 #define _PYTHONQTCLASSINFO_H
3 3
4 4 /*
5 5 *
6 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
6 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
7 7 *
8 8 * This library is free software; you can redistribute it and/or
9 9 * modify it under the terms of the GNU Lesser General Public
10 10 * License as published by the Free Software Foundation; either
11 11 * version 2.1 of the License, or (at your option) any later version.
12 12 *
13 13 * This library is distributed in the hope that it will be useful,
14 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 16 * Lesser General Public License for more details.
17 17 *
18 18 * Further, this software is distributed without any warranty that it is
19 19 * free of the rightful claim of any third person regarding infringement
20 20 * or the like. Any license provided herein, whether implied or
21 21 * otherwise, applies only to this software file. Patent licenses, if
22 22 * any, provided herein do not apply to combinations of this program with
23 23 * other software, or any other product whatsoever.
24 24 *
25 25 * You should have received a copy of the GNU Lesser General Public
26 26 * License along with this library; if not, write to the Free Software
27 27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 28 *
29 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
29 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
30 30 * 28359 Bremen, Germany or:
31 31 *
32 32 * http://www.mevis.de
33 33 *
34 34 */
35 35
36 36 #include <QMetaObject>
37 37 #include <QMetaMethod>
38 38 #include <QHash>
39 39 #include <QByteArray>
40 40 #include <QList>
41 41 #include "PythonQt.h"
42 42
43 43 class PythonQtSlotInfo;
44 44
45 45 struct PythonQtMemberInfo {
46 46 enum Type {
47 47 Invalid, Slot, EnumValue, EnumWrapper, Property, NotFound
48 48 };
49 49
50 50 PythonQtMemberInfo():_type(Invalid),_slot(NULL),_enumWrapper(NULL),_enumValue(0) { }
51 51
52 52 PythonQtMemberInfo(PythonQtSlotInfo* info) {
53 53 _type = Slot;
54 54 _slot = info;
55 55 _enumValue = NULL;
56 56 }
57 57
58 58 PythonQtMemberInfo(const PythonQtObjectPtr& enumValue) {
59 59 _type = EnumValue;
60 60 _slot = NULL;
61 61 _enumValue = enumValue;
62 62 _enumWrapper = NULL;
63 63 }
64 64
65 65 PythonQtMemberInfo(const QMetaProperty& prop) {
66 66 _type = Property;
67 67 _slot = NULL;
68 68 _enumValue = NULL;
69 69 _property = prop;
70 70 _enumWrapper = NULL;
71 71 }
72 72
73 73 Type _type;
74 74
75 75 // TODO: this could be a union...
76 76 PythonQtSlotInfo* _slot;
77 77 PyObject* _enumWrapper;
78 78 PythonQtObjectPtr _enumValue;
79 79 QMetaProperty _property;
80 80 };
81 81
82 82 //! a class that stores all required information about a Qt object (and an optional associated C++ class name)
83 83 /*! for fast lookup of slots when calling the object from Python
84 84 */
85 85 class PythonQtClassInfo {
86 86
87 87 public:
88 88 PythonQtClassInfo();
89 89 ~PythonQtClassInfo();
90 90
91 91 //! store information about parent classes
92 92 struct ParentClassInfo {
93 93 ParentClassInfo(PythonQtClassInfo* parent, int upcastingOffset=0):_parent(parent),_upcastingOffset(upcastingOffset)
94 94 {};
95 95
96 96 PythonQtClassInfo* _parent;
97 97 int _upcastingOffset;
98 98 };
99 99
100 100
101 101 //! setup as a QObject, taking the meta object as meta information about the QObject
102 102 void setupQObject(const QMetaObject* meta);
103 103
104 104 //! setup as a CPP (non-QObject), taking the classname
105 105 void setupCPPObject(const QByteArray& classname);
106 106
107 107 //! set the type capabilities
108 108 void setTypeSlots(int typeSlots) { _typeSlots = typeSlots; }
109 109 //! get the type capabilities
110 110 int typeSlots() const { return _typeSlots; }
111 111
112 112 //! get the Python method definition for a given slot name (without return type and signature)
113 113 PythonQtMemberInfo member(const char* member);
114 114
115 115 //! get access to the constructor slot (which may be overloaded if there are multiple constructors)
116 116 PythonQtSlotInfo* constructors();
117 117
118 118 //! get access to the destructor slot
119 119 PythonQtSlotInfo* destructor();
120 120
121 121 //! add a constructor, ownership is passed to classinfo
122 122 void addConstructor(PythonQtSlotInfo* info);
123 123
124 124 //! set a destructor, ownership is passed to classinfo
125 125 void setDestructor(PythonQtSlotInfo* info);
126 126
127 127 //! add a decorator slot, ownership is passed to classinfo
128 128 void addDecoratorSlot(PythonQtSlotInfo* info);
129 129
130 130 //! get the classname (either of the QObject or of the wrapped CPP object)
131 131 const char* className();
132 132
133 133 //! returns if the QObject
134 134 bool isQObject() { return _isQObject; }
135 135
136 136 //! returns if the class is a CPP wrapper
137 137 bool isCPPWrapper() { return !_isQObject; }
138 138
139 139 //! get the meta object
140 140 const QMetaObject* metaObject() { return _meta; }
141 141
142 142 //! set the meta object, this will reset the caching
143 143 void setMetaObject(const QMetaObject* meta);
144 144
145 145 //! returns if this class inherits from the given classname
146 146 bool inherits(const char* classname);
147 147
148 148 //! returns if this class inherits from the given classinfo
149 149 bool inherits(PythonQtClassInfo* info);
150 150
151 151 //! casts the given \c ptr to an object of type \c classname, returns the new pointer
152 152 //! which might be different to \c ptr due to C++ multiple inheritance
153 153 //! (if the cast is not possible or if ptr is NULL, NULL is returned)
154 154 void* castTo(void* ptr, const char* classname);
155 155
156 156 //! get help string for the metaobject
157 157 QString help();
158 158
159 159 //! get list of all properties (on QObjects only, otherwise the list is empty)
160 160 QStringList propertyList();
161 161
162 162 //! get list of all members
163 163 QStringList memberList(bool metaOnly = false);
164 164
165 165 //! get the meta type id of this class (only valid for isCPPWrapper() == true)
166 166 int metaTypeId() { return _metaTypeId; }
167 167
168 168 //! set an additional decorator provider that offers additional decorator slots for this class
169 169 void setDecoratorProvider(PythonQtQObjectCreatorFunctionCB* cb) { _decoratorProviderCB = cb; _decoratorProvider = NULL; }
170 170
171 171 //! get the decorator qobject instance
172 172 QObject* decorator();
173 173
174 174 //! add the parent class info of a CPP object
175 175 void addParentClass(const ParentClassInfo& info) { _parentClasses.append(info); }
176 176
177 177 //! check if the special method "py_hasOwner" is implemented and if it returns false, which means that the object may be destroyed
178 178 bool hasOwnerMethodButNoOwner(void* object);
179 179
180 180 //! set the associated PythonQtClassWrapper (which handles instance creation of this type)
181 181 void setPythonQtClassWrapper(PyObject* obj) { _pythonQtClassWrapper = obj; }
182 182
183 183 //! get the associated PythonQtClassWrapper (which handles instance creation of this type)
184 184 PyObject* pythonQtClassWrapper() { return _pythonQtClassWrapper; }
185 185
186 186 //! set the shell set instance wrapper cb
187 187 void setShellSetInstanceWrapperCB(PythonQtShellSetInstanceWrapperCB* cb) {
188 188 _shellSetInstanceWrapperCB = cb;
189 189 }
190 190
191 191 //! get the shell set instance wrapper cb
192 192 PythonQtShellSetInstanceWrapperCB* shellSetInstanceWrapperCB() {
193 193 return _shellSetInstanceWrapperCB;
194 194 }
195 195
196 196 //! add a handler for polymorphic downcasting
197 197 void addPolymorphicHandler(PythonQtPolymorphicHandlerCB* cb) { _polymorphicHandlers.append(cb); }
198 198
199 199 //! cast the pointer down in the class hierarchy if a polymorphic handler allows to do that
200 200 void* castDownIfPossible(void* ptr, PythonQtClassInfo** resultClassInfo);
201 201
202 202 //! returns if the localScope has an enum of that type name or if the enum contains a :: scope, if that class contails the enum
203 203 static PyObject* findEnumWrapper(const QByteArray& name, PythonQtClassInfo* localScope, bool* isLocalEnum = NULL);
204 204
205 205 private:
206 206 void createEnumWrappers();
207 207 void createEnumWrappers(const QMetaObject* meta);
208 208 PyObject* findEnumWrapper(const char* name);
209 209
210 210 //! clear all cached members
211 211 void clearCachedMembers();
212 212
213 213 void* recursiveCastDownIfPossible(void* ptr, char** resultClassName);
214 214
215 215 PythonQtSlotInfo* findDecoratorSlotsFromDecoratorProvider(const char* memberName, PythonQtSlotInfo* inputInfo, bool &found, QHash<QByteArray, PythonQtMemberInfo>& memberCache, int upcastingOffset);
216 216 void listDecoratorSlotsFromDecoratorProvider(QStringList& list, bool metaOnly);
217 217 PythonQtSlotInfo* recursiveFindDecoratorSlotsFromDecoratorProvider(const char* memberName, PythonQtSlotInfo* inputInfo, bool &found, QHash<QByteArray, PythonQtMemberInfo>& memberCache, int upcastingOffset);
218 218
219 219 void recursiveCollectClassInfos(QList<PythonQtClassInfo*>& classInfoObjects);
220 220 void recursiveCollectDecoratorObjects(QList<QObject*>& decoratorObjects);
221 221
222 222 bool lookForPropertyAndCache(const char* memberName);
223 223 bool lookForMethodAndCache(const char* memberName);
224 224 bool lookForEnumAndCache(const QMetaObject* m, const char* memberName);
225 225
226 226 PythonQtSlotInfo* findDecoratorSlots(const char* memberName, int memberNameLen, PythonQtSlotInfo* tail, bool &found, QHash<QByteArray, PythonQtMemberInfo>& memberCache, int upcastingOffset);
227 227 int findCharOffset(const char* sigStart, char someChar);
228 228
229 229 QHash<QByteArray, PythonQtMemberInfo> _cachedMembers;
230 230
231 231 PythonQtSlotInfo* _constructors;
232 232 PythonQtSlotInfo* _destructor;
233 233 QList<PythonQtSlotInfo*> _decoratorSlots;
234 234
235 235 QList<PythonQtObjectPtr> _enumWrappers;
236 236
237 237 const QMetaObject* _meta;
238 238
239 239 QByteArray _wrappedClassName;
240 240 QList<ParentClassInfo> _parentClasses;
241 241
242 242 QList<PythonQtPolymorphicHandlerCB*> _polymorphicHandlers;
243 243
244 244 QObject* _decoratorProvider;
245 245 PythonQtQObjectCreatorFunctionCB* _decoratorProviderCB;
246 246
247 247 PyObject* _pythonQtClassWrapper;
248 248
249 249 PythonQtShellSetInstanceWrapperCB* _shellSetInstanceWrapperCB;
250 250
251 251 int _metaTypeId;
252 252 int _typeSlots;
253 253
254 254 bool _isQObject;
255 255 bool _enumsCreated;
256 256
257 257 };
258 258
259 259 //---------------------------------------------------------------
260 260
261 261
262 262 #endif
Show file before | Show file after | Hide comments
@@ -1,454 +1,454
1 1 /*
2 2 *
3 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
3 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
4 4 *
5 5 * This library is free software; you can redistribute it and/or
6 6 * modify it under the terms of the GNU Lesser General Public
7 7 * License as published by the Free Software Foundation; either
8 8 * version 2.1 of the License, or (at your option) any later version.
9 9 *
10 10 * This library is distributed in the hope that it will be useful,
11 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 13 * Lesser General Public License for more details.
14 14 *
15 15 * Further, this software is distributed without any warranty that it is
16 16 * free of the rightful claim of any third person regarding infringement
17 17 * or the like. Any license provided herein, whether implied or
18 18 * otherwise, applies only to this software file. Patent licenses, if
19 19 * any, provided herein do not apply to combinations of this program with
20 20 * other software, or any other product whatsoever.
21 21 *
22 22 * You should have received a copy of the GNU Lesser General Public
23 23 * License along with this library; if not, write to the Free Software
24 24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 25 *
26 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
26 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
27 27 * 28359 Bremen, Germany or:
28 28 *
29 29 * http://www.mevis.de
30 30 *
31 31 */
32 32
33 33 //----------------------------------------------------------------------------------
34 34 /*!
35 35 // \file PythonQtClassWrapper.cpp
36 36 // \author Florian Link
37 37 // \author Last changed by $Author: florian $
38 38 // \date 2006-05
39 39 */
40 40 //----------------------------------------------------------------------------------
41 41
42 42 #include "PythonQtClassWrapper.h"
43 43 #include <QObject>
44 44
45 45 #include "PythonQt.h"
46 46 #include "PythonQtSlot.h"
47 47 #include "PythonQtClassInfo.h"
48 48 #include "PythonQtConversion.h"
49 49 #include "PythonQtInstanceWrapper.h"
50 50
51 51 static PyObject* PythonQtInstanceWrapper_invert(PythonQtInstanceWrapper* wrapper)
52 52 {
53 53 PyObject* result = NULL;
54 54 static QByteArray memberName = "__invert__";
55 55 PythonQtMemberInfo opSlot = wrapper->classInfo()->member(memberName);
56 56 if (opSlot._type == PythonQtMemberInfo::Slot) {
57 57 result = PythonQtSlotFunction_CallImpl(wrapper->classInfo(), wrapper->_obj, opSlot._slot, NULL, NULL, wrapper->_wrappedPtr);
58 58 }
59 59 return result;
60 60 }
61 61
62 62 static int PythonQtInstanceWrapper_nonzero(PythonQtInstanceWrapper* wrapper)
63 63 {
64 64 int result = (wrapper->_wrappedPtr == NULL && wrapper->_obj == NULL)?0:1;
65 65 if (result) {
66 66 static QByteArray memberName = "__nonzero__";
67 67 PythonQtMemberInfo opSlot = wrapper->classInfo()->member(memberName);
68 68 if (opSlot._type == PythonQtMemberInfo::Slot) {
69 69 PyObject* resultObj = PythonQtSlotFunction_CallImpl(wrapper->classInfo(), wrapper->_obj, opSlot._slot, NULL, NULL, wrapper->_wrappedPtr);
70 70 if (resultObj == Py_False) {
71 71 result = 0;
72 72 }
73 73 Py_XDECREF(resultObj);
74 74 }
75 75 }
76 76 return result;
77 77 }
78 78
79 79
80 80 static PyObject* PythonQtInstanceWrapper_binaryfunc(PythonQtInstanceWrapper* wrapper, PyObject* other, const QByteArray& opName, const QByteArray& fallbackOpName = QByteArray())
81 81 {
82 82 PyObject* result = NULL;
83 83 PythonQtMemberInfo opSlot = wrapper->classInfo()->member(opName);
84 84 if (opSlot._type == PythonQtMemberInfo::Slot) {
85 85 // TODO get rid of tuple
86 86 PyObject* args = PyTuple_New(1);
87 87 Py_INCREF(other);
88 88 PyTuple_SET_ITEM(args, 0, other);
89 89 result = PythonQtSlotFunction_CallImpl(wrapper->classInfo(), wrapper->_obj, opSlot._slot, args, NULL, wrapper->_wrappedPtr);
90 90 Py_DECREF(args);
91 91 if (!result && !fallbackOpName.isEmpty()) {
92 92 // try fallback if we did not get a result
93 93 result = PythonQtInstanceWrapper_binaryfunc(wrapper, other, fallbackOpName);
94 94 }
95 95 }
96 96 return result;
97 97 }
98 98
99 99 #define BINARY_OP(NAME) \
100 100 static PyObject* PythonQtInstanceWrapper_ ## NAME(PythonQtInstanceWrapper* wrapper, PyObject* other) \
101 101 { \
102 102 static const QByteArray opName("__" #NAME "__"); \
103 103 return PythonQtInstanceWrapper_binaryfunc(wrapper, other, opName); \
104 104 }
105 105
106 106 #define BINARY_OP_INPLACE(NAME) \
107 107 static PyObject* PythonQtInstanceWrapper_i ## NAME(PythonQtInstanceWrapper* wrapper, PyObject* other) \
108 108 { \
109 109 static const QByteArray opName("__i" #NAME "__"); \
110 110 static const QByteArray fallbackName("__" #NAME "__"); \
111 111 return PythonQtInstanceWrapper_binaryfunc(wrapper, other, opName, fallbackName); \
112 112 }
113 113
114 114 BINARY_OP(add)
115 115 BINARY_OP(sub)
116 116 BINARY_OP(mul)
117 117 BINARY_OP(div)
118 118 BINARY_OP(and)
119 119 BINARY_OP(or)
120 120 BINARY_OP(xor)
121 121 BINARY_OP(mod)
122 122 BINARY_OP(lshift)
123 123 BINARY_OP(rshift)
124 124
125 125 BINARY_OP_INPLACE(add)
126 126 BINARY_OP_INPLACE(sub)
127 127 BINARY_OP_INPLACE(mul)
128 128 BINARY_OP_INPLACE(div)
129 129 BINARY_OP_INPLACE(and)
130 130 BINARY_OP_INPLACE(or)
131 131 BINARY_OP_INPLACE(xor)
132 132 BINARY_OP_INPLACE(mod)
133 133 BINARY_OP_INPLACE(lshift)
134 134 BINARY_OP_INPLACE(rshift)
135 135
136 136 static void initializeSlots(PythonQtClassWrapper* wrap)
137 137 {
138 138 int typeSlots = wrap->classInfo()->typeSlots();
139 139 if (typeSlots) {
140 140 if (typeSlots & PythonQt::Type_Add) {
141 141 wrap->_base.as_number.nb_add = (binaryfunc)PythonQtInstanceWrapper_add;
142 142 }
143 143 if (typeSlots & PythonQt::Type_Subtract) {
144 144 wrap->_base.as_number.nb_subtract = (binaryfunc)PythonQtInstanceWrapper_sub;
145 145 }
146 146 if (typeSlots & PythonQt::Type_Multiply) {
147 147 wrap->_base.as_number.nb_multiply = (binaryfunc)PythonQtInstanceWrapper_mul;
148 148 }
149 149 if (typeSlots & PythonQt::Type_Divide) {
150 150 wrap->_base.as_number.nb_divide = (binaryfunc)PythonQtInstanceWrapper_div;
151 151 wrap->_base.as_number.nb_true_divide = (binaryfunc)PythonQtInstanceWrapper_div;
152 152 }
153 153 if (typeSlots & PythonQt::Type_And) {
154 154 wrap->_base.as_number.nb_and = (binaryfunc)PythonQtInstanceWrapper_and;
155 155 }
156 156 if (typeSlots & PythonQt::Type_Or) {
157 157 wrap->_base.as_number.nb_or = (binaryfunc)PythonQtInstanceWrapper_or;
158 158 }
159 159 if (typeSlots & PythonQt::Type_Xor) {
160 160 wrap->_base.as_number.nb_xor = (binaryfunc)PythonQtInstanceWrapper_xor;
161 161 }
162 162 if (typeSlots & PythonQt::Type_Mod) {
163 163 wrap->_base.as_number.nb_remainder = (binaryfunc)PythonQtInstanceWrapper_mod;
164 164 }
165 165 if (typeSlots & PythonQt::Type_LShift) {
166 166 wrap->_base.as_number.nb_lshift = (binaryfunc)PythonQtInstanceWrapper_lshift;
167 167 }
168 168 if (typeSlots & PythonQt::Type_RShift) {
169 169 wrap->_base.as_number.nb_rshift = (binaryfunc)PythonQtInstanceWrapper_rshift;
170 170 }
171 171
172 172 if (typeSlots & PythonQt::Type_InplaceAdd) {
173 173 wrap->_base.as_number.nb_add = (binaryfunc)PythonQtInstanceWrapper_iadd;
174 174 }
175 175 if (typeSlots & PythonQt::Type_InplaceSubtract) {
176 176 wrap->_base.as_number.nb_subtract = (binaryfunc)PythonQtInstanceWrapper_isub;
177 177 }
178 178 if (typeSlots & PythonQt::Type_InplaceMultiply) {
179 179 wrap->_base.as_number.nb_multiply = (binaryfunc)PythonQtInstanceWrapper_imul;
180 180 }
181 181 if (typeSlots & PythonQt::Type_InplaceDivide) {
182 182 wrap->_base.as_number.nb_inplace_divide = (binaryfunc)PythonQtInstanceWrapper_idiv;
183 183 wrap->_base.as_number.nb_inplace_true_divide = (binaryfunc)PythonQtInstanceWrapper_idiv;
184 184 }
185 185 if (typeSlots & PythonQt::Type_InplaceAnd) {
186 186 wrap->_base.as_number.nb_inplace_and = (binaryfunc)PythonQtInstanceWrapper_iand;
187 187 }
188 188 if (typeSlots & PythonQt::Type_InplaceOr) {
189 189 wrap->_base.as_number.nb_inplace_or = (binaryfunc)PythonQtInstanceWrapper_ior;
190 190 }
191 191 if (typeSlots & PythonQt::Type_InplaceXor) {
192 192 wrap->_base.as_number.nb_inplace_xor = (binaryfunc)PythonQtInstanceWrapper_ixor;
193 193 }
194 194 if (typeSlots & PythonQt::Type_InplaceMod) {
195 195 wrap->_base.as_number.nb_inplace_remainder = (binaryfunc)PythonQtInstanceWrapper_imod;
196 196 }
197 197 if (typeSlots & PythonQt::Type_InplaceLShift) {
198 198 wrap->_base.as_number.nb_inplace_lshift = (binaryfunc)PythonQtInstanceWrapper_ilshift;
199 199 }
200 200 if (typeSlots & PythonQt::Type_InplaceRShift) {
201 201 wrap->_base.as_number.nb_inplace_rshift = (binaryfunc)PythonQtInstanceWrapper_irshift;
202 202 }
203 203 if (typeSlots & PythonQt::Type_Invert) {
204 204 wrap->_base.as_number.nb_invert = (unaryfunc)PythonQtInstanceWrapper_invert;
205 205 }
206 206 if (typeSlots & PythonQt::Type_NonZero) {
207 207 wrap->_base.as_number.nb_nonzero = (inquiry)PythonQtInstanceWrapper_nonzero;
208 208 }
209 209 }
210 210 }
211 211
212 212 static PyObject* PythonQtClassWrapper_alloc(PyTypeObject *self, Py_ssize_t nitems)
213 213 {
214 214 // call the default type alloc
215 215 PyObject* obj = PyType_Type.tp_alloc(self, nitems);
216 216
217 217 // take current class type, if we are called via newPythonQtClassWrapper()
218 218 PythonQtClassWrapper* wrap = (PythonQtClassWrapper*)obj;
219 219 wrap->_classInfo = PythonQt::priv()->currentClassInfoForClassWrapperCreation();
220 220 if (wrap->_classInfo) {
221 221 initializeSlots(wrap);
222 222 }
223 223
224 224 return obj;
225 225 }
226 226
227 227
228 228 static int PythonQtClassWrapper_init(PythonQtClassWrapper* self, PyObject* args, PyObject* kwds)
229 229 {
230 230 // call the default type init
231 231 if (PyType_Type.tp_init((PyObject *)self, args, kwds) < 0) {
232 232 return -1;
233 233 }
234 234
235 235 // if we have no CPP class information, try our base class
236 236 if (!self->classInfo()) {
237 237 PyTypeObject* superType = ((PyTypeObject *)self)->tp_base;
238 238
239 239 if (!superType || (superType->ob_type != &PythonQtClassWrapper_Type)) {
240 240 PyErr_Format(PyExc_TypeError, "type %s is not derived from PythonQtClassWrapper", ((PyTypeObject*)self)->tp_name);
241 241 return -1;
242 242 }
243 243
244 244 // take the class info from the superType
245 245 self->_classInfo = ((PythonQtClassWrapper*)superType)->classInfo();
246 246 }
247 247
248 248 return 0;
249 249 }
250 250
251 251 static PyObject *PythonQtClassWrapper_classname(PythonQtClassWrapper* type)
252 252 {
253 253 return PyString_FromString((QString("Class_") + type->classInfo()->className()).toLatin1().data());
254 254 }
255 255
256 256 static PyObject *PythonQtClassWrapper_help(PythonQtClassWrapper* type)
257 257 {
258 258 return PythonQt::self()->helpCalled(type->classInfo());
259 259 }
260 260
261 261 PyObject *PythonQtClassWrapper__init__(PythonQtClassWrapper *type, PyObject *args)
262 262 {
263 263 Py_ssize_t argc = PyTuple_Size(args);
264 264 if (argc>0) {
265 265 // we need to call __init__ of the instance
266 266 PyObject* self = PyTuple_GET_ITEM(args, 0);
267 267 if (PyObject_TypeCheck(self, (PyTypeObject*)type->classInfo()->pythonQtClassWrapper())) {
268 268 PyObject* newargs = PyTuple_New(argc-1);
269 269 for (int i = 0;i<argc-1; i++) {
270 270 PyTuple_SET_ITEM(newargs, i,PyTuple_GET_ITEM(args, i+1));
271 271 }
272 272 PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)self;
273 273 int result = PythonQtInstanceWrapper_init(wrapper, newargs, NULL);
274 274 Py_DECREF(newargs);
275 275 if (result==0) {
276 276 Py_INCREF(Py_None);
277 277 return Py_None;
278 278 } else {
279 279 // init failed!
280 280 }
281 281 } else {
282 282 // self not of correct type!
283 283 }
284 284 } else {
285 285 // wrong number of args
286 286 }
287 287 return NULL;
288 288 }
289 289
290 290 static PyMethodDef PythonQtClassWrapper_methods[] = {
291 291 {"__init__", (PyCFunction)PythonQtClassWrapper__init__, METH_VARARGS,
292 292 "Return the classname of the object"
293 293 },
294 294 {"className", (PyCFunction)PythonQtClassWrapper_classname, METH_NOARGS,
295 295 "Return the classname of the object"
296 296 },
297 297 {"help", (PyCFunction)PythonQtClassWrapper_help, METH_NOARGS,
298 298 "Shows the help of available methods for this class"
299 299 },
300 300 {NULL, NULL, 0 , NULL} /* Sentinel */
301 301 };
302 302
303 303
304 304 static PyObject *PythonQtClassWrapper_getattro(PyObject *obj, PyObject *name)
305 305 {
306 306 const char *attributeName;
307 307 PythonQtClassWrapper *wrapper = (PythonQtClassWrapper *)obj;
308 308
309 309 if ((attributeName = PyString_AsString(name)) == NULL) {
310 310 return NULL;
311 311 }
312 312 if (obj == (PyObject*)&PythonQtInstanceWrapper_Type) {
313 313 return NULL;
314 314 }
315 315
316 316 if (qstrcmp(attributeName, "__dict__")==0) {
317 317 PyObject* dict = ((PyTypeObject *)wrapper)->tp_dict;
318 318 if (!wrapper->classInfo()) {
319 319 Py_INCREF(dict);
320 320 return dict;
321 321 }
322 322 dict = PyDict_Copy(dict);
323 323
324 324 QStringList l = wrapper->classInfo()->memberList(false);
325 325 foreach (QString name, l) {
326 326 PyObject* o = PyObject_GetAttrString(obj, name.toLatin1().data());
327 327 if (o) {
328 328 PyDict_SetItemString(dict, name.toLatin1().data(), o);
329 329 Py_DECREF(o);
330 330 } else {
331 331 // it must have been a property or child, which we do not know as a class object...
332 332 }
333 333 }
334 334 if (wrapper->classInfo()->constructors()) {
335 335 PyObject* func = PyCFunction_New(&PythonQtClassWrapper_methods[0], obj);
336 336 PyDict_SetItemString(dict, "__init__", func);
337 337 Py_DECREF(func);
338 338 }
339 339 for (int i = 1;i<3;i++) {
340 340 PyObject* func = PyCFunction_New(&PythonQtClassWrapper_methods[i], obj);
341 341 PyDict_SetItemString(dict, PythonQtClassWrapper_methods[i].ml_name, func);
342 342 Py_DECREF(func);
343 343 }
344 344 return dict;
345 345 }
346 346
347 347 if (wrapper->classInfo()) {
348 348 PythonQtMemberInfo member = wrapper->classInfo()->member(attributeName);
349 349 if (member._type == PythonQtMemberInfo::EnumValue) {
350 350 PyObject* enumValue = member._enumValue;
351 351 Py_INCREF(enumValue);
352 352 return enumValue;
353 353 } else if (member._type == PythonQtMemberInfo::EnumWrapper) {
354 354 PyObject* enumWrapper = member._enumWrapper;
355 355 Py_INCREF(enumWrapper);
356 356 return enumWrapper;
357 357 } else if (member._type == PythonQtMemberInfo::Slot) {
358 358 // we return all slots, even the instance slots, since they are callable as unbound slots with self argument
359 359 return PythonQtSlotFunction_New(member._slot, obj, NULL);
360 360 }
361 361 }
362 362
363 363 // look for the interal methods (className(), help())
364 364 PyObject* internalMethod = Py_FindMethod( PythonQtClassWrapper_methods, obj, (char*)attributeName);
365 365 if (internalMethod) {
366 366 return internalMethod;
367 367 }
368 368 PyErr_Clear();
369 369
370 370 // look in super
371 371 PyObject* superAttr = PyType_Type.tp_getattro(obj, name);
372 372 if (superAttr) {
373 373 return superAttr;
374 374 }
375 375
376 376 QString error = QString(wrapper->classInfo()->className()) + " has no attribute named '" + QString(attributeName) + "'";
377 377 PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
378 378 return NULL;
379 379 }
380 380
381 381 static int PythonQtClassWrapper_setattro(PyObject *obj,PyObject *name,PyObject *value)
382 382 {
383 383 return PyType_Type.tp_setattro(obj,name,value);
384 384 }
385 385
386 386 /*
387 387 static PyObject * PythonQtClassWrapper_repr(PyObject * obj)
388 388 {
389 389 PythonQtClassWrapper* wrapper = (PythonQtClassWrapper*)obj;
390 390 if (wrapper->classInfo()->isCPPWrapper()) {
391 391 const QMetaObject* meta = wrapper->classInfo()->metaObject();
392 392 if (!meta) {
393 393 QObject* decorator = wrapper->classInfo()->decorator();
394 394 if (decorator) {
395 395 meta = decorator->metaObject();
396 396 }
397 397 }
398 398 if (meta) {
399 399 return PyString_FromFormat("%s Class (C++ wrapped by %s)", wrapper->classInfo()->className(), meta->className());
400 400 } else {
401 401 return PyString_FromFormat("%s Class (C++ unwrapped)", wrapper->classInfo()->className());
402 402 }
403 403 } else {
404 404 return PyString_FromFormat("%s Class", wrapper->classInfo()->className());
405 405 }
406 406 }
407 407
408 408 */
409 409
410 410 PyTypeObject PythonQtClassWrapper_Type = {
411 411 PyObject_HEAD_INIT(NULL)
412 412 0, /*ob_size*/
413 413 "PythonQt.PythonQtClassWrapper", /*tp_name*/
414 414 sizeof(PythonQtClassWrapper), /*tp_basicsize*/
415 415 0, /*tp_itemsize*/
416 416 0, /*tp_dealloc*/
417 417 0, /*tp_print*/
418 418 0, /*tp_getattr*/
419 419 0, /*tp_setattr*/
420 420 0, /*tp_compare*/
421 421 0, //PythonQtClassWrapper_repr, /*tp_repr*/
422 422 0, /*tp_as_number*/
423 423 0, /*tp_as_sequence*/
424 424 0, /*tp_as_mapping*/
425 425 0, /*tp_hash */
426 426 0, /*tp_call*/
427 427 0, /*tp_str*/
428 428 PythonQtClassWrapper_getattro, /*tp_getattro*/
429 429 PythonQtClassWrapper_setattro, /*tp_setattro*/
430 430 0, /*tp_as_buffer*/
431 431 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
432 432 0, /* tp_doc */
433 433 0, /* tp_traverse */
434 434 0, /* tp_clear */
435 435 0, /* tp_richcompare */
436 436 0, /* tp_weaklistoffset */
437 437 0, /* tp_iter */
438 438 0, /* tp_iternext */
439 439 0, /* tp_methods */
440 440 0, /* tp_members */
441 441 0, /* tp_getset */
442 442 0, /* tp_base */
443 443 0, /* tp_dict */
444 444 0, /* tp_descr_get */
445 445 0, /* tp_descr_set */
446 446 0, /* tp_dictoffset */
447 447 (initproc)PythonQtClassWrapper_init, /* tp_init */
448 448 PythonQtClassWrapper_alloc, /* tp_alloc */
449 449 0, /* tp_new */
450 450 0, /* tp_free */
451 451 };
452 452
453 453 //-------------------------------------------------------
454 454
Show file before | Show file after | Hide comments
@@ -1,77 +1,77
1 1 #ifndef _PYTHONQTCLASSWRAPPER_H
2 2 #define _PYTHONQTCLASSWRAPPER_H
3 3
4 4 /*
5 5 *
6 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
6 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
7 7 *
8 8 * This library is free software; you can redistribute it and/or
9 9 * modify it under the terms of the GNU Lesser General Public
10 10 * License as published by the Free Software Foundation; either
11 11 * version 2.1 of the License, or (at your option) any later version.
12 12 *
13 13 * This library is distributed in the hope that it will be useful,
14 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 16 * Lesser General Public License for more details.
17 17 *
18 18 * Further, this software is distributed without any warranty that it is
19 19 * free of the rightful claim of any third person regarding infringement
20 20 * or the like. Any license provided herein, whether implied or
21 21 * otherwise, applies only to this software file. Patent licenses, if
22 22 * any, provided herein do not apply to combinations of this program with
23 23 * other software, or any other product whatsoever.
24 24 *
25 25 * You should have received a copy of the GNU Lesser General Public
26 26 * License along with this library; if not, write to the Free Software
27 27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 28 *
29 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
29 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
30 30 * 28359 Bremen, Germany or:
31 31 *
32 32 * http://www.mevis.de
33 33 *
34 34 */
35 35
36 36 //----------------------------------------------------------------------------------
37 37 /*!
38 38 // \file PythonQtClassWrapper.h
39 39 // \author Florian Link
40 40 // \author Last changed by $Author: florian $
41 41 // \date 2006-05
42 42 */
43 43 //----------------------------------------------------------------------------------
44 44
45 45 #include <Python.h>
46 46
47 47 #include "PythonQtSystem.h"
48 48
49 49 #include "structmember.h"
50 50 #include "methodobject.h"
51 51 #include "compile.h"
52 52 #include "eval.h"
53 53 #include <QString>
54 54
55 55 class PythonQtClassInfo;
56 56
57 57 //! the type of the PythonQt class wrapper objects
58 58 extern PYTHONQT_EXPORT PyTypeObject PythonQtClassWrapper_Type;
59 59
60 60 //---------------------------------------------------------------
61 61 //! a Python wrapper object for PythonQt wrapped classes
62 62 //! which inherits from the Python type object to allow
63 63 //! deriving of wrapped CPP classes from Python.
64 64 typedef struct {
65 65 PyHeapTypeObject _base;
66 66
67 67 //! the additional class information that PythonQt stores for the CPP class
68 68 PythonQtClassInfo* _classInfo;
69 69
70 70 //! get the class info
71 71 PythonQtClassInfo* classInfo() { return _classInfo; }
72 72
73 73 } PythonQtClassWrapper;
74 74
75 75 //---------------------------------------------------------------
76 76
77 77 #endif
Show file before | Show file after | Hide comments
@@ -1,1228 +1,1228
1 1 /*
2 2 *
3 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
3 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
4 4 *
5 5 * This library is free software; you can redistribute it and/or
6 6 * modify it under the terms of the GNU Lesser General Public
7 7 * License as published by the Free Software Foundation; either
8 8 * version 2.1 of the License, or (at your option) any later version.
9 9 *
10 10 * This library is distributed in the hope that it will be useful,
11 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 13 * Lesser General Public License for more details.
14 14 *
15 15 * Further, this software is distributed without any warranty that it is
16 16 * free of the rightful claim of any third person regarding infringement
17 17 * or the like. Any license provided herein, whether implied or
18 18 * otherwise, applies only to this software file. Patent licenses, if
19 19 * any, provided herein do not apply to combinations of this program with
20 20 * other software, or any other product whatsoever.
21 21 *
22 22 * You should have received a copy of the GNU Lesser General Public
23 23 * License along with this library; if not, write to the Free Software
24 24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 25 *
26 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
26 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
27 27 * 28359 Bremen, Germany or:
28 28 *
29 29 * http://www.mevis.de
30 30 *
31 31 */
32 32
33 33 //----------------------------------------------------------------------------------
34 34 /*!
35 35 // \file PythonQtConversion.cpp
36 36 // \author Florian Link
37 37 // \author Last changed by $Author: florian $
38 38 // \date 2006-05
39 39 */
40 40 //----------------------------------------------------------------------------------
41 41
42 42 #include "PythonQtConversion.h"
43 43 #include "PythonQtVariants.h"
44 44 #include <QDateTime>
45 45 #include <QTime>
46 46 #include <QDate>
47 47
48 48 PythonQtValueStorage<qint64, 128> PythonQtConv::global_valueStorage;
49 49 PythonQtValueStorage<void*, 128> PythonQtConv::global_ptrStorage;
50 50 PythonQtValueStorage<QVariant, 32> PythonQtConv::global_variantStorage;
51 51
52 52 QHash<int, PythonQtConvertMetaTypeToPythonCB*> PythonQtConv::_metaTypeToPythonConverters;
53 53 QHash<int, PythonQtConvertPythonToMetaTypeCB*> PythonQtConv::_pythonToMetaTypeConverters;
54 54
55 55 PyObject* PythonQtConv::GetPyBool(bool val)
56 56 {
57 57 PyObject* r = val?Py_True:Py_False;
58 58 Py_INCREF(r);
59 59 return r;
60 60 }
61 61
62 62 PyObject* PythonQtConv::ConvertQtValueToPython(const PythonQtMethodInfo::ParameterInfo& info, const void* data) {
63 63 // is it an enum value?
64 64 if (info.enumWrapper) {
65 65 if (!info.isPointer) {
66 66 return PythonQtPrivate::createEnumValueInstance(info.enumWrapper, *((unsigned int*)data));
67 67 } else {
68 68 // we do not support pointers to enums (who needs them?)
69 69 Py_INCREF(Py_None);
70 70 return Py_None;
71 71 }
72 72 }
73 73
74 74 if (info.typeId == QMetaType::Void) {
75 75 Py_INCREF(Py_None);
76 76 return Py_None;
77 77 } else if (info.isPointer && (info.typeId == QMetaType::Char)) {
78 78 // a char ptr will probably be a null terminated string, so we support that:
79 79 return PyString_FromString(*((char**)data));
80 80 } else if ((info.typeId == PythonQtMethodInfo::Unknown || info.typeId >= QMetaType::User) &&
81 81 info.name.startsWith("QList<")) {
82 82 // it is a QList template:
83 83 QByteArray innerType = info.name.mid(6,info.name.length()-7);
84 84 if (innerType.endsWith("*")) {
85 85 innerType.truncate(innerType.length()-1);
86 86 QList<void*>* listPtr;
87 87 if (info.isPointer) {
88 88 listPtr = *((QList<void*>**)data);
89 89 } else {
90 90 listPtr = (QList<void*>*)data;
91 91 }
92 92 return ConvertQListOfPointerTypeToPythonList(listPtr, innerType);
93 93 }
94 94 }
95 95
96 96 if (info.typeId >= QMetaType::User) {
97 97 // if a converter is registered, we use is:
98 98 PythonQtConvertMetaTypeToPythonCB* converter = _metaTypeToPythonConverters.value(info.typeId);
99 99 if (converter) {
100 100 return (*converter)(data, info.typeId);
101 101 }
102 102 }
103 103
104 104 // special handling did not match, so we convert the usual way (either pointer or value version):
105 105 if (info.isPointer) {
106 106 // convert the pointer to a Python Object (we can handle ANY C++ object, in the worst case we just know the type and the pointer)
107 107 return PythonQt::priv()->wrapPtr(*((void**)data), info.name);
108 108 } else {
109 109 // handle values that are not yet handled and not pointers
110 110 return ConvertQtValueToPythonInternal(info.typeId, data);
111 111 }
112 112 }
113 113
114 114 PyObject* PythonQtConv::ConvertQtValueToPythonInternal(int type, const void* data) {
115 115 switch (type) {
116 116 case QMetaType::Void:
117 117 Py_INCREF(Py_None);
118 118 return Py_None;
119 119 case QMetaType::Char:
120 120 return PyInt_FromLong(*((char*)data));
121 121 case QMetaType::UChar:
122 122 return PyInt_FromLong(*((unsigned char*)data));
123 123 case QMetaType::Short:
124 124 return PyInt_FromLong(*((short*)data));
125 125 case QMetaType::UShort:
126 126 return PyInt_FromLong(*((unsigned short*)data));
127 127 case QMetaType::Long:
128 128 return PyInt_FromLong(*((long*)data));
129 129 case QMetaType::ULong:
130 130 // does not fit into simple int of python
131 131 return PyLong_FromUnsignedLong(*((unsigned long*)data));
132 132 case QMetaType::Bool:
133 133 return PythonQtConv::GetPyBool(*((bool*)data));
134 134 case QMetaType::Int:
135 135 return PyInt_FromLong(*((int*)data));
136 136 case QMetaType::UInt:
137 137 // does not fit into simple int of python
138 138 return PyLong_FromUnsignedLong(*((unsigned int*)data));
139 139 case QMetaType::QChar:
140 140 return PyInt_FromLong(*((short*)data));
141 141 case QMetaType::Float:
142 142 return PyFloat_FromDouble(*((float*)data));
143 143 case QMetaType::Double:
144 144 return PyFloat_FromDouble(*((double*)data));
145 145 case QMetaType::LongLong:
146 146 return PyLong_FromLongLong(*((qint64*)data));
147 147 case QMetaType::ULongLong:
148 148 return PyLong_FromUnsignedLongLong(*((quint64*)data));
149 149 // implicit conversion from QByteArray to str has been removed:
150 150 //case QMetaType::QByteArray: {
151 151 // QByteArray* v = (QByteArray*) data;
152 152 // return PyString_FromStringAndSize(*v, v->size());
153 153 // }
154 154 case QMetaType::QVariantMap:
155 155 return PythonQtConv::QVariantMapToPyObject(*((QVariantMap*)data));
156 156 case QMetaType::QVariantList:
157 157 return PythonQtConv::QVariantListToPyObject(*((QVariantList*)data));
158 158 case QMetaType::QString:
159 159 return PythonQtConv::QStringToPyObject(*((QString*)data));
160 160 case QMetaType::QStringList:
161 161 return PythonQtConv::QStringListToPyObject(*((QStringList*)data));
162 162
163 163 case PythonQtMethodInfo::Variant:
164 164 return PythonQtConv::QVariantToPyObject(*((QVariant*)data));
165 165 case QMetaType::QObjectStar:
166 166 case QMetaType::QWidgetStar:
167 167 return PythonQt::priv()->wrapQObject(*((QObject**)data));
168 168
169 169 default:
170 170 if (PythonQt::priv()->isPythonQtObjectPtrMetaId(type)) {
171 171 // special case, it is a PythonQtObjectPtr which contains a PyObject, take it directly:
172 172 PyObject* o = ((PythonQtObjectPtr*)data)->object();
173 173 Py_INCREF(o);
174 174 return o;
175 175 } else {
176 176 if (type > 0) {
177 177 // if the type is known, we can construct it via QMetaType::construct
178 178 void* newCPPObject = QMetaType::construct(type, data);
179 179 // XXX this could be optimized by using metatypeid directly
180 180 PythonQtInstanceWrapper* wrap = (PythonQtInstanceWrapper*)PythonQt::priv()->wrapPtr(newCPPObject, QMetaType::typeName(type));
181 181 wrap->_ownedByPythonQt = true;
182 182 wrap->_useQMetaTypeDestroy = true;
183 183 return (PyObject*)wrap;
184 184 }
185 185 std::cerr << "Unknown type that can not be converted to Python: " << type << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
186 186 }
187 187 }
188 188 Py_INCREF(Py_None);
189 189 return Py_None;
190 190 }
191 191
192 192 void* PythonQtConv::CreateQtReturnValue(const PythonQtMethodInfo::ParameterInfo& info) {
193 193 void* ptr = NULL;
194 194 if (info.isPointer) {
195 195 PythonQtValueStorage_ADD_VALUE(global_ptrStorage, void*, NULL, ptr);
196 196 } else if (info.enumWrapper) {
197 197 // create enum return value
198 198 PythonQtValueStorage_ADD_VALUE(PythonQtConv::global_valueStorage, long, 0, ptr);
199 199 } else {
200 200 switch (info.typeId) {
201 201 case QMetaType::Char:
202 202 case QMetaType::UChar:
203 203 case QMetaType::Short:
204 204 case QMetaType::UShort:
205 205 case QMetaType::Long:
206 206 case QMetaType::ULong:
207 207 case QMetaType::Bool:
208 208 case QMetaType::Int:
209 209 case QMetaType::UInt:
210 210 case QMetaType::QChar:
211 211 case QMetaType::Float:
212 212 case QMetaType::Double:
213 213 PythonQtValueStorage_ADD_VALUE(global_valueStorage, qint64, 0, ptr);
214 214 break;
215 215 case PythonQtMethodInfo::Variant:
216 216 PythonQtValueStorage_ADD_VALUE(global_variantStorage, QVariant, 0, ptr);
217 217 // return the ptr to the variant
218 218 break;
219 219 default:
220 220 if (info.typeId == PythonQtMethodInfo::Unknown) {
221 221 // check if we have a QList of pointers, which we can circumvent with a QList<void*>
222 222 if (info.name.startsWith("QList<")) {
223 223 QByteArray innerType = info.name.mid(6,info.name.length()-7);
224 224 if (innerType.endsWith("*")) {
225 225 static int id = QMetaType::type("QList<void*>");
226 226 PythonQtValueStorage_ADD_VALUE(global_variantStorage, QVariant, QVariant::Type(id), ptr);
227 227 // return the constData pointer that will be filled with the result value later on
228 228 ptr = (void*)((QVariant*)ptr)->constData();
229 229 }
230 230 }
231 231 }
232 232
233 233 if (!ptr && info.typeId!=PythonQtMethodInfo::Unknown) {
234 234 // everything else is stored in a QVariant, if we know the meta type...
235 235 PythonQtValueStorage_ADD_VALUE(global_variantStorage, QVariant, QVariant::Type(info.typeId), ptr);
236 236 // return the constData pointer that will be filled with the result value later on
237 237 ptr = (void*)((QVariant*)ptr)->constData();
238 238 }
239 239 }
240 240 }
241 241 return ptr;
242 242 }
243 243
244 244 void* PythonQtConv::castWrapperTo(PythonQtInstanceWrapper* wrapper, const QByteArray& className, bool& ok)
245 245 {
246 246 void* object;
247 247 if (wrapper->classInfo()->isCPPWrapper()) {
248 248 object = wrapper->_wrappedPtr;
249 249 } else {
250 250 QObject* tmp = wrapper->_obj;
251 251 object = tmp;
252 252 }
253 253 if (object) {
254 254 // if we can be upcasted to the given name, we pass the casted pointer in:
255 255 object = wrapper->classInfo()->castTo(object, className);
256 256 ok = object!=NULL;
257 257 } else {
258 258 // if it is a NULL ptr, we need to check if it inherits, so that we might pass the NULL ptr
259 259 ok = wrapper->classInfo()->inherits(className);
260 260 }
261 261 return object;
262 262 }
263 263
264 264 void* PythonQtConv::handlePythonToQtAutoConversion(int typeId, PyObject* obj, void* alreadyAllocatedCPPObject)
265 265 {
266 266 void* ptr = alreadyAllocatedCPPObject;
267 267
268 268 static int penId = QMetaType::type("QPen");
269 269 static int brushId = QMetaType::type("QBrush");
270 270 static int cursorId = QMetaType::type("QCursor");
271 271 static int colorId = QMetaType::type("QColor");
272 272 static PyObject* qtGlobalColorEnum = PythonQtClassInfo::findEnumWrapper("Qt::GlobalColor", NULL);
273 273 if (typeId == cursorId) {
274 274 static PyObject* qtCursorShapeEnum = PythonQtClassInfo::findEnumWrapper("Qt::CursorShape", NULL);
275 275 if ((PyObject*)obj->ob_type == qtCursorShapeEnum) {
276 276 Qt::CursorShape val = (Qt::CursorShape)PyInt_AS_LONG(obj);
277 277 if (!ptr) {
278 278 PythonQtValueStorage_ADD_VALUE(global_variantStorage, QVariant, QCursor(), ptr);
279 279 ptr = (void*)((QVariant*)ptr)->constData();
280 280 }
281 281 *((QCursor*)ptr) = QCursor(val);
282 282 return ptr;
283 283 }
284 284 } else if (typeId == penId) {
285 285 // brushes can be created from QColor and from Qt::GlobalColor (and from brushes, but that's the default)
286 286 static PyObject* qtColorClass = PythonQt::priv()->getClassInfo("QColor")->pythonQtClassWrapper();
287 287 if ((PyObject*)obj->ob_type == qtGlobalColorEnum) {
288 288 Qt::GlobalColor val = (Qt::GlobalColor)PyInt_AS_LONG(obj);
289 289 if (!ptr) {
290 290 PythonQtValueStorage_ADD_VALUE(global_variantStorage, QVariant, QPen(), ptr);
291 291 ptr = (void*)((QVariant*)ptr)->constData();
292 292 }
293 293 *((QPen*)ptr) = QPen(QColor(val));
294 294 return ptr;
295 295 } else if ((PyObject*)obj->ob_type == qtColorClass) {
296 296 if (!ptr) {
297 297 PythonQtValueStorage_ADD_VALUE(global_variantStorage, QVariant, QPen(), ptr);
298 298 ptr = (void*)((QVariant*)ptr)->constData();
299 299 }
300 300 *((QPen*)ptr) = QPen(*((QColor*)((PythonQtInstanceWrapper*)obj)->_wrappedPtr));
301 301 return ptr;
302 302 }
303 303 } else if (typeId == brushId) {
304 304 // brushes can be created from QColor and from Qt::GlobalColor (and from brushes, but that's the default)
305 305 static PyObject* qtColorClass = PythonQt::priv()->getClassInfo("QColor")->pythonQtClassWrapper();
306 306 if ((PyObject*)obj->ob_type == qtGlobalColorEnum) {
307 307 Qt::GlobalColor val = (Qt::GlobalColor)PyInt_AS_LONG(obj);
308 308 if (!ptr) {
309 309 PythonQtValueStorage_ADD_VALUE(global_variantStorage, QVariant, QBrush(), ptr);
310 310 ptr = (void*)((QVariant*)ptr)->constData();
311 311 }
312 312 *((QBrush*)ptr) = QBrush(QColor(val));
313 313 return ptr;
314 314 } else if ((PyObject*)obj->ob_type == qtColorClass) {
315 315 if (!ptr) {
316 316 PythonQtValueStorage_ADD_VALUE(global_variantStorage, QVariant, QBrush(), ptr);
317 317 ptr = (void*)((QVariant*)ptr)->constData();
318 318 }
319 319 *((QBrush*)ptr) = QBrush(*((QColor*)((PythonQtInstanceWrapper*)obj)->_wrappedPtr));
320 320 return ptr;
321 321 }
322 322 } else if (typeId == colorId) {
323 323 // colors can be created from Qt::GlobalColor (and from colors, but that's the default)
324 324 if ((PyObject*)obj->ob_type == qtGlobalColorEnum) {
325 325 Qt::GlobalColor val = (Qt::GlobalColor)PyInt_AS_LONG(obj);
326 326 if (!ptr) {
327 327 PythonQtValueStorage_ADD_VALUE(global_variantStorage, QVariant, QColor(), ptr);
328 328 ptr = (void*)((QVariant*)ptr)->constData();
329 329 }
330 330 *((QColor*)ptr) = QColor(val);
331 331 return ptr;
332 332 }
333 333 }
334 334 return NULL;
335 335 }
336 336
337 337 void* PythonQtConv::ConvertPythonToQt(const PythonQtMethodInfo::ParameterInfo& info, PyObject* obj, bool strict, PythonQtClassInfo* /*classInfo*/, void* alreadyAllocatedCPPObject)
338 338 {
339 339 bool ok = false;
340 340 void* ptr = NULL;
341 341
342 342 // autoconversion of QPen/QBrush/QCursor/QColor from different type
343 343 if (!info.isPointer && !strict) {
344 344 ptr = handlePythonToQtAutoConversion(info.typeId, obj, alreadyAllocatedCPPObject);
345 345 if (ptr) {
346 346 return ptr;
347 347 }
348 348 }
349 349
350 350 if (PyObject_TypeCheck(obj, &PythonQtInstanceWrapper_Type) && info.typeId != PythonQtMethodInfo::Variant) {
351 351 // if we have a Qt wrapper object and if we do not need a QVariant, we do the following:
352 352 // (the Variant case is handled below in a switch)
353 353
354 354 // a C++ wrapper (can be passed as pointer or reference)
355 355 PythonQtInstanceWrapper* wrap = (PythonQtInstanceWrapper*)obj;
356 356 void* object = castWrapperTo(wrap, info.name, ok);
357 357 if (ok) {
358 358 if (info.isPointer) {
359 359 // store the wrapped pointer in an extra pointer and let ptr point to the extra pointer
360 360 PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_ptrStorage, void*, object, ptr);
361 361 } else {
362 362 // store the wrapped pointer directly, since we are a reference
363 363 ptr = object;
364 364 }
365 365 } else {
366 366 // not matching
367 367 }
368 368 } else if (info.isPointer) {
369 369 // a pointer
370 370 if (info.typeId == QMetaType::Char || info.typeId == QMetaType::UChar)
371 371 {
372 372 QString str = PyObjGetString(obj, strict, ok);
373 373 if (ok) {
374 374 void* ptr2 = NULL;
375 375 PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_variantStorage, QVariant, QVariant(str.toUtf8()), ptr2);
376 376 PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_ptrStorage, void*, (((QByteArray*)((QVariant*)ptr2)->constData())->data()), ptr);
377 377 }
378 378 } else if (info.name == "PyObject") {
379 379 // handle low level PyObject directly
380 380 PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_ptrStorage, void*, obj, ptr);
381 381 } else if (obj == Py_None) {
382 382 // None is treated as a NULL ptr
383 383 PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_ptrStorage, void*, NULL, ptr);
384 384 } else {
385 385 // if we are not strict, we try if we are passed a 0 integer
386 386 if (!strict) {
387 387 bool ok;
388 388 int value = PyObjGetInt(obj, true, ok);
389 389 if (ok && value==0) {
390 390 // TODOXXX is this wise? or should it be expected from the programmer to use None?
391 391 PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_ptrStorage, void*, NULL, ptr);
392 392 }
393 393 }
394 394 }
395 395 } else {
396 396 // not a pointer
397 397 switch (info.typeId) {
398 398 case QMetaType::Char:
399 399 {
400 400 int val = PyObjGetInt(obj, strict, ok);
401 401 if (ok) {
402 402 PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, char, val, ptr);
403 403 }
404 404 }
405 405 break;
406 406 case QMetaType::UChar:
407 407 {
408 408 int val = PyObjGetInt(obj, strict, ok);
409 409 if (ok) {
410 410 PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, unsigned char, val, ptr);
411 411 }
412 412 }
413 413 break;
414 414 case QMetaType::Short:
415 415 {
416 416 int val = PyObjGetInt(obj, strict, ok);
417 417 if (ok) {
418 418 PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, short, val, ptr);
419 419 }
420 420 }
421 421 break;
422 422 case QMetaType::UShort:
423 423 {
424 424 int val = PyObjGetInt(obj, strict, ok);
425 425 if (ok) {
426 426 PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, unsigned short, val, ptr);
427 427 }
428 428 }
429 429 break;
430 430 case QMetaType::Long:
431 431 {
432 432 long val = (long)PyObjGetLongLong(obj, strict, ok);
433 433 if (ok) {
434 434 PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, long, val, ptr);
435 435 }
436 436 }
437 437 break;
438 438 case QMetaType::ULong:
439 439 {
440 440 unsigned long val = (unsigned long)PyObjGetLongLong(obj, strict, ok);
441 441 if (ok) {
442 442 PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, unsigned long, val, ptr);
443 443 }
444 444 }
445 445 break;
446 446 case QMetaType::Bool:
447 447 {
448 448 bool val = PyObjGetBool(obj, strict, ok);
449 449 if (ok) {
450 450 PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, bool, val, ptr);
451 451 }
452 452 }
453 453 break;
454 454 case QMetaType::Int:
455 455 {
456 456 int val = PyObjGetInt(obj, strict, ok);
457 457 if (ok) {
458 458 PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, int, val, ptr);
459 459 }
460 460 }
461 461 break;
462 462 case QMetaType::UInt:
463 463 {
464 464 unsigned int val = (unsigned int)PyObjGetLongLong(obj, strict, ok);
465 465 if (ok) {
466 466 PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, unsigned int, val, ptr);
467 467 }
468 468 }
469 469 break;
470 470 case QMetaType::QChar:
471 471 {
472 472 int val = PyObjGetInt(obj, strict, ok);
473 473 if (ok) {
474 474 PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, short, val, ptr);
475 475 }
476 476 }
477 477 break;
478 478 case QMetaType::Float:
479 479 {
480 480 float val = (float)PyObjGetDouble(obj, strict, ok);
481 481 if (ok) {
482 482 PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, float, val, ptr);
483 483 }
484 484 }
485 485 break;
486 486 case QMetaType::Double:
487 487 {
488 488 double val = (double)PyObjGetDouble(obj, strict, ok);
489 489 if (ok) {
490 490 PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, double, val, ptr);
491 491 }
492 492 }
493 493 break;
494 494 case QMetaType::LongLong:
495 495 {
496 496 qint64 val = PyObjGetLongLong(obj, strict, ok);
497 497 if (ok) {
498 498 PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, qint64, val, ptr);
499 499 }
500 500 }
501 501 break;
502 502 case QMetaType::ULongLong:
503 503 {
504 504 quint64 val = PyObjGetULongLong(obj, strict, ok);
505 505 if (ok) {
506 506 PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, quint64, val, ptr);
507 507 }
508 508 }
509 509 break;
510 510 case QMetaType::QByteArray:
511 511 {
512 512 QByteArray bytes = PyObjGetBytes(obj, strict, ok);
513 513 if (ok) {
514 514 PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_variantStorage, QVariant, QVariant(bytes), ptr);
515 515 ptr = (void*)((QVariant*)ptr)->constData();
516 516 }
517 517 }
518 518 break;
519 519 case QMetaType::QString:
520 520 {
521 521 QString str = PyObjGetString(obj, strict, ok);
522 522 if (ok) {
523 523 PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_variantStorage, QVariant, QVariant(str), ptr);
524 524 ptr = (void*)((QVariant*)ptr)->constData();
525 525 }
526 526 }
527 527 break;
528 528 case QMetaType::QStringList:
529 529 {
530 530 QStringList l = PyObjToStringList(obj, strict, ok);
531 531 if (ok) {
532 532 PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_variantStorage, QVariant, QVariant(l), ptr);
533 533 ptr = (void*)((QVariant*)ptr)->constData();
534 534 }
535 535 }
536 536 break;
537 537
538 538 case PythonQtMethodInfo::Variant:
539 539 {
540 540 QVariant v = PyObjToQVariant(obj);
541 541 // the only case where conversion can fail it None and we want to pass that to, e.g. setProperty(),
542 542 // so we do not check v.isValid() here
543 543 PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_variantStorage, QVariant, v, ptr);
544 544 }
545 545 break;
546 546 default:
547 547 {
548 548 // check for enum case
549 549 if (info.enumWrapper) {
550 550 unsigned int val;
551 551 ok = false;
552 552 if ((PyObject*)obj->ob_type == info.enumWrapper) {
553 553 // we have a exact enum type match:
554 554 val = PyInt_AS_LONG(obj);
555 555 ok = true;
556 556 } else if (!strict) {
557 557 // we try to get any integer, when not being strict. If we are strict, integers are not wanted because
558 558 // we want an integer overload to be taken first!
559 559 val = (unsigned int)PyObjGetLongLong(obj, false, ok);
560 560 }
561 561 if (ok) {
562 562 PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, unsigned int, val, ptr);
563 563 return ptr;
564 564 } else {
565 565 return NULL;
566 566 }
567 567 }
568 568
569 569 if (info.typeId == PythonQtMethodInfo::Unknown || info.typeId >= QMetaType::User) {
570 570 // check for QList<AnyPtr*> case, where we will use a QList<void*> QVariant
571 571 if (info.name.startsWith("QList<")) {
572 572 QByteArray innerType = info.name.mid(6,info.name.length()-7);
573 573 if (innerType.endsWith("*")) {
574 574 innerType.truncate(innerType.length()-1);
575 575 static int id = QMetaType::type("QList<void*>");
576 576 if (!alreadyAllocatedCPPObject) {
577 577 PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_variantStorage, QVariant, QVariant::Type(id), ptr);
578 578 ptr = (void*)((QVariant*)ptr)->constData();
579 579 } else {
580 580 ptr = alreadyAllocatedCPPObject;
581 581 }
582 582 ok = ConvertPythonListToQListOfPointerType(obj, (QList<void*>*)ptr, innerType, strict);
583 583 if (ok) {
584 584 return ptr;
585 585 } else {
586 586 return NULL;
587 587 }
588 588 }
589 589 }
590 590 }
591 591
592 592 // We only do this for registered type > QMetaType::User for performance reasons.
593 593 if (info.typeId >= QMetaType::User) {
594 594 // Maybe we have a special converter that is registered for that type:
595 595 PythonQtConvertPythonToMetaTypeCB* converter = _pythonToMetaTypeConverters.value(info.typeId);
596 596 if (converter) {
597 597 if (!alreadyAllocatedCPPObject) {
598 598 // create a new empty variant of concrete type:
599 599 PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_variantStorage, QVariant, QVariant::Type(info.typeId), ptr);
600 600 ptr = (void*)((QVariant*)ptr)->constData();
601 601 } else {
602 602 ptr = alreadyAllocatedCPPObject;
603 603 }
604 604 // now call the converter, passing the internal object of the variant
605 605 ok = (*converter)(obj, ptr, info.typeId, strict);
606 606 if (ok) {
607 607 return ptr;
608 608 } else {
609 609 return NULL;
610 610 }
611 611 }
612 612 }
613 613 // if no type id is available, conversion to a QVariant makes no sense/is not possible
614 614 if (info.typeId != PythonQtMethodInfo::Unknown) {
615 615 // for all other types, we use the same qvariant conversion and pass out the constData of the variant:
616 616 QVariant v = PyObjToQVariant(obj, info.typeId);
617 617 if (v.isValid()) {
618 618 PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_variantStorage, QVariant, v, ptr);
619 619 ptr = (void*)((QVariant*)ptr)->constData();
620 620 }
621 621 }
622 622 }
623 623 }
624 624 }
625 625 return ptr;
626 626 }
627 627
628 628
629 629 QStringList PythonQtConv::PyObjToStringList(PyObject* val, bool strict, bool& ok) {
630 630 QStringList v;
631 631 ok = false;
632 632 // if we are strict, we do not want to convert a string to a stringlist
633 633 // (strings in python are detected to be sequences)
634 634 if (strict &&
635 635 (val->ob_type == &PyString_Type ||
636 636 PyUnicode_Check(val))) {
637 637 ok = false;
638 638 return v;
639 639 }
640 640 if (PySequence_Check(val)) {
641 641 int count = PySequence_Size(val);
642 642 for (int i = 0;i<count;i++) {
643 643 PyObject* value = PySequence_GetItem(val,i);
644 644 v.append(PyObjGetString(value,false,ok));
645 645 }
646 646 ok = true;
647 647 }
648 648 return v;
649 649 }
650 650
651 651 QString PythonQtConv::PyObjGetRepresentation(PyObject* val)
652 652 {
653 653 QString r;
654 654 PyObject* str = PyObject_Repr(val);
655 655 if (str) {
656 656 r = QString(PyString_AS_STRING(str));
657 657 Py_DECREF(str);
658 658 }
659 659 return r;
660 660 }
661 661
662 662 QString PythonQtConv::PyObjGetString(PyObject* val, bool strict, bool& ok) {
663 663 QString r;
664 664 ok = true;
665 665 if (val->ob_type == &PyString_Type) {
666 666 r = QString(PyString_AS_STRING(val));
667 667 } else if (PyUnicode_Check(val)) {
668 668 #ifdef WIN32
669 669 r = QString::fromUtf16(PyUnicode_AS_UNICODE(val));
670 670 #else
671 671 PyObject *ptmp = PyUnicode_AsUTF8String(val);
672 672 if(ptmp) {
673 673 r = QString::fromUtf8(PyString_AS_STRING(ptmp));
674 674 Py_DECREF(ptmp);
675 675 }
676 676 #endif
677 677 } else if (!strict) {
678 678 // EXTRA: could also use _Unicode, but why should we?
679 679 PyObject* str = PyObject_Str(val);
680 680 if (str) {
681 681 r = QString(PyString_AS_STRING(str));
682 682 Py_DECREF(str);
683 683 } else {
684 684 ok = false;
685 685 }
686 686 } else {
687 687 ok = false;
688 688 }
689 689 return r;
690 690 }
691 691
692 692 QByteArray PythonQtConv::PyObjGetBytes(PyObject* val, bool /*strict*/, bool& ok) {
693 693 // TODO: support buffer objects in general
694 694 QByteArray r;
695 695 ok = true;
696 696 if (val->ob_type == &PyString_Type) {
697 697 long size = PyString_GET_SIZE(val);
698 698 r = QByteArray(PyString_AS_STRING(val), size);
699 699 } else {
700 700 ok = false;
701 701 }
702 702 return r;
703 703 }
704 704
705 705 bool PythonQtConv::PyObjGetBool(PyObject* val, bool strict, bool &ok) {
706 706 bool d = false;
707 707 ok = false;
708 708 if (val == Py_False) {
709 709 d = false;
710 710 ok = true;
711 711 } else if (val == Py_True) {
712 712 d = true;
713 713 ok = true;
714 714 } else if (!strict) {
715 715 d = PyObjGetInt(val, false, ok)!=0;
716 716 ok = true;
717 717 }
718 718 return d;
719 719 }
720 720
721 721 int PythonQtConv::PyObjGetInt(PyObject* val, bool strict, bool &ok) {
722 722 int d = 0;
723 723 ok = true;
724 724 if (val->ob_type == &PyInt_Type) {
725 725 d = PyInt_AS_LONG(val);
726 726 } else if (!strict) {
727 727 if (PyObject_TypeCheck(val, &PyInt_Type)) {
728 728 // support for derived int classes, e.g. for our enums
729 729 d = PyInt_AS_LONG(val);
730 730 } else if (val->ob_type == &PyFloat_Type) {
731 731 d = floor(PyFloat_AS_DOUBLE(val));
732 732 } else if (val->ob_type == &PyLong_Type) {
733 733 // handle error on overflow!
734 734 d = PyLong_AsLong(val);
735 735 } else if (val == Py_False) {
736 736 d = 0;
737 737 } else if (val == Py_True) {
738 738 d = 1;
739 739 } else {
740 740 ok = false;
741 741 }
742 742 } else {
743 743 ok = false;
744 744 }
745 745 return d;
746 746 }
747 747
748 748 qint64 PythonQtConv::PyObjGetLongLong(PyObject* val, bool strict, bool &ok) {
749 749 qint64 d = 0;
750 750 ok = true;
751 751 if (val->ob_type == &PyInt_Type) {
752 752 d = PyInt_AS_LONG(val);
753 753 } else if (val->ob_type == &PyLong_Type) {
754 754 d = PyLong_AsLongLong(val);
755 755 } else if (!strict) {
756 756 if (PyObject_TypeCheck(val, &PyInt_Type)) {
757 757 // support for derived int classes, e.g. for our enums
758 758 d = PyInt_AS_LONG(val);
759 759 } else if (val->ob_type == &PyFloat_Type) {
760 760 d = floor(PyFloat_AS_DOUBLE(val));
761 761 } else if (val == Py_False) {
762 762 d = 0;
763 763 } else if (val == Py_True) {
764 764 d = 1;
765 765 } else {
766 766 ok = false;
767 767 }
768 768 } else {
769 769 ok = false;
770 770 }
771 771 return d;
772 772 }
773 773
774 774 quint64 PythonQtConv::PyObjGetULongLong(PyObject* val, bool strict, bool &ok) {
775 775 quint64 d = 0;
776 776 ok = true;
777 777 if (PyObject_TypeCheck(val, &PyInt_Type)) {
778 778 d = PyInt_AS_LONG(val);
779 779 } else if (val->ob_type == &PyLong_Type) {
780 780 d = PyLong_AsLongLong(val);
781 781 } else if (!strict) {
782 782 if (PyObject_TypeCheck(val, &PyInt_Type)) {
783 783 // support for derived int classes, e.g. for our enums
784 784 d = PyInt_AS_LONG(val);
785 785 } else if (val->ob_type == &PyFloat_Type) {
786 786 d = floor(PyFloat_AS_DOUBLE(val));
787 787 } else if (val == Py_False) {
788 788 d = 0;
789 789 } else if (val == Py_True) {
790 790 d = 1;
791 791 } else {
792 792 ok = false;
793 793 }
794 794 } else {
795 795 ok = false;
796 796 }
797 797 return d;
798 798 }
799 799
800 800 double PythonQtConv::PyObjGetDouble(PyObject* val, bool strict, bool &ok) {
801 801 double d = 0;
802 802 ok = true;
803 803 if (val->ob_type == &PyFloat_Type) {
804 804 d = PyFloat_AS_DOUBLE(val);
805 805 } else if (!strict) {
806 806 if (PyObject_TypeCheck(val, &PyInt_Type)) {
807 807 d = PyInt_AS_LONG(val);
808 808 } else if (val->ob_type == &PyLong_Type) {
809 809 d = PyLong_AsLong(val);
810 810 } else if (val == Py_False) {
811 811 d = 0;
812 812 } else if (val == Py_True) {
813 813 d = 1;
814 814 } else {
815 815 ok = false;
816 816 }
817 817 } else {
818 818 ok = false;
819 819 }
820 820 return d;
821 821 }
822 822
823 823 QVariant PythonQtConv::PyObjToQVariant(PyObject* val, int type)
824 824 {
825 825 QVariant v;
826 826 bool ok = true;
827 827
828 828 if (type==-1) {
829 829 // no special type requested
830 830 if (val->ob_type==&PyString_Type || val->ob_type==&PyUnicode_Type) {
831 831 type = QVariant::String;
832 832 } else if (PyObject_TypeCheck(val, &PyInt_Type)) {
833 833 type = QVariant::Int;
834 834 } else if (val->ob_type==&PyLong_Type) {
835 835 type = QVariant::LongLong;
836 836 } else if (val->ob_type==&PyFloat_Type) {
837 837 type = QVariant::Double;
838 838 } else if (val == Py_False || val == Py_True) {
839 839 type = QVariant::Bool;
840 840 } else if (PyObject_TypeCheck(val, &PythonQtInstanceWrapper_Type)) {
841 841 PythonQtInstanceWrapper* wrap = (PythonQtInstanceWrapper*)val;
842 842 // c++ wrapper, check if the class names of the c++ objects match
843 843 if (wrap->classInfo()->isCPPWrapper()) {
844 844 if (wrap->classInfo()->metaTypeId()>0) {
845 845 // construct a new variant from the C++ object if it has a meta type (this will COPY the object!)
846 846 v = QVariant(wrap->classInfo()->metaTypeId(), wrap->_wrappedPtr);
847 847 } else {
848 848 // TODOXXX we could as well check if there is a registered meta type for "classname*", so that we may pass
849 849 // the pointer here...
850 850 // is this worth anything? we loose the knowledge of the cpp object type
851 851 v = qVariantFromValue(wrap->_wrappedPtr);
852 852 }
853 853 } else {
854 854 // this gives us a QObject pointer
855 855 QObject* myObject = wrap->_obj;
856 856 v = qVariantFromValue(myObject);
857 857 }
858 858 return v;
859 859 } else if (val->ob_type==&PyDict_Type) {
860 860 type = QVariant::Map;
861 861 } else if (val->ob_type==&PyList_Type || val->ob_type==&PyTuple_Type || PySequence_Check(val)) {
862 862 type = QVariant::List;
863 863 } else if (val == Py_None) {
864 864 // none is invalid
865 865 type = QVariant::Invalid;
866 866 } else {
867 867 // this used to be:
868 868 // type = QVariant::String;
869 869 // but now we want to transport the Python Objects directly:
870 870 PythonQtObjectPtr o(val);
871 871 v = qVariantFromValue(o);
872 872 return v;
873 873 }
874 874 }
875 875 // special type request:
876 876 switch (type) {
877 877 case QVariant::Invalid:
878 878 return v;
879 879 break;
880 880 case QVariant::Int:
881 881 {
882 882 int d = PyObjGetInt(val, false, ok);
883 883 if (ok) return QVariant(d);
884 884 }
885 885 break;
886 886 case QVariant::UInt:
887 887 {
888 888 int d = PyObjGetInt(val, false,ok);
889 889 if (ok) v = QVariant((unsigned int)d);
890 890 }
891 891 break;
892 892 case QVariant::Bool:
893 893 {
894 894 int d = PyObjGetBool(val,false,ok);
895 895 if (ok) v = QVariant((bool)(d!=0));
896 896 }
897 897 break;
898 898 case QVariant::Double:
899 899 {
900 900 double d = PyObjGetDouble(val,false,ok);
901 901 if (ok) v = QVariant(d);
902 902 break;
903 903 }
904 904 case QMetaType::Float:
905 905 {
906 906 float d = (float) PyObjGetDouble(val,false,ok);
907 907 if (ok) v = qVariantFromValue(d);
908 908 break;
909 909 }
910 910 case QMetaType::Long:
911 911 {
912 912 long d = (long) PyObjGetLongLong(val,false,ok);
913 913 if (ok) v = qVariantFromValue(d);
914 914 break;
915 915 }
916 916 case QMetaType::ULong:
917 917 {
918 918 unsigned long d = (unsigned long) PyObjGetLongLong(val,false,ok);
919 919 if (ok) v = qVariantFromValue(d);
920 920 break;
921 921 }
922 922 case QMetaType::LongLong:
923 923 {
924 924 qint64 d = PyObjGetLongLong(val, false, ok);
925 925 if (ok) v = qVariantFromValue(d);
926 926 }
927 927 break;
928 928 case QMetaType::ULongLong:
929 929 {
930 930 quint64 d = PyObjGetULongLong(val, false, ok);
931 931 if (ok) v = qVariantFromValue(d);
932 932 }
933 933 break;
934 934 case QMetaType::Short:
935 935 {
936 936 short d = (short) PyObjGetInt(val,false,ok);
937 937 if (ok) v = qVariantFromValue(d);
938 938 break;
939 939 }
940 940 case QMetaType::UShort:
941 941 {
942 942 unsigned short d = (unsigned short) PyObjGetInt(val,false,ok);
943 943 if (ok) v = qVariantFromValue(d);
944 944 break;
945 945 }
946 946 case QMetaType::Char:
947 947 {
948 948 char d = (char) PyObjGetInt(val,false,ok);
949 949 if (ok) v = qVariantFromValue(d);
950 950 break;
951 951 }
952 952 case QMetaType::UChar:
953 953 {
954 954 unsigned char d = (unsigned char) PyObjGetInt(val,false,ok);
955 955 if (ok) v = qVariantFromValue(d);
956 956 break;
957 957 }
958 958
959 959 case QVariant::ByteArray:
960 960 case QVariant::String:
961 961 {
962 962 bool ok;
963 963 v = QVariant(PyObjGetString(val, false, ok));
964 964 }
965 965 break;
966 966
967 967 // these are important for MeVisLab
968 968 case QVariant::Map:
969 969 {
970 970 if (PyMapping_Check(val)) {
971 971 QMap<QString,QVariant> map;
972 972 PyObject* items = PyMapping_Items(val);
973 973 if (items) {
974 974 int count = PyList_Size(items);
975 975 PyObject* value;
976 976 PyObject* key;
977 977 PyObject* tuple;
978 978 for (int i = 0;i<count;i++) {
979 979 tuple = PyList_GetItem(items,i);
980 980 key = PyTuple_GetItem(tuple, 0);
981 981 value = PyTuple_GetItem(tuple, 1);
982 982 map.insert(PyObjGetString(key), PyObjToQVariant(value,-1));
983 983 }
984 984 Py_DECREF(items);
985 985 v = map;
986 986 }
987 987 }
988 988 }
989 989 break;
990 990 case QVariant::List:
991 991 if (PySequence_Check(val)) {
992 992 QVariantList list;
993 993 int count = PySequence_Size(val);
994 994 PyObject* value;
995 995 for (int i = 0;i<count;i++) {
996 996 value = PySequence_GetItem(val,i);
997 997 list.append(PyObjToQVariant(value, -1));
998 998 }
999 999 v = list;
1000 1000 }
1001 1001 break;
1002 1002 case QVariant::StringList:
1003 1003 {
1004 1004 bool ok;
1005 1005 QStringList l = PyObjToStringList(val, false, ok);
1006 1006 if (ok) {
1007 1007 v = l;
1008 1008 }
1009 1009 }
1010 1010 break;
1011 1011
1012 1012 default:
1013 1013 if (PyObject_TypeCheck(val, &PythonQtInstanceWrapper_Type)) {
1014 1014 PythonQtInstanceWrapper* wrap = (PythonQtInstanceWrapper*)val;
1015 1015 if (wrap->classInfo()->isCPPWrapper() && wrap->classInfo()->metaTypeId() == type) {
1016 1016 // construct a new variant from the C++ object if it has the same meta type
1017 1017 v = QVariant(type, wrap->_wrappedPtr);
1018 1018 } else {
1019 1019 v = QVariant();
1020 1020 }
1021 1021 } else {
1022 1022 v = QVariant();
1023 1023 }
1024 1024 }
1025 1025 return v;
1026 1026 }
1027 1027
1028 1028 PyObject* PythonQtConv::QStringToPyObject(const QString& str)
1029 1029 {
1030 1030 if (str.isNull()) {
1031 1031 return PyString_FromString("");
1032 1032 } else {
1033 1033 #ifdef WIN32
1034 1034 // return PyString_FromString(str.toLatin1().data());
1035 1035 return PyUnicode_FromUnicode(str.utf16(), str.length());
1036 1036 #else
1037 1037 return PyUnicode_DecodeUTF16((const char*)str.utf16(), str.length()*2, NULL, NULL);
1038 1038 #endif
1039 1039 }
1040 1040 }
1041 1041
1042 1042 PyObject* PythonQtConv::QStringListToPyObject(const QStringList& list)
1043 1043 {
1044 1044 PyObject* result = PyTuple_New(list.count());
1045 1045 int i = 0;
1046 1046 QString str;
1047 1047 foreach (str, list) {
1048 1048 PyTuple_SET_ITEM(result, i, PythonQtConv::QStringToPyObject(str));
1049 1049 i++;
1050 1050 }
1051 1051 // why is the error state bad after this?
1052 1052 PyErr_Clear();
1053 1053 return result;
1054 1054 }
1055 1055
1056 1056 PyObject* PythonQtConv::QStringListToPyList(const QStringList& list)
1057 1057 {
1058 1058 PyObject* result = PyList_New(list.count());
1059 1059 int i = 0;
1060 1060 for (QStringList::ConstIterator it = list.begin(); it!=list.end(); ++it) {
1061 1061 PyList_SET_ITEM(result, i, PythonQtConv::QStringToPyObject(*it));
1062 1062 i++;
1063 1063 }
1064 1064 return result;
1065 1065 }
1066 1066
1067 1067 PyObject* PythonQtConv::QVariantToPyObject(const QVariant& v)
1068 1068 {
1069 1069 return ConvertQtValueToPythonInternal(v.userType(), (void*)v.constData());
1070 1070 }
1071 1071
1072 1072 PyObject* PythonQtConv::QVariantMapToPyObject(const QVariantMap& m) {
1073 1073 PyObject* result = PyDict_New();
1074 1074 QVariantMap::const_iterator t = m.constBegin();
1075 1075 PyObject* key;
1076 1076 PyObject* val;
1077 1077 for (;t!=m.end();t++) {
1078 1078 key = QStringToPyObject(t.key());
1079 1079 val = QVariantToPyObject(t.value());
1080 1080 PyDict_SetItem(result, key, val);
1081 1081 Py_DECREF(key);
1082 1082 Py_DECREF(val);
1083 1083 }
1084 1084 return result;
1085 1085 }
1086 1086
1087 1087 PyObject* PythonQtConv::QVariantListToPyObject(const QVariantList& l) {
1088 1088 PyObject* result = PyTuple_New(l.count());
1089 1089 int i = 0;
1090 1090 QVariant v;
1091 1091 foreach (v, l) {
1092 1092 PyTuple_SET_ITEM(result, i, PythonQtConv::QVariantToPyObject(v));
1093 1093 i++;
1094 1094 }
1095 1095 // why is the error state bad after this?
1096 1096 PyErr_Clear();
1097 1097 return result;
1098 1098 }
1099 1099
1100 1100 PyObject* PythonQtConv::ConvertQListOfPointerTypeToPythonList(QList<void*>* list, const QByteArray& typeName)
1101 1101 {
1102 1102 PyObject* result = PyTuple_New(list->count());
1103 1103 int i = 0;
1104 1104 foreach (void* value, *list) {
1105 1105 PyTuple_SET_ITEM(result, i, PythonQt::priv()->wrapPtr(value, typeName));
1106 1106 i++;
1107 1107 }
1108 1108 return result;
1109 1109 }
1110 1110
1111 1111 bool PythonQtConv::ConvertPythonListToQListOfPointerType(PyObject* obj, QList<void*>* list, const QByteArray& type, bool /*strict*/)
1112 1112 {
1113 1113 bool result = false;
1114 1114 if (PySequence_Check(obj)) {
1115 1115 result = true;
1116 1116 int count = PySequence_Size(obj);
1117 1117 PyObject* value;
1118 1118 for (int i = 0;i<count;i++) {
1119 1119 value = PySequence_GetItem(obj,i);
1120 1120 if (PyObject_TypeCheck(value, &PythonQtInstanceWrapper_Type)) {
1121 1121 PythonQtInstanceWrapper* wrap = (PythonQtInstanceWrapper*)value;
1122 1122 bool ok;
1123 1123 void* object = castWrapperTo(wrap, type, ok);
1124 1124 if (ok) {
1125 1125 list->append(object);
1126 1126 } else {
1127 1127 result = false;
1128 1128 break;
1129 1129 }
1130 1130 }
1131 1131 }
1132 1132 }
1133 1133 return result;
1134 1134 }
1135 1135
1136 1136 int PythonQtConv::getInnerTemplateMetaType(const QByteArray& typeName)
1137 1137 {
1138 1138 int idx = typeName.indexOf("<");
1139 1139 if (idx>0) {
1140 1140 int idx2 = typeName.indexOf(">");
1141 1141 if (idx2>0) {
1142 1142 QByteArray innerType = typeName.mid(idx+1,idx2-idx-1);
1143 1143 return QMetaType::type(innerType.constData());
1144 1144 }
1145 1145 }
1146 1146 return QMetaType::Void;
1147 1147 }
1148 1148
1149 1149
1150 1150 QString PythonQtConv::CPPObjectToString(int type, const void* data) {
1151 1151 QString r;
1152 1152 switch (type) {
1153 1153 case QVariant::Size: {
1154 1154 const QSize* s = static_cast<const QSize*>(data);
1155 1155 r = QString::number(s->width()) + ", " + QString::number(s->height());
1156 1156 }
1157 1157 break;
1158 1158 case QVariant::SizeF: {
1159 1159 const QSizeF* s = static_cast<const QSizeF*>(data);
1160 1160 r = QString::number(s->width()) + ", " + QString::number(s->height());
1161 1161 }
1162 1162 break;
1163 1163 case QVariant::Point: {
1164 1164 const QPoint* s = static_cast<const QPoint*>(data);
1165 1165 r = QString::number(s->x()) + ", " + QString::number(s->y());
1166 1166 }
1167 1167 break;
1168 1168 case QVariant::PointF: {
1169 1169 const QPointF* s = static_cast<const QPointF*>(data);
1170 1170 r = QString::number(s->x()) + ", " + QString::number(s->y());
1171 1171 }
1172 1172 break;
1173 1173 case QVariant::Rect: {
1174 1174 const QRect* s = static_cast<const QRect*>(data);
1175 1175 r = QString::number(s->x()) + ", " + QString::number(s->y());
1176 1176 r += ", " + QString::number(s->width()) + ", " + QString::number(s->height());
1177 1177 }
1178 1178 break;
1179 1179 case QVariant::RectF: {
1180 1180 const QRectF* s = static_cast<const QRectF*>(data);
1181 1181 r = QString::number(s->x()) + ", " + QString::number(s->y());
1182 1182 r += ", " + QString::number(s->width()) + ", " + QString::number(s->height());
1183 1183 }
1184 1184 break;
1185 1185 case QVariant::Date: {
1186 1186 const QDate* s = static_cast<const QDate*>(data);
1187 1187 r = s->toString(Qt::ISODate);
1188 1188 }
1189 1189 break;
1190 1190 case QVariant::DateTime: {
1191 1191 const QDateTime* s = static_cast<const QDateTime*>(data);
1192 1192 r = s->toString(Qt::ISODate);
1193 1193 }
1194 1194 break;
1195 1195 case QVariant::Time: {
1196 1196 const QTime* s = static_cast<const QTime*>(data);
1197 1197 r = s->toString(Qt::ISODate);
1198 1198 }
1199 1199 break;
1200 1200 case QVariant::Pixmap:
1201 1201 {
1202 1202 const QPixmap* s = static_cast<const QPixmap*>(data);
1203 1203 r = QString("Pixmap ") + QString::number(s->width()) + ", " + QString::number(s->height());
1204 1204 }
1205 1205 break;
1206 1206 case QVariant::Image:
1207 1207 {
1208 1208 const QImage* s = static_cast<const QImage*>(data);
1209 1209 r = QString("Image ") + QString::number(s->width()) + ", " + QString::number(s->height());
1210 1210 }
1211 1211 break;
1212 1212 case QVariant::Url:
1213 1213 {
1214 1214 const QUrl* s = static_cast<const QUrl*>(data);
1215 1215 r = s->toString();
1216 1216 }
1217 1217 break;
1218 1218 //TODO: add more printing for other variant types
1219 1219 default:
1220 1220 // this creates a copy, but that should not be expensive for typical simple variants
1221 1221 // (but we do not want to do this for our won user types!
1222 1222 if (type>0 && type < (int)QVariant::UserType) {
1223 1223 QVariant v(type, data);
1224 1224 r = v.toString();
1225 1225 }
1226 1226 }
1227 1227 return r;
1228 1228 }
Show file before | Show file after | Hide comments
@@ -1,210 +1,210
1 1 #ifndef _PYTHONQTCONVERSION_H
2 2 #define _PYTHONQTCONVERSION_H
3 3
4 4 /*
5 5 *
6 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
6 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
7 7 *
8 8 * This library is free software; you can redistribute it and/or
9 9 * modify it under the terms of the GNU Lesser General Public
10 10 * License as published by the Free Software Foundation; either
11 11 * version 2.1 of the License, or (at your option) any later version.
12 12 *
13 13 * This library is distributed in the hope that it will be useful,
14 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 16 * Lesser General Public License for more details.
17 17 *
18 18 * Further, this software is distributed without any warranty that it is
19 19 * free of the rightful claim of any third person regarding infringement
20 20 * or the like. Any license provided herein, whether implied or
21 21 * otherwise, applies only to this software file. Patent licenses, if
22 22 * any, provided herein do not apply to combinations of this program with
23 23 * other software, or any other product whatsoever.
24 24 *
25 25 * You should have received a copy of the GNU Lesser General Public
26 26 * License along with this library; if not, write to the Free Software
27 27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 28 *
29 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
29 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
30 30 * 28359 Bremen, Germany or:
31 31 *
32 32 * http://www.mevis.de
33 33 *
34 34 */
35 35
36 36 //----------------------------------------------------------------------------------
37 37 /*!
38 38 // \file PythonQtConversion.h
39 39 // \author Florian Link
40 40 // \author Last changed by $Author: florian $
41 41 // \date 2006-05
42 42 */
43 43 //----------------------------------------------------------------------------------
44 44
45 45 #include "PythonQt.h"
46 46 #include "PythonQtMisc.h"
47 47 #include "PythonQtClassInfo.h"
48 48 #include "PythonQtMethodInfo.h"
49 49
50 50 #include <QWidget>
51 51 #include <QList>
52 52 #include <vector>
53 53
54 54 typedef PyObject* PythonQtConvertMetaTypeToPythonCB(const void* inObject, int metaTypeId);
55 55 typedef bool PythonQtConvertPythonToMetaTypeCB(PyObject* inObject, void* outObject, int metaTypeId, bool strict);
56 56
57 57 #define PythonQtRegisterListTemplateConverter(type, innertype) \
58 58 { int typeId = qRegisterMetaType<type<innertype> >(#type"<"#innertype">"); \
59 59 PythonQtConv::registerPythonToMetaTypeConverter(typeId, PythonQtConvertPythonListToListOfValueType<type<innertype>, innertype>); \
60 60 PythonQtConv::registerMetaTypeToPythonConverter(typeId, PythonQtConvertListOfValueTypeToPythonList<type<innertype>, innertype>); \
61 61 }
62 62
63 63 #define PythonQtRegisterToolClassesTemplateConverter(innertype) \
64 64 PythonQtRegisterListTemplateConverter(QList, innertype); \
65 65 PythonQtRegisterListTemplateConverter(QVector, innertype); \
66 66 PythonQtRegisterListTemplateConverter(std::vector, innertype);
67 67 // TODO: add QHash etc. here!
68 68
69 69 //! a static class that offers methods for type conversion
70 70 class PYTHONQT_EXPORT PythonQtConv {
71 71
72 72 public:
73 73
74 74 //! get a ref counted True or False Python object
75 75 static PyObject* GetPyBool(bool val);
76 76
77 77 //! converts the Qt parameter given in \c data, interpreting it as a \c info parameter, into a Python object,
78 78 static PyObject* ConvertQtValueToPython(const PythonQtMethodInfo::ParameterInfo& info, const void* data);
79 79
80 80 //! convert python object to Qt (according to the given parameter) and if the conversion should be strict (classInfo is currently not used anymore)
81 81 static void* ConvertPythonToQt(const PythonQtMethodInfo::ParameterInfo& info, PyObject* obj, bool strict, PythonQtClassInfo* classInfo, void* alreadyAllocatedCPPObject = NULL);
82 82
83 83 //! creates a data storage for the passed parameter type and returns a void pointer to be set as arg[0] of qt_metacall
84 84 static void* CreateQtReturnValue(const PythonQtMethodInfo::ParameterInfo& info);
85 85
86 86 //! converts QString to Python string (unicode!)
87 87 static PyObject* QStringToPyObject(const QString& str);
88 88
89 89 //! converts QStringList to Python tuple
90 90 static PyObject* QStringListToPyObject(const QStringList& list);
91 91
92 92 //! converts QStringList to Python list
93 93 static PyObject* QStringListToPyList(const QStringList& list);
94 94
95 95 //! get string representation of py object
96 96 static QString PyObjGetRepresentation(PyObject* val);
97 97
98 98 //! get string value from py object
99 99 static QString PyObjGetString(PyObject* val) { bool ok; QString s = PyObjGetString(val, false, ok); return s; }
100 100 //! get string value from py object
101 101 static QString PyObjGetString(PyObject* val, bool strict, bool &ok);
102 102 //! get bytes from py object
103 103 static QByteArray PyObjGetBytes(PyObject* val, bool strict, bool &ok);
104 104 //! get int from py object
105 105 static int PyObjGetInt(PyObject* val, bool strict, bool &ok);
106 106 //! get int64 from py object
107 107 static qint64 PyObjGetLongLong(PyObject* val, bool strict, bool &ok);
108 108 //! get int64 from py object
109 109 static quint64 PyObjGetULongLong(PyObject* val, bool strict, bool &ok);
110 110 //! get double from py object
111 111 static double PyObjGetDouble(PyObject* val, bool strict, bool &ok);
112 112 //! get bool from py object
113 113 static bool PyObjGetBool(PyObject* val, bool strict, bool &ok);
114 114
115 115 //! create a string list from python sequence
116 116 static QStringList PyObjToStringList(PyObject* val, bool strict, bool& ok);
117 117
118 118 //! convert python object to qvariant, if type is given it will try to create a qvariant of that type, otherwise
119 119 //! it will guess from the python type
120 120 static QVariant PyObjToQVariant(PyObject* val, int type = -1);
121 121
122 122 //! convert QVariant from PyObject
123 123 static PyObject* QVariantToPyObject(const QVariant& v);
124 124
125 125 static PyObject* QVariantMapToPyObject(const QVariantMap& m);
126 126 static PyObject* QVariantListToPyObject(const QVariantList& l);
127 127
128 128 //! get human readable string from CPP object (when the metatype is known)
129 129 static QString CPPObjectToString(int type, const void* data);
130 130
131 131 //! register a converter callback from python to cpp for given metatype
132 132 static void registerPythonToMetaTypeConverter(int metaTypeId, PythonQtConvertPythonToMetaTypeCB* cb) { _pythonToMetaTypeConverters.insert(metaTypeId, cb); }
133 133
134 134 //! register a converter callback from cpp to python for given metatype
135 135 static void registerMetaTypeToPythonConverter(int metaTypeId, PythonQtConvertMetaTypeToPythonCB* cb) { _metaTypeToPythonConverters.insert(metaTypeId, cb); }
136 136
137 137 //! returns the inner type id of a simple template of the form SomeObject<InnerType>
138 138 static int getInnerTemplateMetaType(const QByteArray& typeName);
139 139
140 140 //! converts the Qt parameter given in \c data, interpreting it as a \c type registered qvariant/meta type, into a Python object,
141 141 static PyObject* ConvertQtValueToPythonInternal(int type, const void* data);
142 142
143 143 public:
144 144
145 145 static PythonQtValueStorage<qint64, 128> global_valueStorage;
146 146 static PythonQtValueStorage<void*, 128> global_ptrStorage;
147 147 static PythonQtValueStorage<QVariant, 32> global_variantStorage;
148 148
149 149 protected:
150 150 static QHash<int, PythonQtConvertMetaTypeToPythonCB*> _metaTypeToPythonConverters;
151 151 static QHash<int, PythonQtConvertPythonToMetaTypeCB*> _pythonToMetaTypeConverters;
152 152
153 153 //! handle automatic conversion of some special types (QColor, QBrush, ...)
154 154 static void* handlePythonToQtAutoConversion(int typeId, PyObject* obj, void* alreadyAllocatedCPPObject);
155 155
156 156 //! converts the list of pointers of given type to Python
157 157 static PyObject* ConvertQListOfPointerTypeToPythonList(QList<void*>* list, const QByteArray& type);
158 158 //! tries to convert the python object to a QList of pointers to \c type objects, returns true on success
159 159 static bool ConvertPythonListToQListOfPointerType(PyObject* obj, QList<void*>* list, const QByteArray& type, bool strict);
160 160
161 161 //! cast wrapper to given className if possible
162 162 static void* castWrapperTo(PythonQtInstanceWrapper* wrapper, const QByteArray& className, bool& ok);
163 163 };
164 164
165 165 template<class ListType, class T>
166 166 PyObject* PythonQtConvertListOfValueTypeToPythonList(const void* /*QList<T>* */ inList, int metaTypeId)
167 167 {
168 168 ListType* list = (ListType*)inList;
169 169 static const int innerType = PythonQtConv::getInnerTemplateMetaType(QByteArray(QMetaType::typeName(metaTypeId)));
170 170 if (innerType == QVariant::Invalid) {
171 171 std::cerr << "PythonQtConvertListOfValueTypeToPythonList: unknown inner type " << QMetaType::typeName(metaTypeId) << std::endl;
172 172 }
173 173 PyObject* result = PyTuple_New(list->size());
174 174 int i = 0;
175 175 foreach (const T& value, *list) {
176 176 PyTuple_SET_ITEM(result, i, PythonQtConv::ConvertQtValueToPythonInternal(innerType, &value));
177 177 i++;
178 178 }
179 179 return result;
180 180 }
181 181
182 182 template<class ListType, class T>
183 183 bool PythonQtConvertPythonListToListOfValueType(PyObject* obj, void* /*QList<T>* */ outList, int metaTypeId, bool /*strict*/)
184 184 {
185 185 ListType* list = (ListType*)outList;
186 186 static const int innerType = PythonQtConv::getInnerTemplateMetaType(QByteArray(QMetaType::typeName(metaTypeId)));
187 187 if (innerType == QVariant::Invalid) {
188 188 std::cerr << "PythonQtConvertPythonListToListOfValueType: unknown inner type " << QMetaType::typeName(metaTypeId) << std::endl;
189 189 }
190 190 bool result = false;
191 191 if (PySequence_Check(obj)) {
192 192 result = true;
193 193 int count = PySequence_Size(obj);
194 194 PyObject* value;
195 195 for (int i = 0;i<count;i++) {
196 196 value = PySequence_GetItem(obj,i);
197 197 // this is quite some overhead, but it avoids having another large switch...
198 198 QVariant v = PythonQtConv::PyObjToQVariant(value, innerType);
199 199 if (v.isValid()) {
200 200 list->push_back(qVariantValue<T>(v));
201 201 } else {
202 202 result = false;
203 203 break;
204 204 }
205 205 }
206 206 }
207 207 return result;
208 208 }
209 209
210 210 #endif
Show file before | Show file after | Hide comments
@@ -1,61 +1,61
1 1 #ifndef _PYTHONQTCPPWRAPPERFACTORY_H
2 2 #define _PYTHONQTCPPWRAPPERFACTORY_H
3 3
4 4 /*
5 5 *
6 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
6 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
7 7 *
8 8 * This library is free software; you can redistribute it and/or
9 9 * modify it under the terms of the GNU Lesser General Public
10 10 * License as published by the Free Software Foundation; either
11 11 * version 2.1 of the License, or (at your option) any later version.
12 12 *
13 13 * This library is distributed in the hope that it will be useful,
14 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 16 * Lesser General Public License for more details.
17 17 *
18 18 * Further, this software is distributed without any warranty that it is
19 19 * free of the rightful claim of any third person regarding infringement
20 20 * or the like. Any license provided herein, whether implied or
21 21 * otherwise, applies only to this software file. Patent licenses, if
22 22 * any, provided herein do not apply to combinations of this program with
23 23 * other software, or any other product whatsoever.
24 24 *
25 25 * You should have received a copy of the GNU Lesser General Public
26 26 * License along with this library; if not, write to the Free Software
27 27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 28 *
29 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
29 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
30 30 * 28359 Bremen, Germany or:
31 31 *
32 32 * http://www.mevis.de
33 33 *
34 34 */
35 35
36 36 //----------------------------------------------------------------------------------
37 37 /*!
38 38 // \file PythonQtCppWrapperFactory.h
39 39 // \author Florian Link
40 40 // \author Last changed by $Author: florian $
41 41 // \date 2006-06
42 42 */
43 43 //----------------------------------------------------------------------------------
44 44
45 45 //! Factory interface for C++ classes that can be wrapped by QObject objects
46 46 /*! To create your own factory, derive PythonQtCppWrapperFactory and implement
47 47 the create() method.
48 48 A factory can be added to PythonQt by PythonQt::addCppWrapperFactory().
49 49 */
50 50 class PYTHONQT_EXPORT PythonQtCppWrapperFactory
51 51 {
52 52 public:
53 53 PythonQtCppWrapperFactory() {};
54 54 virtual ~PythonQtCppWrapperFactory() {};
55 55
56 56 //! create a wrapper for the given object
57 57 virtual QObject* create(const QByteArray& name, void *ptr) = 0;
58 58
59 59 };
60 60
61 61 #endif No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,509 +1,509
1 1 #ifndef _PYTHONQTDOC_H
2 2 #define _PYTHONQTDOC_H
3 3
4 4 /*
5 5 *
6 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
6 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
7 7 *
8 8 * This library is free software; you can redistribute it and/or
9 9 * modify it under the terms of the GNU Lesser General Public
10 10 * License as published by the Free Software Foundation; either
11 11 * version 2.1 of the License, or (at your option) any later version.
12 12 *
13 13 * This library is distributed in the hope that it will be useful,
14 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 16 * Lesser General Public License for more details.
17 17 *
18 18 * Further, this software is distributed without any warranty that it is
19 19 * free of the rightful claim of any third person regarding infringement
20 20 * or the like. Any license provided herein, whether implied or
21 21 * otherwise, applies only to this software file. Patent licenses, if
22 22 * any, provided herein do not apply to combinations of this program with
23 23 * other software, or any other product whatsoever.
24 24 *
25 25 * You should have received a copy of the GNU Lesser General Public
26 26 * License along with this library; if not, write to the Free Software
27 27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 28 *
29 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
29 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
30 30 * 28359 Bremen, Germany or:
31 31 *
32 32 * http://www.mevis.de
33 33 *
34 34 */
35 35
36 36 //----------------------------------------------------------------------------------
37 37 /*!
38 38 // \file PythonQtDoc.h
39 39 // \author Florian Link
40 40 // \author Last changed by $Author: florian $
41 41 // \date 2006-10
42 42 */
43 43 //----------------------------------------------------------------------------------
44 44
45 45 /*!
46 46 \if USE_GLOBAL_DOXYGEN_DOC
47 47 \page PythonQtPage PythonQt Overview
48 48 \else
49 49 \mainpage PythonQt Overview
50 50 \endif
51 51
52 52 \section Introduction
53 53
54 54 \b PythonQt is a dynamic Python (http://www.python.org) binding for the Qt framework (http://qt.nokia.com).
55 55 It offers an easy way to embed the Python scripting language into
56 56 your C++ Qt applications. It makes heavy use of the QMetaObject system and thus requires Qt4.x.
57 57
58 58 The focus of PythonQt is on embedding Python into an existing C++ application, not on writing the whole
59 59 application completely in Python. If you want to write your whole application in Python,
60 60 you should use <a href="http://www.riverbankcomputing.co.uk/pyqt/">PyQt</a> or <a href="http://www.pyside.org">PySide</a> instead.
61 61
62 62 If you are looking for a simple way to embed Python objects into your C++/Qt Application
63 63 and to script parts of your application via Python, PythonQt is the way to go!
64 64
65 65 PythonQt is a stable library that was developed to make the
66 66 Image Processing and Visualization platform MeVisLab (http://www.mevislab.de)
67 67 scriptable from Python.
68 68
69 69 \section Download
70 70
71 71 PythonQt is hosted on SourceForge at http://sourceforge.net/projects/pythonqt , you can access it via SVN
72 72 or download a tarball.
73 73
74 74 \section Licensing
75 75
76 76 PythonQt is distributed under the LGPL license, so it pairs well with the LGPL of the Qt 4.5 release and allows
77 77 to be used in commercial applications when following the LGPL 2.1 obligations.
78 78
79 79 \section LicensingWrapper Licensing of Wrapper Generator
80 80
81 81 The build system of PythonQt makes use of a modified version of the LGPL'ed QtScript generator,
82 82 located in the "generator" directory.
83 83
84 84 See http://qt.gitorious.org/qt-labs/qtscriptgenerator for details on the original project.
85 85 Thanks a lot to the QtJambi guys and the QtScript Generator project for the C++ parser and
86 86 Qt typesystem files!
87 87
88 88 The PythonQt wrappers generated by the generator located in the "generated_cpp" directory are free to be used without any licensing restrictions.
89 89
90 90 The generated wrappers are pre-generated and checked-in for Qt 4.6.1, so you only need to build and run the
91 91 generator when you want to build additional wrappers or you want to upgrade/downgrade to another Qt version.
92 92 You may use the generator to generate C++ bindings for your own C++ classes (e.g., to make them inheritable in Python),
93 93 , but this is currently not documented and involves creating your own typesystem files (although the Qt Jambi examples might help you).
94 94
95 95 \section Features
96 96
97 97 The following are the built-in features of the PythonQt library:
98 98
99 99 - Access all \b slots, \b properties, children and registered enums of any QObject derived class from Python
100 100 - Connecting Qt Signals to Python functions (both from within Python and from C++)
101 101 - Easy wrapping of Python objects from C++ with smart, reference-counting PythonQtObjectPtr.
102 102 - Convenient conversions to/from QVariant for PythonQtObjectPtr.
103 103 - Wrapping of C++ objects (which are not derived from QObject) via PythonQtCppWrapperFactory
104 104 - Extending C++ and QObject derived classes with additional slots, static methods and constructors (see Decorators)
105 105 - StdOut/Err redirection to Qt signals instead of cout
106 106 - Interface for creating your own \c import replacement, so that Python scripts can be e.g. signed/verified before they are executed (PythonQtImportFileInterface)
107 107 - Mapping of plain-old-datatypes and ALL QVariant types to and from Python
108 108 - Support for wrapping of user QVariant types which are registerd via QMetaType
109 109 - Support for Qt namespace (with all enumerators)
110 110 - All PythonQt wrapped objects support the dir() statement, so that you can see easily which attributes a QObject, CPP object or QVariant has
111 111 - No preprocessing/wrapping tool needs to be started, PythonQt can script any QObject without prior knowledge about it (except for the MetaObject information from the \b moc)
112 112 - Multiple inheritance for C++ objects (e.g. a QWidget is derived from QObject and QPaintDevice, PythonQt will automatically cast a QWidget to a QPaintDevice when needed)
113 113 - Polymorphic downcasting (if e.g. PythonQt sees a QEvent, it can downcast it depending on the type(), so the Python e.g. sees a QPaintEvent instead of a plain QEvent)
114 114 - Deriving C++ objects from Python and overwriting virtual method with a Python implementation (requires usage of wrapper generator or manual work!)
115 115 - Extensible handler for Python/C++ conversion of complex types, e.g. mapping of QVector<SomeObject> to/from a Python array
116 116
117 117 \section FeaturesQtAll Features (with PythonQt_QtAll linked in)
118 118
119 119 Thanks to the new wrapper generator, PythonQt now offers the additional PythonQt_QtAll library which wraps the complete Qt API, including all C++ classes and all non-slots on QObject derived classes.
120 120 This offers the following features:
121 121
122 122 - Complete Qt API wrapped and accessible
123 123 - The following modules are available as submodules of the PythonQt module:
124 124 - QtCore
125 125 - QtGui
126 126 - QtNetwork
127 127 - QtOpenGL
128 128 - QtSql
129 129 - QtSvg
130 130 - QtUiTools
131 131 - QtWebKit
132 132 - QtXml
133 133 - QtXmlPatterns
134 134 - (phonon, QtHelp, assistant, designer are currently not supported, this would require some additional effort on the code generator)
135 135 - For convenience, all classes are also available in the PythonQt.Qt module, for people who do not care in which module a class is located
136 136 - Any Qt class that has virtual methods can be easily derived from Python and the virtual methods can be reimplemented in Python
137 137 - Polymorphic downcasting on QEvent, QGraphicsItem, QStyleOption, ...
138 138 - Multiple inheritance support (e.g., QGraphicsTextItem is a QObject AND a QGraphicsItem, PythonQt will handle this well)
139 139
140 140 \section Comparision Comparision with PyQt/PySide
141 141
142 142 - PythonQt is not as Pythonic as PyQt in many details (e.g. buffer protocol, pickling, translation support, ...) and it is mainly thought for embedding and intercommunication between Qt/Cpp and Python
143 143 - PythonQt allows to communicate in both directions, e.g., calling a Python object from C++ AND calling a C++ method from Python, while PyQt only handles the Python->C++ direction
144 144 - PythonQt offers properties as Python attributes, while PyQt offers them as setter/getter methods (e.g. QWidget.width is a property in PythonQt and a method in PyQt)
145 145 - PythonQt does not support instanceof checks for Qt classes, except for the exact match and derived Python classes
146 146 - QObject.emit to emit Qt signals from Python is not yet implemented but PythonQt allows to just emit a signal by calling it
147 147 - PythonQt does not (yet) offer to add new signals to Python/C++ objects
148 148 - Ownership of objects is a bit different in PythonQt, currently Python classes derived from a C++ class need to be manually referenced in Python to not get deleted too early (this will be fixed)
149 149 - QStrings are always converted to unicode Python objects (PyQt returns QString instead), we prefered to return Python strings.
150 150 - Probably there are lots of details that differ, I do not know PyQt that well to list them all.
151 151
152 152 \section Interface
153 153
154 154 The main interface to PythonQt is the PythonQt singleton.
155 155 PythonQt needs to be initialized via PythonQt::init() once.
156 156 Afterwards you communicate with the singleton via PythonQt::self().
157 157 PythonQt offers a complete Qt binding, which
158 158 needs to be enabled via PythonQt_QtAll::init().
159 159
160 160
161 161 \section Datatype Datatype Mapping
162 162
163 163 The following table shows the mapping between Python and Qt objects:
164 164 <table>
165 165 <tr><th>Qt/C++</th><th>Python</th></tr>
166 166 <tr><td>bool</td><td>bool</td></tr>
167 167 <tr><td>double</td><td>float</td></tr>
168 168 <tr><td>float</td><td>float</td></tr>
169 169 <tr><td>char/uchar,int/uint,short,ushort,QChar</td><td>integer</td></tr>
170 170 <tr><td>long</td><td>integer</td></tr>
171 171 <tr><td>ulong,longlong,ulonglong</td><td>long</td></tr>
172 172 <tr><td>QString</td><td>unicode string</td></tr>
173 173 <tr><td>QByteArray</td><td>str</td></tr>
174 174 <tr><td>char*</td><td>str</td></tr>
175 175 <tr><td>QStringList</td><td>tuple of unicode strings</td></tr>
176 176 <tr><td>QVariantList</td><td>tuple of objects</td></tr>
177 177 <tr><td>QVariantMap</td><td>dict of objects</td></tr>
178 178 <tr><td>QVariant</td><td>depends on type, see below</td></tr>
179 179 <tr><td>QSize, QRect and all other standard Qt QVariants</td><td>variant wrapper that supports complete API of the respective Qt classes</td></tr>
180 180 <tr><td>OwnRegisteredMetaType</td><td>C++ wrapper, optionally with additional information/wrapping provided by registerCPPClass()</td></tr>
181 181 <tr><td>QList<AnyObject*></td><td>converts to a list of CPP wrappers</td></tr>
182 182 <tr><td>EnumType</td><td>integer (all enums that are known via the moc and the Qt namespace are supported)</td></tr>
183 183 <tr><td>QObject (and derived classes)</td><td>QObject wrapper</td></tr>
184 184 <tr><td>C++ object</td><td>CPP wrapper, either wrapped via PythonQtCppWrapperFactory or just decorated with decorators</td></tr>
185 185 <tr><td>PyObject</td><td>PyObject</td></tr>
186 186 </table>
187 187
188 188 PyObject is passed as simple pointer, which allows to pass/return any Python Object directly to/from
189 189 a Qt slot.
190 190 QVariants are mapped recursively as given above, e.g. a dictionary can
191 191 contain lists of dictionaries of doubles.
192 192 For example a QVariant of type "String" is mapped to a python unicode string.
193 193 All Qt QVariant types are implemented, PythonQt supports the complete Qt API for these object.
194 194
195 195 \section QObject QObject Wrapping
196 196
197 197 All classes derived from QObject are automatically wrapped with a python wrapper class
198 198 when they become visible to the Python interpreter. This can happen via
199 199 - the PythonQt::addObject() method
200 200 - when a Qt \b slot returns a QObject derived object to python
201 201 - when a Qt \b signal contains a QObject and is connected to a python function
202 202
203 203 It is important that you call PythonQt::registerClass() for any QObject derived class
204 204 that may become visible to Python, except when you add it via PythonQt::addObject().
205 205 This will register the complete parent hierachy of the registered class, so that
206 206 when you register e.g. a QPushButton, QWidget will be registered as well (and all intermediate
207 207 parents).
208 208
209 209 From Python, you can talk to the returned QObjects in a natural way by calling
210 210 their slots and receiving the return values. You can also read/write all
211 211 properties of the objects as if they where normal python properties.
212 212
213 213 In addition to this, the wrapped objects support
214 214 - className() - returns a string that reprents the classname of the QObject
215 215 - help() - shows all properties, slots, enums, decorator slots and constructors of the object, in a printable form
216 216 - delete() - deletes the object (use with care, especially if you passed the ownership to C++)
217 217 - connect(signal, function) - connect the signal of the given object to a python function
218 218 - connect(signal, qobject, slot) - connect the signal of the given object to a slot of another QObject
219 219 - disconnect(signal, function) - disconnect the signal of the given object from a python function
220 220 - disconnect(signal, qobject, slot) - disconnect the signal of the given object from a slot of another QObject
221 221 - children() - returns the children of the object
222 222 - setParent(QObject) - set the parent
223 223 - QObject* parent() - get the parent
224 224
225 225 The below example shows how to connect signals in Python:
226 226
227 227 \code
228 228 # define a signal handler function
229 229 def someFunction(flag):
230 230 print flag
231 231
232 232 # button1 is a QPushButton that has been added to Python via addObject()
233 233 # connect the clicked signal to a python function:
234 234 button1.connect("clicked(bool)", someFunction)
235 235
236 236 \endcode
237 237
238 238 \section CPP CPP Wrapping
239 239
240 240 You can create dedicated wrapper QObjects for any C++ class. This is done by deriving from PythonQtCppWrapperFactory
241 241 and adding your factory via addWrapperFactory().
242 242 Whenever PythonQt encounters a CPP pointer (e.g. on a slot or signal)
243 243 and it does not known it as a QObject derived class, it will create a generic CPP wrapper. So even unknown C++ objects
244 244 can be passed through Python. If the wrapper factory supports the CPP class, a QObject wrapper will be created for each
245 245 instance that enters Python. An alternative to a complete wrapper via the wrapper factory are decorators, see \ref Decorators
246 246
247 247 \section MetaObject Meta Object/Class access
248 248
249 249 For each known C++ class, PythonQt provides a Python class. These classes are visible
250 250 inside of the "PythonQt" python module or in subpackages if a package is given when the class is registered.
251 251
252 252 A Meta class supports:
253 253
254 254 - access to all declared enum values
255 255 - constructors
256 256 - static methods
257 257 - unbound non-static methods
258 258 - help() and className()
259 259
260 260 From within Python, you can import the module "PythonQt" to access these classes and the Qt namespace.
261 261
262 262 \code
263 263 from PythonQt import QtCore
264 264
265 265 # namespace access:
266 266 print QtCore.Qt.AlignLeft
267 267
268 268 # constructors
269 269 a = QtCore.QSize(12,13)
270 270 b = QtCore.QFont()
271 271
272 272 # static method
273 273 QtCore.QDate.currentDate()
274 274
275 275 # enum value
276 276 QtCore.QFont.UltraCondensed
277 277
278 278 \endcode
279 279
280 280 \section Decorators Decorator slots
281 281
282 282 PythonQt introduces a new generic approach to extend any wrapped QObject or CPP object with
283 283
284 284 - constructors
285 285 - destructors (for CPP objects)
286 286 - additional slots
287 287 - static slots (callable on both the Meta object and the instances)
288 288
289 289 The idea behind decorators is that we wanted to make it as easy as possible to extend
290 290 wrapped objects. Since we already have an implementation for invoking any Qt Slot from
291 291 Python, it looked promising to use this approach for the extension of wrapped objects as well.
292 292 This avoids that the PythonQt user needs to care about how Python arguments are mapped from/to
293 293 Qt when he wants to create static methods, constructors and additional member functions.
294 294
295 295 The basic idea about decorators is to create a QObject derived class that implements slots
296 296 which take one of the above roles (e.g. constructor, destructor etc.) via a naming convention.
297 297 These slots are then assigned to other classes via the naming convention.
298 298
299 299 - SomeClassName* new_SomeClassName(...) - defines a constructor for "SomeClassName" that returns a new object of type SomeClassName (where SomeClassName can be any CPP class, not just QObject classes)
300 300 - void delete_SomeClassName(SomeClassName* o) - defines a destructor, which should delete the passed in object o
301 301 - anything static_SomeClassName_someMethodName(...) - defines a static method that is callable on instances and the meta class
302 302 - anything someMethodName(SomeClassName* o, ...) - defines a slot that will be available on SomeClassName instances (and derived instances). When such a slot is called the first argument is the pointer to the instance and the rest of the arguments can be used to make a call on the instance.
303 303
304 304 The below example shows all kinds of decorators in action:
305 305
306 306 \code
307 307
308 308 // an example CPP object
309 309 class YourCPPObject {
310 310 public:
311 311 YourCPPObject(int arg1, float arg2) { a = arg1; b = arg2; }
312 312
313 313 float doSomething(int arg1) { return arg1*a*b; };
314 314
315 315 private:
316 316
317 317 int a;
318 318 float b;
319 319 };
320 320
321 321 // an example decorator
322 322 class ExampleDecorator : public QObject
323 323 {
324 324 Q_OBJECT
325 325
326 326 public slots:
327 327 // add a constructor to QSize that takes a QPoint
328 328 QSize* new_QSize(const QPoint& p) { return new QSize(p.x(), p.y()); }
329 329
330 330 // add a constructor for QPushButton that takes a text and a parent widget
331 331 QPushButton* new_QPushButton(const QString& text, QWidget* parent=NULL) { return new QPushButton(text, parent); }
332 332
333 333 // add a constructor for a CPP object
334 334 YourCPPObject* new_YourCPPObject(int arg1, float arg2) { return new YourCPPObject(arg1, arg2); }
335 335
336 336 // add a destructor for a CPP object
337 337 void delete_YourCPPObject(YourCPPObject* obj) { delete obj; }
338 338
339 339 // add a static method to QWidget
340 340 QWidget* static_QWidget_mouseGrabber() { return QWidget::mouseGrabber(); }
341 341
342 342 // add an additional slot to QWidget (make move() callable, which is not declared as a slot in QWidget)
343 343 void move(QWidget* w, const QPoint& p) { w->move(p); }
344 344
345 345 // add an additional slot to QWidget, overloading the above move method
346 346 void move(QWidget* w, int x, int y) { w->move(x,y); }
347 347
348 348 // add a method to your own CPP object
349 349 int doSomething(YourCPPObject* obj, int arg1) { return obj->doSomething(arg1); }
350 350 };
351 351
352 352 ...
353 353
354 354 PythonQt::self()->addDecorators(new ExampleDecorator());
355 355 PythonQt::self()->registerCPPClass("YourCPPObject");
356 356
357 357 \endcode
358 358
359 359 After you have registered an instance of the above ExampleDecorator, you can do the following from Python
360 360 (all these calls are mapped to the above decorator slots):
361 361
362 362 \code
363 363 from PythonQt import QtCore, QtGui, YourCPPObject
364 364
365 365 # call our new constructor of QSize
366 366 size = QtCore.QSize(QPoint(1,2));
367 367
368 368 # call our new QPushButton constructor
369 369 button = QtGui.QPushButton("sometext");
370 370
371 371 # call the move slot (overload1)
372 372 button.move(QPoint(0,0))
373 373
374 374 # call the move slot (overload2)
375 375 button.move(0,0)
376 376
377 377 # call the static method
378 378 grabber = QtGui.QWidget.mouseWrapper();
379 379
380 380 # create a CPP object via constructor
381 381 yourCpp = YourCPPObject(1,11.5)
382 382
383 383 # call the wrapped method on CPP object
384 384 print yourCpp.doSomething(1);
385 385
386 386 # destructor will be called:
387 387 yourCpp = None
388 388
389 389 \endcode
390 390
391 391 \section Building
392 392
393 393 PythonQt requires Qt 4.6.1 (or higher) and Python 2.5 or 2.6 on Windows, Linux and MacOS X. It has not yet been tested with Python 3.x, but it should only require minor changes.
394 394 To compile PythonQt, you will need a python developer installation which includes Python's header files and
395 395 the python2x.[lib | dll | so | dynlib].
396 396 The build scripts a currently set to use Python 2.5.
397 397 You may need to tweak the \b build/python.prf file to set the correct Python includes and libs on your system.
398 398
399 399 \subsection Windows
400 400
401 401 On Windows, the (non-source) Python Windows installer can be used.
402 402 Make sure that you use the same compiler, the current Python distribution is built
403 403 with Visual Studio 2003. If you want to use another compiler, you will need to build
404 404 Python yourself, using your compiler.
405 405
406 406 To build PythonQt, you need to set the environment variable \b PYTHON_PATH to point to the root
407 407 dir of the python installation and \b PYTHON_LIB to point to
408 408 the directory where the python lib file is located.
409 409
410 410 When using the prebuild Python installer, this will be:
411 411
412 412 \code
413 413 > set PYTHON_PATH = c:\Python25
414 414 > set PYTHON_LIB = c:\Python25\libs
415 415 \endcode
416 416
417 417 When using the python sources, this will be something like:
418 418
419 419 \code
420 420 > set PYTHON_PATH = c:\yourDir\Python-2.5.1\
421 421 > set PYTHON_LIB = c:\yourDir\Python-2.5.1\PCbuild8\Win32
422 422 \endcode
423 423
424 424 To build all, do the following (after setting the above variables):
425 425
426 426 \code
427 427 > cd PythonQtRoot
428 428 > vcvars32
429 429 > qmake
430 430 > nmake
431 431 \endcode
432 432
433 433 This should build everything. If Python can not be linked or include files can not be found,
434 434 you probably need to tweak \b build/python.prf
435 435
436 436 The tests and examples are located in PythonQt/lib.
437 437
438 438 \subsection Linux
439 439
440 440 On Linux, you need to install a Python-dev package.
441 441 If Python can not be linked or include files can not be found,
442 442 you probably need to tweak \b build/python.prf
443 443
444 444 To build PythonQt, just do a:
445 445
446 446 \code
447 447 > cd PythonQtRoot
448 448 > qmake
449 449 > make all
450 450 \endcode
451 451
452 452 The tests and examples are located in PythonQt/lib.
453 453 You should add PythonQt/lib to your LD_LIBRARY_PATH so that the runtime
454 454 linker can find the *.so files.
455 455
456 456 \subsection MacOsX
457 457
458 458 On Mac, Python is installed as a Framework, so you should not need to install it.
459 459 To build PythonQt, just do a:
460 460
461 461 \code
462 462 > cd PythonQtRoot
463 463 > qmake
464 464 > make all
465 465 \endcode
466 466
467 467 \section Tests
468 468
469 469 There is a unit test that tests most features of PythonQt, see the \b tests subdirectory for details.
470 470
471 471 \section Examples
472 472
473 473 Examples are available in the \b examples directory. The PyScriptingConsole implements a simple
474 474 interactive scripting console that shows how to script a simple application.
475 475
476 476 The following shows how to integrate PythonQt into you Qt application:
477 477
478 478 \code
479 479 #include "PythonQt.h"
480 480 #include <QApplication>
481 481 ...
482 482
483 483 int main( int argc, char **argv )
484 484 {
485 485
486 486 QApplication qapp(argc, argv);
487 487
488 488 // init PythonQt and Python itself
489 489 PythonQt::init(PythonQt::IgnoreSiteModule | PythonQt::RedirectStdOut);
490 490
491 491
492 492 // get a smart pointer to the __main__ module of the Python interpreter
493 493 PythonQtObjectPtr mainContext = PythonQt::self()->getMainModule();
494 494
495 495 // add a QObject as variable of name "example" to the namespace of the __main__ module
496 496 PyExampleObject example;
497 497 PythonQt::self()->addObject(mainContext, "example", &example);
498 498
499 499 // do something
500 500 PythonQt::self()->runScript(mainContext, "print example\n");
501 501 PythonQt::self()->runScript(mainContext, "def multiply(a,b):\n return a*b;\n");
502 502 QVariantList args;
503 503 args << 42 << 47;
504 504 QVariant result = PythonQt::self()->call(mainContext,"multiply", args);
505 505 ...
506 506 \endcode
507 507
508 508
509 509 */
Show file before | Show file after | Hide comments
@@ -1,72 +1,72
1 1 #ifndef _PYTHONQTIMPORTFILEINTERFACE_H
2 2 #define _PYTHONQTIMPORTFILEINTERFACE_H
3 3
4 4 /*
5 5 *
6 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
6 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
7 7 *
8 8 * This library is free software; you can redistribute it and/or
9 9 * modify it under the terms of the GNU Lesser General Public
10 10 * License as published by the Free Software Foundation; either
11 11 * version 2.1 of the License, or (at your option) any later version.
12 12 *
13 13 * This library is distributed in the hope that it will be useful,
14 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 16 * Lesser General Public License for more details.
17 17 *
18 18 * Further, this software is distributed without any warranty that it is
19 19 * free of the rightful claim of any third person regarding infringement
20 20 * or the like. Any license provided herein, whether implied or
21 21 * otherwise, applies only to this software file. Patent licenses, if
22 22 * any, provided herein do not apply to combinations of this program with
23 23 * other software, or any other product whatsoever.
24 24 *
25 25 * You should have received a copy of the GNU Lesser General Public
26 26 * License along with this library; if not, write to the Free Software
27 27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 28 *
29 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
29 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
30 30 * 28359 Bremen, Germany or:
31 31 *
32 32 * http://www.mevis.de
33 33 *
34 34 */
35 35
36 36 //----------------------------------------------------------------------------------
37 37 /*!
38 38 // \file PythonQtImportFileInterface.h
39 39 // \author Florian Link
40 40 // \author Last changed by $Author: florian $
41 41 // \date 2006-05
42 42 */
43 43 //----------------------------------------------------------------------------------
44 44
45 45 #include <QDateTime>
46 46 #include <QString>
47 47 #include <QByteArray>
48 48
49 49 //! Defines an abstract interface to file access for the Python import statement.
50 50 //! see PythonQt::setImporter()
51 51 class PythonQtImportFileInterface {
52 52
53 53 public:
54 54 // get rid of warnings
55 55 virtual ~PythonQtImportFileInterface() {}
56 56
57 57 //! read the given file as byte array, without doing any linefeed translations
58 58 virtual QByteArray readFileAsBytes(const QString& filename) = 0;
59 59
60 60 //! read a source file, expects a readable Python text file with translated line feeds.
61 61 //! If the file can not be load OR it can not be verified, ok is set to false
62 62 virtual QByteArray readSourceFile(const QString& filename, bool& ok) = 0;
63 63
64 64 //! returns if the file exists
65 65 virtual bool exists(const QString& filename) = 0;
66 66
67 67 //! get the last modified data of a file
68 68 virtual QDateTime lastModifiedDate(const QString& filename) = 0;
69 69
70 70 };
71 71
72 72 #endif No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,793 +1,793
1 1 /*
2 2 *
3 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
3 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
4 4 *
5 5 * This library is free software; you can redistribute it and/or
6 6 * modify it under the terms of the GNU Lesser General Public
7 7 * License as published by the Free Software Foundation; either
8 8 * version 2.1 of the License, or (at your option) any later version.
9 9 *
10 10 * This library is distributed in the hope that it will be useful,
11 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 13 * Lesser General Public License for more details.
14 14 *
15 15 * Further, this software is distributed without any warranty that it is
16 16 * free of the rightful claim of any third person regarding infringement
17 17 * or the like. Any license provided herein, whether implied or
18 18 * otherwise, applies only to this software file. Patent licenses, if
19 19 * any, provided herein do not apply to combinations of this program with
20 20 * other software, or any other product whatsoever.
21 21 *
22 22 * You should have received a copy of the GNU Lesser General Public
23 23 * License along with this library; if not, write to the Free Software
24 24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 25 *
26 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
26 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
27 27 * 28359 Bremen, Germany or:
28 28 *
29 29 * http://www.mevis.de
30 30 *
31 31 */
32 32
33 33 //----------------------------------------------------------------------------------
34 34 /*!
35 35 // \file PythonQtImporter.h
36 36 // \author Florian Link
37 37 // \author Last changed by $Author: florian $
38 38 // \date 2006-05
39 39 */
40 40 // This module was inspired by the zipimport.c module of the original
41 41 // Python distribution. Most of the functions are identical or slightly
42 42 // modified to do all the loading of Python files via an external file interface.
43 43 // In contrast to zipimport.c, this module also writes *.pyc files
44 44 // automatically if it has write access/is not inside of a zip file.
45 45 //----------------------------------------------------------------------------------
46 46
47 47 #include "PythonQtImporter.h"
48 48 #include "PythonQtImportFileInterface.h"
49 49 #include "PythonQt.h"
50 50 #include "PythonQtConversion.h"
51 51 #include <QFile>
52 52 #include <QFileInfo>
53 53
54 54 #define IS_SOURCE 0x0
55 55 #define IS_BYTECODE 0x1
56 56 #define IS_PACKAGE 0x2
57 57
58 58 struct st_mlab_searchorder {
59 59 char suffix[14];
60 60 int type;
61 61 };
62 62
63 63 /* mlab_searchorder defines how we search for a module in the Zip
64 64 archive: we first search for a package __init__, then for
65 65 non-package .pyc, .pyo and .py entries. The .pyc and .pyo entries
66 66 are swapped by initmlabimport() if we run in optimized mode. Also,
67 67 '/' is replaced by SEP there. */
68 68 struct st_mlab_searchorder mlab_searchorder[] = {
69 69 {"/__init__.pyc", IS_PACKAGE | IS_BYTECODE},
70 70 {"/__init__.pyo", IS_PACKAGE | IS_BYTECODE},
71 71 {"/__init__.py", IS_PACKAGE | IS_SOURCE},
72 72 {".pyc", IS_BYTECODE},
73 73 {".pyo", IS_BYTECODE},
74 74 {".py", IS_SOURCE},
75 75 {"", 0}
76 76 };
77 77
78 78 extern PyTypeObject PythonQtImporter_Type;
79 79 PyObject *PythonQtImportError;
80 80
81 81 QString PythonQtImport::getSubName(const QString& str)
82 82 {
83 83 int idx = str.lastIndexOf('.');
84 84 if (idx!=-1) {
85 85 return str.mid(idx+1);
86 86 } else {
87 87 return str;
88 88 }
89 89 }
90 90
91 91 PythonQtImport::ModuleInfo PythonQtImport::getModuleInfo(PythonQtImporter* self, const QString& fullname)
92 92 {
93 93 ModuleInfo info;
94 94 QString subname;
95 95 struct st_mlab_searchorder *zso;
96 96
97 97 subname = getSubName(fullname);
98 98 QString path = *self->_path + "/" + subname;
99 99
100 100 QString test;
101 101 for (zso = mlab_searchorder; *zso->suffix; zso++) {
102 102 test = path + zso->suffix;
103 103 if (PythonQt::importInterface()->exists(test)) {
104 104 info.fullPath = test;
105 105 info.moduleName = subname;
106 106 info.type = (zso->type & IS_PACKAGE)?MI_PACKAGE:MI_MODULE;
107 107 return info;
108 108 }
109 109 }
110 110 // test if it is a shared library
111 111 foreach(const QString& suffix, PythonQt::priv()->sharedLibrarySuffixes()) {
112 112 test = path+suffix;
113 113 if (PythonQt::importInterface()->exists(test)) {
114 114 info.fullPath = test;
115 115 info.moduleName = subname;
116 116 info.type = MI_SHAREDLIBRARY;
117 117 }
118 118 }
119 119 return info;
120 120 }
121 121
122 122
123 123 /* PythonQtImporter.__init__
124 124 Just store the path argument (or reject if it is in the ignorePaths list
125 125 */
126 126 int PythonQtImporter_init(PythonQtImporter *self, PyObject *args, PyObject * /*kwds*/)
127 127 {
128 128 self->_path = NULL;
129 129
130 130 const char* cpath;
131 131 if (!PyArg_ParseTuple(args, "s",
132 132 &cpath))
133 133 return -1;
134 134
135 135 QString path(cpath);
136 136 if (PythonQt::importInterface()->exists(path)) {
137 137 const QStringList& ignorePaths = PythonQt::self()->getImporterIgnorePaths();
138 138 foreach(QString ignorePath, ignorePaths) {
139 139 if (path.startsWith(ignorePath)) {
140 140 PyErr_SetString(PythonQtImportError,
141 141 "path ignored");
142 142 return -1;
143 143 }
144 144 }
145 145
146 146 self->_path = new QString(path);
147 147 return 0;
148 148 } else {
149 149 PyErr_SetString(PythonQtImportError,
150 150 "path does not exist error");
151 151 return -1;
152 152 }
153 153 }
154 154
155 155 void
156 156 PythonQtImporter_dealloc(PythonQtImporter *self)
157 157 {
158 158 // free the stored path
159 159 if (self->_path) delete self->_path;
160 160 // free ourself
161 161 self->ob_type->tp_free((PyObject *)self);
162 162 }
163 163
164 164
165 165 /* Check whether we can satisfy the import of the module named by
166 166 'fullname'. Return self if we can, None if we can't. */
167 167 PyObject *
168 168 PythonQtImporter_find_module(PyObject *obj, PyObject *args)
169 169 {
170 170 PythonQtImporter *self = (PythonQtImporter *)obj;
171 171 PyObject *path = NULL;
172 172 char *fullname;
173 173
174 174 if (!PyArg_ParseTuple(args, "s|O:PythonQtImporter.find_module",
175 175 &fullname, &path))
176 176 return NULL;
177 177
178 178 //qDebug() << "looking for " << fullname << " at " << *self->_path;
179 179
180 180 PythonQtImport::ModuleInfo info = PythonQtImport::getModuleInfo(self, fullname);
181 181 if (info.type != PythonQtImport::MI_NOT_FOUND) {
182 182 Py_INCREF(self);
183 183 return (PyObject *)self;
184 184 } else {
185 185 Py_INCREF(Py_None);
186 186 return Py_None;
187 187 }
188 188 }
189 189
190 190 /* Load and return the module named by 'fullname'. */
191 191 PyObject *
192 192 PythonQtImporter_load_module(PyObject *obj, PyObject *args)
193 193 {
194 194 PythonQtImporter *self = (PythonQtImporter *)obj;
195 195 PyObject *code = NULL, *mod = NULL, *dict = NULL;
196 196 char *fullname;
197 197
198 198 if (!PyArg_ParseTuple(args, "s:PythonQtImporter.load_module",
199 199 &fullname))
200 200 return NULL;
201 201
202 202 PythonQtImport::ModuleInfo info = PythonQtImport::getModuleInfo(self, fullname);
203 203 if (info.type == PythonQtImport::MI_NOT_FOUND) {
204 204 return NULL;
205 205 }
206 206
207 207 if (info.type == PythonQtImport::MI_PACKAGE || info.type == PythonQtImport::MI_MODULE) {
208 208 QString fullPath;
209 209 code = PythonQtImport::getModuleCode(self, fullname, fullPath);
210 210 if (code == NULL) {
211 211 return NULL;
212 212 }
213 213
214 214 mod = PyImport_AddModule(fullname);
215 215 if (mod == NULL) {
216 216 Py_DECREF(code);
217 217 return NULL;
218 218 }
219 219 dict = PyModule_GetDict(mod);
220 220
221 221 if (PyDict_SetItemString(dict, "__loader__", (PyObject *)self) != 0) {
222 222 Py_DECREF(code);
223 223 Py_DECREF(mod);
224 224 return NULL;
225 225 }
226 226
227 227 if (info.type == PythonQtImport::MI_PACKAGE) {
228 228 PyObject *pkgpath, *fullpath;
229 229 QString subname = info.moduleName;
230 230 int err;
231 231
232 232 fullpath = PyString_FromFormat("%s%c%s",
233 233 self->_path->toLatin1().constData(),
234 234 SEP,
235 235 subname.toLatin1().constData());
236 236 if (fullpath == NULL) {
237 237 Py_DECREF(code);
238 238 Py_DECREF(mod);
239 239 return NULL;
240 240 }
241 241
242 242 pkgpath = Py_BuildValue("[O]", fullpath);
243 243 Py_DECREF(fullpath);
244 244 if (pkgpath == NULL) {
245 245 Py_DECREF(code);
246 246 Py_DECREF(mod);
247 247 return NULL;
248 248 }
249 249 err = PyDict_SetItemString(dict, "__path__", pkgpath);
250 250 Py_DECREF(pkgpath);
251 251 if (err != 0) {
252 252 Py_DECREF(code);
253 253 Py_DECREF(mod);
254 254 return NULL;
255 255 }
256 256 }
257 257 mod = PyImport_ExecCodeModuleEx(fullname, code, fullPath.toLatin1().data());
258 258 Py_DECREF(code);
259 259 if (Py_VerboseFlag) {
260 260 PySys_WriteStderr("import %s # loaded from %s\n",
261 261 fullname, fullPath.toLatin1().constData());
262 262 }
263 263 } else {
264 264 PythonQtObjectPtr imp;
265 265 imp.setNewRef(PyImport_ImportModule("imp"));
266 266
267 267 // Create a PyList with the current path as its single element,
268 268 // which is required for find_module (it won't accept a tuple...)
269 269 PythonQtObjectPtr pathList;
270 270 pathList.setNewRef(PythonQtConv::QStringListToPyList(QStringList() << *self->_path));
271 271
272 272 QVariantList args;
273 273 // Pass the module name without the package prefix
274 274 args.append(info.moduleName);
275 275 // And the path where we know that the shared library is
276 276 args.append(QVariant::fromValue(pathList));
277 277 QVariant result = imp.call("find_module", args);
278 278 if (result.isValid()) {
279 279 // This will return a tuple with (file, pathname, description)
280 280 QVariantList list = result.toList();
281 281 if (list.count()==3) {
282 282 // We prepend the full module name (including package prefix)
283 283 list.prepend(fullname);
284 284 // And call "load_module" with (fullname, file, pathname, description)
285 285 PythonQtObjectPtr module = imp.call("load_module", list);
286 286 mod = module.object();
287 287 if (mod) {
288 288 Py_INCREF(mod);
289 289 }
290 290
291 291 // Finally, we need to close the file again, which find_module opened for us
292 292 PythonQtObjectPtr file = list.at(1);
293 293 file.call("close");
294 294 }
295 295 }
296 296 }
297 297 return mod;
298 298 }
299 299
300 300
301 301 PyObject *
302 302 PythonQtImporter_get_data(PyObject* /*obj*/, PyObject* /*args*/)
303 303 {
304 304 // EXTRA, NOT YET IMPLEMENTED
305 305 return NULL;
306 306 }
307 307
308 308 PyObject *
309 309 PythonQtImporter_get_code(PyObject *obj, PyObject *args)
310 310 {
311 311 PythonQtImporter *self = (PythonQtImporter *)obj;
312 312 char *fullname;
313 313
314 314 if (!PyArg_ParseTuple(args, "s:PythonQtImporter.get_code", &fullname))
315 315 return NULL;
316 316
317 317 QString notused;
318 318 return PythonQtImport::getModuleCode(self, fullname, notused);
319 319 }
320 320
321 321 PyObject *
322 322 PythonQtImporter_get_source(PyObject * /*obj*/, PyObject * /*args*/)
323 323 {
324 324 // EXTRA, NOT YET IMPLEMENTED
325 325 return NULL;
326 326 }
327 327
328 328 PyDoc_STRVAR(doc_find_module,
329 329 "find_module(fullname, path=None) -> self or None.\n\
330 330 \n\
331 331 Search for a module specified by 'fullname'. 'fullname' must be the\n\
332 332 fully qualified (dotted) module name. It returns the PythonQtImporter\n\
333 333 instance itself if the module was found, or None if it wasn't.\n\
334 334 The optional 'path' argument is ignored -- it's there for compatibility\n\
335 335 with the importer protocol.");
336 336
337 337 PyDoc_STRVAR(doc_load_module,
338 338 "load_module(fullname) -> module.\n\
339 339 \n\
340 340 Load the module specified by 'fullname'. 'fullname' must be the\n\
341 341 fully qualified (dotted) module name. It returns the imported\n\
342 342 module, or raises PythonQtImportError if it wasn't found.");
343 343
344 344 PyDoc_STRVAR(doc_get_data,
345 345 "get_data(pathname) -> string with file data.\n\
346 346 \n\
347 347 Return the data associated with 'pathname'. Raise IOError if\n\
348 348 the file wasn't found.");
349 349
350 350 PyDoc_STRVAR(doc_get_code,
351 351 "get_code(fullname) -> code object.\n\
352 352 \n\
353 353 Return the code object for the specified module. Raise PythonQtImportError\n\
354 354 is the module couldn't be found.");
355 355
356 356 PyDoc_STRVAR(doc_get_source,
357 357 "get_source(fullname) -> source string.\n\
358 358 \n\
359 359 Return the source code for the specified module. Raise PythonQtImportError\n\
360 360 is the module couldn't be found, return None if the archive does\n\
361 361 contain the module, but has no source for it.");
362 362
363 363 PyMethodDef PythonQtImporter_methods[] = {
364 364 {"find_module", PythonQtImporter_find_module, METH_VARARGS,
365 365 doc_find_module},
366 366 {"load_module", PythonQtImporter_load_module, METH_VARARGS,
367 367 doc_load_module},
368 368 {"get_data", PythonQtImporter_get_data, METH_VARARGS,
369 369 doc_get_data},
370 370 {"get_code", PythonQtImporter_get_code, METH_VARARGS,
371 371 doc_get_code},
372 372 {"get_source", PythonQtImporter_get_source, METH_VARARGS,
373 373 doc_get_source},
374 374 {NULL, NULL, 0 , NULL} /* sentinel */
375 375 };
376 376
377 377
378 378 PyDoc_STRVAR(PythonQtImporter_doc,
379 379 "PythonQtImporter(path) -> PythonQtImporter object\n\
380 380 \n\
381 381 Create a new PythonQtImporter instance. 'path' must be a valid path on disk/or inside of a zip file known to MeVisLab\n\
382 382 . Every path is accepted.");
383 383
384 384 #define DEFERRED_ADDRESS(ADDR) 0
385 385
386 386 PyTypeObject PythonQtImporter_Type = {
387 387 PyObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type))
388 388 0,
389 389 "PythonQtImport.PythonQtImporter",
390 390 sizeof(PythonQtImporter),
391 391 0, /* tp_itemsize */
392 392 (destructor)PythonQtImporter_dealloc, /* tp_dealloc */
393 393 0, /* tp_print */
394 394 0, /* tp_getattr */
395 395 0, /* tp_setattr */
396 396 0, /* tp_compare */
397 397 0, /* tp_repr */
398 398 0, /* tp_as_number */
399 399 0, /* tp_as_sequence */
400 400 0, /* tp_as_mapping */
401 401 0, /* tp_hash */
402 402 0, /* tp_call */
403 403 0, /* tp_str */
404 404 PyObject_GenericGetAttr, /* tp_getattro */
405 405 0, /* tp_setattro */
406 406 0, /* tp_as_buffer */
407 407 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE , /* tp_flags */
408 408 PythonQtImporter_doc, /* tp_doc */
409 409 0, /* tp_traverse */
410 410 0, /* tp_clear */
411 411 0, /* tp_richcompare */
412 412 0, /* tp_weaklistoffset */
413 413 0, /* tp_iter */
414 414 0, /* tp_iternext */
415 415 PythonQtImporter_methods, /* tp_methods */
416 416 0, /* tp_members */
417 417 0, /* tp_getset */
418 418 0, /* tp_base */
419 419 0, /* tp_dict */
420 420 0, /* tp_descr_get */
421 421 0, /* tp_descr_set */
422 422 0, /* tp_dictoffset */
423 423 (initproc)PythonQtImporter_init, /* tp_init */
424 424 PyType_GenericAlloc, /* tp_alloc */
425 425 PyType_GenericNew, /* tp_new */
426 426 PyObject_Del, /* tp_free */
427 427 };
428 428
429 429
430 430 /* Given a buffer, return the long that is represented by the first
431 431 4 bytes, encoded as little endian. This partially reimplements
432 432 marshal.c:r_long() */
433 433 long
434 434 PythonQtImport::getLong(unsigned char *buf)
435 435 {
436 436 long x;
437 437 x = buf[0];
438 438 x |= (long)buf[1] << 8;
439 439 x |= (long)buf[2] << 16;
440 440 x |= (long)buf[3] << 24;
441 441 #if SIZEOF_LONG > 4
442 442 /* Sign extension for 64-bit machines */
443 443 x |= -(x & 0x80000000L);
444 444 #endif
445 445 return x;
446 446 }
447 447
448 448 FILE *
449 449 open_exclusive(const QString& filename)
450 450 {
451 451 #if defined(O_EXCL)&&defined(O_CREAT)&&defined(O_WRONLY)&&defined(O_TRUNC)
452 452 /* Use O_EXCL to avoid a race condition when another process tries to
453 453 write the same file. When that happens, our open() call fails,
454 454 which is just fine (since it's only a cache).
455 455 XXX If the file exists and is writable but the directory is not
456 456 writable, the file will never be written. Oh well.
457 457 */
458 458 QFile::remove(filename);
459 459
460 460 int fd;
461 461 int flags = O_EXCL|O_CREAT|O_WRONLY|O_TRUNC;
462 462 #ifdef O_BINARY
463 463 flags |= O_BINARY; /* necessary for Windows */
464 464 #endif
465 465 #ifdef WIN32
466 466 fd = _wopen(filename.ucs2(), flags, 0666);
467 467 #else
468 468 fd = open(filename.local8Bit(), flags, 0666);
469 469 #endif
470 470 if (fd < 0)
471 471 return NULL;
472 472 return fdopen(fd, "wb");
473 473 #else
474 474 /* Best we can do -- on Windows this can't happen anyway */
475 475 return fopen(filename.toLocal8Bit().constData(), "wb");
476 476 #endif
477 477 }
478 478
479 479
480 480 void PythonQtImport::writeCompiledModule(PyCodeObject *co, const QString& filename, long mtime)
481 481 {
482 482 FILE *fp;
483 483 // we do not want to write Qt resources to disk, do we?
484 484 if (filename.startsWith(":")) {
485 485 return;
486 486 }
487 487 fp = open_exclusive(filename);
488 488 if (fp == NULL) {
489 489 if (Py_VerboseFlag)
490 490 PySys_WriteStderr(
491 491 "# can't create %s\n", filename.toLatin1().constData());
492 492 return;
493 493 }
494 494 #if PY_VERSION_HEX < 0x02040000
495 495 PyMarshal_WriteLongToFile(PyImport_GetMagicNumber(), fp);
496 496 #else
497 497 PyMarshal_WriteLongToFile(PyImport_GetMagicNumber(), fp, Py_MARSHAL_VERSION);
498 498 #endif
499 499 /* First write a 0 for mtime */
500 500 #if PY_VERSION_HEX < 0x02040000
501 501 PyMarshal_WriteLongToFile(0L, fp);
502 502 #else
503 503 PyMarshal_WriteLongToFile(0L, fp, Py_MARSHAL_VERSION);
504 504 #endif
505 505 #if PY_VERSION_HEX < 0x02040000
506 506 PyMarshal_WriteObjectToFile((PyObject *)co, fp);
507 507 #else
508 508 PyMarshal_WriteObjectToFile((PyObject *)co, fp, Py_MARSHAL_VERSION);
509 509 #endif
510 510 if (ferror(fp)) {
511 511 if (Py_VerboseFlag)
512 512 PySys_WriteStderr("# can't write %s\n", filename.toLatin1().constData());
513 513 /* Don't keep partial file */
514 514 fclose(fp);
515 515 QFile::remove(filename);
516 516 return;
517 517 }
518 518 /* Now write the true mtime */
519 519 fseek(fp, 4L, 0);
520 520 #if PY_VERSION_HEX < 0x02040000
521 521 PyMarshal_WriteLongToFile(mtime, fp);
522 522 #else
523 523 PyMarshal_WriteLongToFile(mtime, fp, Py_MARSHAL_VERSION);
524 524 #endif
525 525 fflush(fp);
526 526 fclose(fp);
527 527 if (Py_VerboseFlag)
528 528 PySys_WriteStderr("# wrote %s\n", filename.toLatin1().constData());
529 529 //#ifdef macintosh
530 530 // PyMac_setfiletype(cpathname, 'Pyth', 'PYC ');
531 531 //#endif
532 532 }
533 533
534 534 /* Given the contents of a .py[co] file in a buffer, unmarshal the data
535 535 and return the code object. Return None if it the magic word doesn't
536 536 match (we do this instead of raising an exception as we fall back
537 537 to .py if available and we don't want to mask other errors).
538 538 Returns a new reference. */
539 539 PyObject *
540 540 PythonQtImport::unmarshalCode(const QString& path, const QByteArray& data, time_t mtime)
541 541 {
542 542 PyObject *code;
543 543 // ugly cast, but Python API is not const safe
544 544 char *buf = (char*) data.constData();
545 545 int size = data.size();
546 546
547 547 if (size <= 9) {
548 548 PySys_WriteStderr("# %s has bad pyc data\n",
549 549 path.toLatin1().constData());
550 550 Py_INCREF(Py_None);
551 551 return Py_None;
552 552 }
553 553
554 554 if (getLong((unsigned char *)buf) != PyImport_GetMagicNumber()) {
555 555 if (Py_VerboseFlag)
556 556 PySys_WriteStderr("# %s has bad magic\n",
557 557 path.toLatin1().constData());
558 558 Py_INCREF(Py_None);
559 559 return Py_None;
560 560 }
561 561
562 562 if (mtime != 0 && !(getLong((unsigned char *)buf + 4) == mtime)) {
563 563 if (Py_VerboseFlag)
564 564 PySys_WriteStderr("# %s has bad mtime\n",
565 565 path.toLatin1().constData());
566 566 Py_INCREF(Py_None);
567 567 return Py_None;
568 568 }
569 569
570 570 code = PyMarshal_ReadObjectFromString(buf + 8, size - 8);
571 571 if (code == NULL)
572 572 return NULL;
573 573 if (!PyCode_Check(code)) {
574 574 Py_DECREF(code);
575 575 PyErr_Format(PyExc_TypeError,
576 576 "compiled module %.200s is not a code object",
577 577 path.toLatin1().constData());
578 578 return NULL;
579 579 }
580 580 return code;
581 581 }
582 582
583 583
584 584 /* Given a string buffer containing Python source code, compile it
585 585 return and return a code object as a new reference. */
586 586 PyObject *
587 587 PythonQtImport::compileSource(const QString& path, const QByteArray& data)
588 588 {
589 589 PyObject *code;
590 590 QByteArray data1 = data;
591 591 // in qt4, data is null terminated
592 592 // data1.resize(data.size()+1);
593 593 // data1.data()[data.size()-1] = 0;
594 594 code = Py_CompileString(data.data(), path.toLatin1().constData(),
595 595 Py_file_input);
596 596 return code;
597 597 }
598 598
599 599
600 600 /* Return the code object for the module named by 'fullname' from the
601 601 Zip archive as a new reference. */
602 602 PyObject *
603 603 PythonQtImport::getCodeFromData(const QString& path, int isbytecode,int /*ispackage*/, time_t mtime)
604 604 {
605 605 PyObject *code;
606 606
607 607 QByteArray qdata;
608 608 if (!isbytecode) {
609 609 // mlabDebugConst("MLABPython", "reading source " << path);
610 610 bool ok;
611 611 qdata = PythonQt::importInterface()->readSourceFile(path, ok);
612 612 if (!ok) {
613 613 // mlabErrorConst("PythonQtImporter","File could not be verified" << path);
614 614 return NULL;
615 615 }
616 616 if (qdata == " ") {
617 617 qdata.clear();
618 618 }
619 619 } else {
620 620 qdata = PythonQt::importInterface()->readFileAsBytes(path);
621 621 }
622 622
623 623 if (isbytecode) {
624 624 // mlabDebugConst("MLABPython", "reading bytecode " << path);
625 625 code = unmarshalCode(path, qdata, mtime);
626 626 }
627 627 else {
628 628 // mlabDebugConst("MLABPython", "compiling source " << path);
629 629 code = compileSource(path, qdata);
630 630 if (code) {
631 631 // save a pyc file if possible
632 632 QDateTime time;
633 633 time = PythonQt::importInterface()->lastModifiedDate(path);
634 634 writeCompiledModule((PyCodeObject*)code, path+"c", time.toTime_t());
635 635 }
636 636 }
637 637 return code;
638 638 }
639 639
640 640 time_t
641 641 PythonQtImport::getMTimeOfSource(const QString& path)
642 642 {
643 643 time_t mtime = 0;
644 644 QString path2 = path;
645 645 path2.truncate(path.length()-1);
646 646
647 647 if (PythonQt::importInterface()->exists(path2)) {
648 648 mtime = PythonQt::importInterface()->lastModifiedDate(path2).toTime_t();
649 649 }
650 650
651 651 return mtime;
652 652 }
653 653
654 654 /* Get the code object associated with the module specified by
655 655 'fullname'. */
656 656 PyObject *
657 657 PythonQtImport::getModuleCode(PythonQtImporter *self, const char* fullname, QString& modpath)
658 658 {
659 659 QString subname;
660 660 struct st_mlab_searchorder *zso;
661 661
662 662 subname = getSubName(fullname);
663 663 QString path = *self->_path + "/" + subname;
664 664
665 665 QString test;
666 666 for (zso = mlab_searchorder; *zso->suffix; zso++) {
667 667 PyObject *code = NULL;
668 668 test = path + zso->suffix;
669 669
670 670 if (Py_VerboseFlag > 1)
671 671 PySys_WriteStderr("# trying %s\n",
672 672 test.toLatin1().constData());
673 673 if (PythonQt::importInterface()->exists(test)) {
674 674 time_t mtime = 0;
675 675 int ispackage = zso->type & IS_PACKAGE;
676 676 int isbytecode = zso->type & IS_BYTECODE;
677 677
678 678 if (isbytecode) {
679 679 mtime = getMTimeOfSource(test);
680 680 }
681 681 code = getCodeFromData(test, isbytecode, ispackage, mtime);
682 682 if (code == Py_None) {
683 683 Py_DECREF(code);
684 684 continue;
685 685 }
686 686 if (code != NULL) {
687 687 modpath = test;
688 688 }
689 689 return code;
690 690 }
691 691 }
692 692 PyErr_Format(PythonQtImportError, "can't find module '%.200s'", fullname);
693 693
694 694 return NULL;
695 695 }
696 696
697 697 QString PythonQtImport::replaceExtension(const QString& str, const QString& ext)
698 698 {
699 699 QString r;
700 700 int i = str.lastIndexOf('.');
701 701 if (i!=-1) {
702 702 r = str.mid(0,i) + "." + ext;
703 703 } else {
704 704 r = str + "." + ext;
705 705 }
706 706 return r;
707 707 }
708 708
709 709 PyObject* PythonQtImport::getCodeFromPyc(const QString& file)
710 710 {
711 711 PyObject* code;
712 712 const static QString pycStr("pyc");
713 713 QString pyc = replaceExtension(file, pycStr);
714 714 if (PythonQt::importInterface()->exists(pyc)) {
715 715 time_t mtime = 0;
716 716 mtime = getMTimeOfSource(pyc);
717 717 code = getCodeFromData(pyc, true, false, mtime);
718 718 if (code != Py_None && code != NULL) {
719 719 return code;
720 720 }
721 721 if (code) {
722 722 Py_DECREF(code);
723 723 }
724 724 }
725 725 code = getCodeFromData(file,false,false,0);
726 726 return code;
727 727 }
728 728
729 729 /* Module init */
730 730
731 731 PyDoc_STRVAR(mlabimport_doc,
732 732 "Imports python files into PythonQt, completely replaces internal python import");
733 733
734 734 void PythonQtImport::init()
735 735 {
736 736 static bool first = true;
737 737 if (!first) {
738 738 return;
739 739 }
740 740 first = false;
741 741
742 742 PyObject *mod;
743 743
744 744 if (PyType_Ready(&PythonQtImporter_Type) < 0)
745 745 return;
746 746
747 747 /* Correct directory separator */
748 748 mlab_searchorder[0].suffix[0] = SEP;
749 749 mlab_searchorder[1].suffix[0] = SEP;
750 750 mlab_searchorder[2].suffix[0] = SEP;
751 751 if (Py_OptimizeFlag) {
752 752 /* Reverse *.pyc and *.pyo */
753 753 struct st_mlab_searchorder tmp;
754 754 tmp = mlab_searchorder[0];
755 755 mlab_searchorder[0] = mlab_searchorder[1];
756 756 mlab_searchorder[1] = tmp;
757 757 tmp = mlab_searchorder[3];
758 758 mlab_searchorder[3] = mlab_searchorder[4];
759 759 mlab_searchorder[4] = tmp;
760 760 }
761 761
762 762 mod = Py_InitModule4("PythonQtImport", NULL, mlabimport_doc,
763 763 NULL, PYTHON_API_VERSION);
764 764
765 765 PythonQtImportError = PyErr_NewException("PythonQtImport.PythonQtImportError",
766 766 PyExc_ImportError, NULL);
767 767 if (PythonQtImportError == NULL)
768 768 return;
769 769
770 770 Py_INCREF(PythonQtImportError);
771 771 if (PyModule_AddObject(mod, "PythonQtImportError",
772 772 PythonQtImportError) < 0)
773 773 return;
774 774
775 775 Py_INCREF(&PythonQtImporter_Type);
776 776 if (PyModule_AddObject(mod, "PythonQtImporter",
777 777 (PyObject *)&PythonQtImporter_Type) < 0)
778 778 return;
779 779
780 780 // set our importer into the path_hooks to handle all path on sys.path
781 781 PyObject* classobj = PyDict_GetItemString(PyModule_GetDict(mod), "PythonQtImporter");
782 782 PyObject* path_hooks = PySys_GetObject("path_hooks");
783 783 PyList_Append(path_hooks, classobj);
784 784
785 785 #ifndef WIN32
786 786 // reload the encodings module, because it might fail to custom import requirements (e.g. encryption).
787 787 PyObject* modules = PyImport_GetModuleDict();
788 788 PyObject* encodingsModule = PyDict_GetItemString(modules, "encodings");
789 789 if (encodingsModule != NULL) {
790 790 PyImport_ReloadModule(encodingsModule);
791 791 }
792 792 #endif
793 793 }
Show file before | Show file after | Hide comments
@@ -1,137 +1,137
1 1 #ifndef _PYTHONQTIMPORTER_
2 2 #define _PYTHONQTIMPORTER_
3 3
4 4 /*
5 5 *
6 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
6 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
7 7 *
8 8 * This library is free software; you can redistribute it and/or
9 9 * modify it under the terms of the GNU Lesser General Public
10 10 * License as published by the Free Software Foundation; either
11 11 * version 2.1 of the License, or (at your option) any later version.
12 12 *
13 13 * This library is distributed in the hope that it will be useful,
14 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 16 * Lesser General Public License for more details.
17 17 *
18 18 * Further, this software is distributed without any warranty that it is
19 19 * free of the rightful claim of any third person regarding infringement
20 20 * or the like. Any license provided herein, whether implied or
21 21 * otherwise, applies only to this software file. Patent licenses, if
22 22 * any, provided herein do not apply to combinations of this program with
23 23 * other software, or any other product whatsoever.
24 24 *
25 25 * You should have received a copy of the GNU Lesser General Public
26 26 * License along with this library; if not, write to the Free Software
27 27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 28 *
29 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
29 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
30 30 * 28359 Bremen, Germany or:
31 31 *
32 32 * http://www.mevis.de
33 33 *
34 34 */
35 35
36 36 //----------------------------------------------------------------------------------
37 37 /*!
38 38 // \file PythonQtImporter.h
39 39 // \author Florian Link
40 40 // \author Last changed by $Author: stk $
41 41 // \date 2004-06
42 42 */
43 43 //----------------------------------------------------------------------------------
44 44
45 45 #include "Python.h"
46 46 #include "structmember.h"
47 47 #include "osdefs.h"
48 48 #include "marshal.h"
49 49 #include "compile.h"
50 50 #include <time.h>
51 51
52 52 #include <qobject.h>
53 53 #include <qstring.h>
54 54
55 55
56 56 //! defines a python object that stores a Qt slot info
57 57 typedef struct _PythonQtImporter {
58 58 PyObject_HEAD
59 59 QString* _path;
60 60 } PythonQtImporter;
61 61
62 62
63 63 //! implements importing of python files into PythonQt
64 64 /*! also compiles/marshalls/unmarshalls py/pyc files and handles time stamps correctly
65 65 */
66 66 class PythonQtImport
67 67 {
68 68 public:
69 69
70 70 enum ModuleType {
71 71 MI_NOT_FOUND,
72 72 MI_MODULE,
73 73 MI_PACKAGE,
74 74 MI_SHAREDLIBRARY
75 75 };
76 76
77 77 struct ModuleInfo {
78 78 ModuleInfo() {
79 79 type = MI_NOT_FOUND;
80 80 }
81 81 QString fullPath; //!< the full path to the found file
82 82 QString moduleName; //!< the module name without the package prefix
83 83 ModuleType type;
84 84 };
85 85
86 86 //! initialize
87 87 static void init();
88 88
89 89 //! writes the python code to disk, marshalling and writing the time stamp
90 90 static void writeCompiledModule(PyCodeObject *co, const QString& filename, long mtime);
91 91
92 92 /*! Given the contents of a .py[co] file in a buffer, unmarshal the data
93 93 and return the code object. Return None if it the magic word doesn't
94 94 match (we do this instead of raising an exception as we fall back
95 95 to .py if available and we don't want to mask other errors).
96 96 Returns a new reference. */
97 97 static PyObject *unmarshalCode(const QString& path, const QByteArray& data, time_t mtime);
98 98
99 99 //! Given a string buffer containing Python source code, compile it
100 100 //! return and return a code object as a new reference.
101 101 static PyObject *compileSource(const QString& path, const QByteArray& data);
102 102
103 103 //! Return the code object for the module named by 'fullname' from the
104 104 //! Zip archive as a new reference.
105 105 static PyObject *getCodeFromData(const QString& path, int isbytecode = 0, int ispackage = 0,
106 106 time_t mtime = 0);
107 107
108 108 //! Get the code object associated with the module specified by
109 109 //! 'fullname'.
110 110 static PyObject * getModuleCode(PythonQtImporter *self,
111 111 const char* fullname, QString& modpath);
112 112
113 113
114 114 //! gets the compiled code for the given *.py file if there is a valid pyc file, otherwise compiles the file and writes the pyc
115 115 static PyObject* getCodeFromPyc(const QString& file);
116 116
117 117 //! Return if module exists and is a package or a module
118 118 static ModuleInfo getModuleInfo(PythonQtImporter* self, const QString& fullname);
119 119
120 120 //! get the last name of a dot chain (first.second.last)
121 121 static QString getSubName(const QString& str);
122 122
123 123 //! Given a buffer, return the long that is represented by the first
124 124 //! 4 bytes, encoded as little endian. This partially reimplements
125 125 //! marshal.c:r_long()
126 126 static long getLong(unsigned char *buf);
127 127
128 128 //! get time stamp of file
129 129 static time_t getMTimeOfSource(const QString& path);
130 130
131 131 //! replace extension of file
132 132 static QString replaceExtension(const QString& str, const QString& ext);
133 133
134 134 };
135 135
136 136 #endif
137 137
Show file before | Show file after | Hide comments
@@ -1,726 +1,726
1 1 /*
2 2 *
3 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
3 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
4 4 *
5 5 * This library is free software; you can redistribute it and/or
6 6 * modify it under the terms of the GNU Lesser General Public
7 7 * License as published by the Free Software Foundation; either
8 8 * version 2.1 of the License, or (at your option) any later version.
9 9 *
10 10 * This library is distributed in the hope that it will be useful,
11 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 13 * Lesser General Public License for more details.
14 14 *
15 15 * Further, this software is distributed without any warranty that it is
16 16 * free of the rightful claim of any third person regarding infringement
17 17 * or the like. Any license provided herein, whether implied or
18 18 * otherwise, applies only to this software file. Patent licenses, if
19 19 * any, provided herein do not apply to combinations of this program with
20 20 * other software, or any other product whatsoever.
21 21 *
22 22 * You should have received a copy of the GNU Lesser General Public
23 23 * License along with this library; if not, write to the Free Software
24 24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 25 *
26 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
26 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
27 27 * 28359 Bremen, Germany or:
28 28 *
29 29 * http://www.mevis.de
30 30 *
31 31 */
32 32
33 33 //----------------------------------------------------------------------------------
34 34 /*!
35 35 // \file PythonQtInstanceWrapper.cpp
36 36 // \author Florian Link
37 37 // \author Last changed by $Author: florian $
38 38 // \date 2006-05
39 39 */
40 40 //----------------------------------------------------------------------------------
41 41
42 42 #include "PythonQtInstanceWrapper.h"
43 43 #include <QObject>
44 44 #include "PythonQt.h"
45 45 #include "PythonQtSlot.h"
46 46 #include "PythonQtClassInfo.h"
47 47 #include "PythonQtConversion.h"
48 48 #include "PythonQtClassWrapper.h"
49 49
50 50 PythonQtClassInfo* PythonQtInstanceWrapperStruct::classInfo()
51 51 {
52 52 // take the class info from our type object
53 53 return ((PythonQtClassWrapper*)ob_type)->_classInfo;
54 54 }
55 55
56 56 static void PythonQtInstanceWrapper_deleteObject(PythonQtInstanceWrapper* self, bool force = false) {
57 57
58 58 // is this a C++ wrapper?
59 59 if (self->_wrappedPtr) {
60 60 //mlabDebugConst("Python","c++ wrapper removed " << self->_wrappedPtr << " " << self->_obj->className() << " " << self->classInfo()->wrappedClassName().latin1());
61 61
62 62 PythonQt::priv()->removeWrapperPointer(self->_wrappedPtr);
63 63 // we own our qobject, so we delete it now:
64 64 delete self->_obj;
65 65 self->_obj = NULL;
66 66 if (force || self->classInfo()->hasOwnerMethodButNoOwner(self->_wrappedPtr) || self->_ownedByPythonQt) {
67 67 int type = self->classInfo()->metaTypeId();
68 68 if (self->_useQMetaTypeDestroy && type>=0) {
69 69 // use QMetaType to destroy the object
70 70 QMetaType::destroy(type, self->_wrappedPtr);
71 71 } else {
72 72 PythonQtSlotInfo* slot = self->classInfo()->destructor();
73 73 if (slot) {
74 74 void* args[2];
75 75 args[0] = NULL;
76 76 args[1] = &self->_wrappedPtr;
77 77 slot->decorator()->qt_metacall(QMetaObject::InvokeMetaMethod, slot->slotIndex(), args);
78 78 self->_wrappedPtr = NULL;
79 79 } else {
80 80 if (type>=0) {
81 81 // use QMetaType to destroy the object
82 82 QMetaType::destroy(type, self->_wrappedPtr);
83 83 } else {
84 84 // TODO: warn about not being able to destroy the object?
85 85 }
86 86 }
87 87 }
88 88 }
89 89 } else {
90 90 //mlabDebugConst("Python","qobject wrapper removed " << self->_obj->className() << " " << self->classInfo()->wrappedClassName().latin1());
91 91 if (self->_objPointerCopy) {
92 92 PythonQt::priv()->removeWrapperPointer(self->_objPointerCopy);
93 93 }
94 94 if (self->_obj) {
95 95 if (force || self->_ownedByPythonQt) {
96 96 if (force || !self->_obj->parent()) {
97 97 delete self->_obj;
98 98 }
99 99 } else {
100 100 if (self->_obj->parent()==NULL) {
101 101 // tell someone who is interested that the qobject is no longer wrapped, if it has no parent
102 102 PythonQt::qObjectNoLongerWrappedCB(self->_obj);
103 103 }
104 104 }
105 105 }
106 106 }
107 107 self->_obj = NULL;
108 108 }
109 109
110 110 static void PythonQtInstanceWrapper_dealloc(PythonQtInstanceWrapper* self)
111 111 {
112 112 PythonQtInstanceWrapper_deleteObject(self);
113 113 self->_obj.~QPointer<QObject>();
114 114 self->ob_type->tp_free((PyObject*)self);
115 115 }
116 116
117 117 static PyObject* PythonQtInstanceWrapper_new(PyTypeObject *type, PyObject * /*args*/, PyObject * /*kwds*/)
118 118 {
119 119 //PythonQtClassWrapper *classType = (PythonQtClassWrapper*)type;
120 120 PythonQtInstanceWrapper *self;
121 121 static PyObject* emptyTuple = NULL;
122 122 if (emptyTuple==NULL) {
123 123 emptyTuple = PyTuple_New(0);
124 124 }
125 125
126 126 self = (PythonQtInstanceWrapper*)PyBaseObject_Type.tp_new(type, emptyTuple, NULL);
127 127
128 128 if (self != NULL) {
129 129 new (&self->_obj) QPointer<QObject>();
130 130 self->_wrappedPtr = NULL;
131 131 self->_ownedByPythonQt = false;
132 132 self->_useQMetaTypeDestroy = false;
133 133 self->_isShellInstance = false;
134 134 }
135 135 return (PyObject *)self;
136 136 }
137 137
138 138 int PythonQtInstanceWrapper_init(PythonQtInstanceWrapper * self, PyObject * args, PyObject * kwds)
139 139 {
140 140 if (args == PythonQtPrivate::dummyTuple()) {
141 141 // we are called from the internal PythonQt API, so our data will be filled later on...
142 142 return 0;
143 143 }
144 144
145 145 // we are called from python, try to construct our object
146 146 if (self->classInfo()->constructors()) {
147 147 void* directCPPPointer = NULL;
148 148 PythonQtSlotFunction_CallImpl(self->classInfo(), NULL, self->classInfo()->constructors(), args, kwds, NULL, &directCPPPointer);
149 149 if (PyErr_Occurred()) {
150 150 return -1;
151 151 }
152 152 if (directCPPPointer) {
153 153 // change ownershipflag to be owned by PythonQt
154 154 self->_ownedByPythonQt = true;
155 155 self->_useQMetaTypeDestroy = false;
156 156 if (self->classInfo()->isCPPWrapper()) {
157 157 self->_wrappedPtr = directCPPPointer;
158 158 // TODO xxx: if there is a wrapper factory, we might want to generate a wrapper for our class?!
159 159 } else {
160 160 self->setQObject((QObject*)directCPPPointer);
161 161 }
162 162 // register with PythonQt
163 163 PythonQt::priv()->addWrapperPointer(directCPPPointer, self);
164 164
165 165 PythonQtShellSetInstanceWrapperCB* cb = self->classInfo()->shellSetInstanceWrapperCB();
166 166 if (cb) {
167 167 // if we are a derived python class, we set the wrapper
168 168 // to activate the shell class, otherwise we just ignore that it is a shell...
169 169 // we detect it be checking if the type does not have PythonQtInstanceWrapper_Type as direct base class,
170 170 // which is the case for all non-python derived types
171 171 if (((PyObject*)self)->ob_type->tp_base != &PythonQtInstanceWrapper_Type) {
172 172 // set the wrapper and remember that we have a shell instance!
173 173 (*cb)(directCPPPointer, self);
174 174 self->_isShellInstance = true;
175 175 }
176 176 }
177 177 }
178 178 } else {
179 179 QString error = QString("No constructors available for ") + self->classInfo()->className();
180 180 PyErr_SetString(PyExc_ValueError, error.toLatin1().data());
181 181 return -1;
182 182 }
183 183 return 0;
184 184 }
185 185
186 186 static PyObject *PythonQtInstanceWrapper_richcompare(PythonQtInstanceWrapper* wrapper, PyObject* other, int code)
187 187 {
188 188 bool validPtrs = false;
189 189 bool areSamePtrs = false;
190 190 if (PyObject_TypeCheck((PyObject*)wrapper, &PythonQtInstanceWrapper_Type)) {
191 191 if (PyObject_TypeCheck(other, &PythonQtInstanceWrapper_Type)) {
192 192 validPtrs = true;
193 193 PythonQtInstanceWrapper* w1 = wrapper;
194 194 PythonQtInstanceWrapper* w2 = (PythonQtInstanceWrapper*)other;
195 195 // check pointers directly
196 196 if (w1->_wrappedPtr != NULL) {
197 197 if (w1->_wrappedPtr == w2->_wrappedPtr) {
198 198 areSamePtrs = true;
199 199 }
200 200 } else if (w1->_obj == w2->_obj) {
201 201 areSamePtrs = true;
202 202 }
203 203 } else if (other == Py_None) {
204 204 validPtrs = true;
205 205 if (wrapper->_obj || wrapper->_wrappedPtr) {
206 206 areSamePtrs = false;
207 207 } else {
208 208 areSamePtrs = true;
209 209 }
210 210 }
211 211 }
212 212
213 213 if ((wrapper->classInfo()->typeSlots() & PythonQt::Type_RichCompare) == 0) {
214 214 // shortcut if richcompare is not supported:
215 215 if (validPtrs && code == Py_EQ) {
216 216 return PythonQtConv::GetPyBool(areSamePtrs);
217 217 } else if (validPtrs && code == Py_NE) {
218 218 return PythonQtConv::GetPyBool(!areSamePtrs);
219 219 }
220 220 Py_INCREF(Py_NotImplemented);
221 221 return Py_NotImplemented;
222 222 }
223 223
224 224 QByteArray memberName;
225 225 switch (code) {
226 226 case Py_LT:
227 227 {
228 228 static QByteArray name = "__lt__";
229 229 memberName = name;
230 230 }
231 231 break;
232 232
233 233 case Py_LE:
234 234 {
235 235 static QByteArray name = "__le__";
236 236 memberName = name;
237 237 }
238 238 break;
239 239
240 240 case Py_EQ:
241 241 {
242 242 static QByteArray name = "__eq__";
243 243 memberName = name;
244 244 }
245 245 break;
246 246
247 247 case Py_NE:
248 248 {
249 249 static QByteArray name = "__ne__";
250 250 memberName = name;
251 251 }
252 252 break;
253 253
254 254 case Py_GT:
255 255 {
256 256 static QByteArray name = "__gt__";
257 257 memberName = name;
258 258 }
259 259 break;
260 260
261 261 case Py_GE:
262 262 {
263 263 static QByteArray name = "__ge__";
264 264 memberName = name;
265 265 }
266 266 break;
267 267 }
268 268
269 269 PythonQtMemberInfo opSlot = wrapper->classInfo()->member(memberName);
270 270 if (opSlot._type == PythonQtMemberInfo::Slot) {
271 271 // TODO get rid of tuple
272 272 PyObject* args = PyTuple_New(1);
273 273 Py_INCREF(other);
274 274 PyTuple_SET_ITEM(args, 0, other);
275 275 PyObject* result = PythonQtSlotFunction_CallImpl(wrapper->classInfo(), wrapper->_obj, opSlot._slot, args, NULL, wrapper->_wrappedPtr);
276 276 Py_DECREF(args);
277 277 return result;
278 278 } else {
279 279 // not implemented, let python try something else!
280 280 Py_INCREF(Py_NotImplemented);
281 281 return Py_NotImplemented;
282 282 }
283 283 }
284 284
285 285
286 286 static PyObject *PythonQtInstanceWrapper_classname(PythonQtInstanceWrapper* obj)
287 287 {
288 288 return PyString_FromString(obj->ob_type->tp_name);
289 289 }
290 290
291 291 static PyObject *PythonQtInstanceWrapper_help(PythonQtInstanceWrapper* obj)
292 292 {
293 293 return PythonQt::self()->helpCalled(obj->classInfo());
294 294 }
295 295
296 296 static PyObject *PythonQtInstanceWrapper_delete(PythonQtInstanceWrapper * self)
297 297 {
298 298 PythonQtInstanceWrapper_deleteObject(self, true);
299 299 Py_INCREF(Py_None);
300 300 return Py_None;
301 301 }
302 302
303 303
304 304 static PyMethodDef PythonQtInstanceWrapper_methods[] = {
305 305 {"className", (PyCFunction)PythonQtInstanceWrapper_classname, METH_NOARGS,
306 306 "Return the classname of the object"
307 307 },
308 308 {"help", (PyCFunction)PythonQtInstanceWrapper_help, METH_NOARGS,
309 309 "Shows the help of available methods for this class"
310 310 },
311 311 {"delete", (PyCFunction)PythonQtInstanceWrapper_delete, METH_NOARGS,
312 312 "Deletes the C++ object (at your own risk, my friend!)"
313 313 },
314 314 {NULL, NULL, 0, NULL} /* Sentinel */
315 315 };
316 316
317 317
318 318 static PyObject *PythonQtInstanceWrapper_getattro(PyObject *obj,PyObject *name)
319 319 {
320 320 const char *attributeName;
321 321 PythonQtInstanceWrapper *wrapper = (PythonQtInstanceWrapper *)obj;
322 322
323 323 if ((attributeName = PyString_AsString(name)) == NULL) {
324 324 return NULL;
325 325 }
326 326
327 327 if (qstrcmp(attributeName, "__dict__")==0) {
328 328 PyObject* dict = PyBaseObject_Type.tp_getattro(obj, name);
329 329 dict = PyDict_Copy(dict);
330 330
331 331 if (wrapper->_obj) {
332 332 // only the properties are missing, the rest is already available from
333 333 // PythonQtClassWrapper...
334 334 QStringList l = wrapper->classInfo()->propertyList();
335 335 foreach (QString name, l) {
336 336 PyObject* o = PyObject_GetAttrString(obj, name.toLatin1().data());
337 337 if (o) {
338 338 PyDict_SetItemString(dict, name.toLatin1().data(), o);
339 339 Py_DECREF(o);
340 340 } else {
341 341 std::cerr << "PythonQtInstanceWrapper: something is wrong, could not get attribute " << name.toLatin1().data();
342 342 }
343 343 }
344 344
345 345 QList<QByteArray> dynamicProps = wrapper->_obj->dynamicPropertyNames();
346 346 foreach (QByteArray name, dynamicProps) {
347 347 PyObject* o = PyObject_GetAttrString(obj, name.data());
348 348 if (o) {
349 349 PyDict_SetItemString(dict, name.data(), o);
350 350 Py_DECREF(o);
351 351 } else {
352 352 std::cerr << "PythonQtInstanceWrapper: dynamic property could not be read " << name.data();
353 353 }
354 354 }
355 355 }
356 356 // Note: we do not put children into the dict, is would look confusing?!
357 357 return dict;
358 358 }
359 359
360 360 // first look in super, to return derived methods from base object first
361 361 PyObject* superAttr = PyBaseObject_Type.tp_getattro(obj, name);
362 362 if (superAttr) {
363 363 return superAttr;
364 364 }
365 365 PyErr_Clear();
366 366
367 367 // mlabDebugConst("Python","get " << attributeName);
368 368
369 369 PythonQtMemberInfo member = wrapper->classInfo()->member(attributeName);
370 370 switch (member._type) {
371 371 case PythonQtMemberInfo::Property:
372 372 if (wrapper->_obj) {
373 373 if (member._property.userType() != QVariant::Invalid) {
374 374 return PythonQtConv::QVariantToPyObject(member._property.read(wrapper->_obj));
375 375 } else {
376 376 Py_INCREF(Py_None);
377 377 return Py_None;
378 378 }
379 379 } else {
380 380 QString error = QString("Trying to read property '") + attributeName + "' from a destroyed " + wrapper->classInfo()->className() + " object";
381 381 PyErr_SetString(PyExc_ValueError, error.toLatin1().data());
382 382 return NULL;
383 383 }
384 384 break;
385 385 case PythonQtMemberInfo::Slot:
386 386 return PythonQtSlotFunction_New(member._slot, obj, NULL);
387 387 break;
388 388 case PythonQtMemberInfo::EnumValue:
389 389 {
390 390 PyObject* enumValue = member._enumValue;
391 391 Py_INCREF(enumValue);
392 392 return enumValue;
393 393 }
394 394 break;
395 395 case PythonQtMemberInfo::EnumWrapper:
396 396 {
397 397 PyObject* enumWrapper = member._enumWrapper;
398 398 Py_INCREF(enumWrapper);
399 399 return enumWrapper;
400 400 }
401 401 break;
402 402 case PythonQtMemberInfo::NotFound:
403 403 {
404 404 static const QByteArray getterString("py_get_");
405 405 // check for a getter slot
406 406 PythonQtMemberInfo member = wrapper->classInfo()->member(getterString + attributeName);
407 407 if (member._type == PythonQtMemberInfo::Slot) {
408 408 return PythonQtSlotFunction_CallImpl(wrapper->classInfo(), wrapper->_obj, member._slot, NULL, NULL, wrapper->_wrappedPtr);
409 409 }
410 410
411 411 // handle dynamic properties
412 412 if (wrapper->_obj) {
413 413 QVariant v = wrapper->_obj->property(attributeName);
414 414 if (v.isValid()) {
415 415 return PythonQtConv::QVariantToPyObject(v);
416 416 }
417 417 }
418 418 }
419 419 break;
420 420 default:
421 421 // is an invalid type, go on
422 422 break;
423 423 }
424 424
425 425 // look for the internal methods (className(), help())
426 426 PyObject* internalMethod = Py_FindMethod( PythonQtInstanceWrapper_methods, obj, (char*)attributeName);
427 427 if (internalMethod) {
428 428 return internalMethod;
429 429 }
430 430 PyErr_Clear();
431 431
432 432 if (wrapper->_obj) {
433 433 // look for a child
434 434 QObjectList children = wrapper->_obj->children();
435 435 for (int i = 0; i < children.count(); i++) {
436 436 QObject *child = children.at(i);
437 437 if (child->objectName() == attributeName) {
438 438 return PythonQt::priv()->wrapQObject(child);
439 439 }
440 440 }
441 441 }
442 442
443 443 QString error = QString(wrapper->classInfo()->className()) + " has no attribute named '" + QString(attributeName) + "'";
444 444 PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
445 445 return NULL;
446 446 }
447 447
448 448 static int PythonQtInstanceWrapper_setattro(PyObject *obj,PyObject *name,PyObject *value)
449 449 {
450 450 QString error;
451 451 const char *attributeName;
452 452 PythonQtInstanceWrapper *wrapper = (PythonQtInstanceWrapper *)obj;
453 453
454 454 if ((attributeName = PyString_AsString(name)) == NULL)
455 455 return -1;
456 456
457 457 PythonQtMemberInfo member = wrapper->classInfo()->member(attributeName);
458 458 if (member._type == PythonQtMemberInfo::Property) {
459 459
460 460 if (!wrapper->_obj) {
461 461 error = QString("Trying to set property '") + attributeName + "' on a destroyed " + wrapper->classInfo()->className() + " object";
462 462 PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
463 463 return -1;
464 464 }
465 465
466 466 QMetaProperty prop = member._property;
467 467 if (prop.isWritable()) {
468 468 QVariant v;
469 469 if (prop.isEnumType()) {
470 470 // this will give us either a string or an int, everything else will probably be an error
471 471 v = PythonQtConv::PyObjToQVariant(value);
472 472 } else {
473 473 int t = prop.userType();
474 474 v = PythonQtConv::PyObjToQVariant(value, t);
475 475 }
476 476 bool success = false;
477 477 if (v.isValid()) {
478 478 success = prop.write(wrapper->_obj, v);
479 479 }
480 480 if (success) {
481 481 return 0;
482 482 } else {
483 483 error = QString("Property '") + attributeName + "' of type '" +
484 484 prop.typeName() + "' does not accept an object of type "
485 485 + QString(value->ob_type->tp_name) + " (" + PythonQtConv::PyObjGetRepresentation(value) + ")";
486 486 }
487 487 } else {
488 488 error = QString("Property '") + attributeName + "' of " + obj->ob_type->tp_name + " object is not writable";
489 489 }
490 490 } else if (member._type == PythonQtMemberInfo::Slot) {
491 491 error = QString("Slot '") + attributeName + "' can not be overwritten on " + obj->ob_type->tp_name + " object";
492 492 } else if (member._type == PythonQtMemberInfo::EnumValue) {
493 493 error = QString("EnumValue '") + attributeName + "' can not be overwritten on " + obj->ob_type->tp_name + " object";
494 494 } else if (member._type == PythonQtMemberInfo::EnumWrapper) {
495 495 error = QString("Enum '") + attributeName + "' can not be overwritten on " + obj->ob_type->tp_name + " object";
496 496 } else if (member._type == PythonQtMemberInfo::NotFound) {
497 497 // check for a setter slot
498 498 static const QByteArray setterString("py_set_");
499 499 PythonQtMemberInfo setter = wrapper->classInfo()->member(setterString + attributeName);
500 500 if (setter._type == PythonQtMemberInfo::Slot) {
501 501 // call the setter and ignore the result value
502 502 void* result;
503 503 PyObject* args = PyTuple_New(1);
504 504 Py_INCREF(value);
505 505 PyTuple_SET_ITEM(args, 0, value);
506 506 PythonQtSlotFunction_CallImpl(wrapper->classInfo(), wrapper->_obj, setter._slot, args, NULL, wrapper->_wrappedPtr, &result);
507 507 Py_DECREF(args);
508 508 return 0;
509 509 }
510 510
511 511 // handle dynamic properties
512 512 if (wrapper->_obj) {
513 513 QVariant prop = wrapper->_obj->property(attributeName);
514 514 if (prop.isValid()) {
515 515 QVariant v = PythonQtConv::PyObjToQVariant(value);
516 516 if (v.isValid()) {
517 517 wrapper->_obj->setProperty(attributeName, v);
518 518 return 0;
519 519 } else {
520 520 error = QString("Dynamic property '") + attributeName + "' does not accept an object of type "
521 521 + QString(value->ob_type->tp_name) + " (" + PythonQtConv::PyObjGetRepresentation(value) + ")";
522 522 PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
523 523 return -1;
524 524 }
525 525 }
526 526 }
527 527
528 528 // if we are a derived python class, we allow setting attributes.
529 529 // if we are a direct CPP wrapper, we do NOT allow it, since
530 530 // it would be confusing to allow it because a wrapper will go away when it is not seen by python anymore
531 531 // and when it is recreated from a CPP pointer the attributes are gone...
532 532 if (obj->ob_type->tp_base != &PythonQtInstanceWrapper_Type) {
533 533 return PyBaseObject_Type.tp_setattro(obj,name,value);
534 534 } else {
535 535 error = QString("'") + attributeName + "' does not exist on " + obj->ob_type->tp_name + " and creating new attributes on C++ objects is not allowed";
536 536 }
537 537 }
538 538
539 539 PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
540 540 return -1;
541 541 }
542 542
543 543 static QString getStringFromObject(PythonQtInstanceWrapper* wrapper) {
544 544 QString result;
545 545 if (wrapper->_wrappedPtr) {
546 546 // first try some manually string conversions for some variants
547 547 int metaid = wrapper->classInfo()->metaTypeId();
548 548 result = PythonQtConv::CPPObjectToString(metaid, wrapper->_wrappedPtr);
549 549 if (!result.isEmpty()) {
550 550 return result;
551 551 }
552 552 }
553 553 // next, try to call py_toString
554 554 PythonQtMemberInfo info = wrapper->classInfo()->member("py_toString");
555 555 if (info._type == PythonQtMemberInfo::Slot) {
556 556 PyObject* resultObj = PythonQtSlotFunction_CallImpl(wrapper->classInfo(), wrapper->_obj, info._slot, NULL, NULL, wrapper->_wrappedPtr);
557 557 if (resultObj) {
558 558 // TODO this is one conversion too much, would be nicer to call the slot directly...
559 559 result = PythonQtConv::PyObjGetString(resultObj);
560 560 Py_DECREF(resultObj);
561 561 }
562 562 }
563 563 return result;
564 564 }
565 565
566 566 static PyObject * PythonQtInstanceWrapper_str(PyObject * obj)
567 567 {
568 568 PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)obj;
569 569
570 570 // QByteArray should be directly returned as a str
571 571 if (wrapper->classInfo()->metaTypeId()==QVariant::ByteArray) {
572 572 QByteArray* b = (QByteArray*) wrapper->_wrappedPtr;
573 573 if (b->data()) {
574 574 return PyString_FromStringAndSize(b->data(), b->size());
575 575 } else {
576 576 return PyString_FromString("");
577 577 }
578 578 }
579 579
580 580 const char* typeName = obj->ob_type->tp_name;
581 581 QObject *qobj = wrapper->_obj;
582 582 QString str = getStringFromObject(wrapper);
583 583 if (!str.isEmpty()) {
584 584 return PyString_FromFormat("%s", str.toLatin1().constData());
585 585 }
586 586 if (wrapper->_wrappedPtr) {
587 587 if (wrapper->_obj) {
588 588 return PyString_FromFormat("%s (C++ Object %p wrapped by %s %p))", typeName, wrapper->_wrappedPtr, wrapper->_obj->metaObject()->className(), qobj);
589 589 } else {
590 590 return PyString_FromFormat("%s (C++ Object %p)", typeName, wrapper->_wrappedPtr);
591 591 }
592 592 } else {
593 593 return PyString_FromFormat("%s (QObject %p)", typeName, qobj);
594 594 }
595 595 }
596 596
597 597 static PyObject * PythonQtInstanceWrapper_repr(PyObject * obj)
598 598 {
599 599 PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)obj;
600 600 const char* typeName = obj->ob_type->tp_name;
601 601
602 602 QObject *qobj = wrapper->_obj;
603 603 QString str = getStringFromObject(wrapper);
604 604 if (!str.isEmpty()) {
605 605 if (str.startsWith(typeName)) {
606 606 return PyString_FromFormat("%s", str.toLatin1().constData());
607 607 } else {
608 608 return PyString_FromFormat("%s(%s, %p)", typeName, str.toLatin1().constData(), wrapper->_wrappedPtr);
609 609 }
610 610 }
611 611 if (wrapper->_wrappedPtr) {
612 612 if (wrapper->_obj) {
613 613 return PyString_FromFormat("%s (C++ Object %p wrapped by %s %p))", typeName, wrapper->_wrappedPtr, wrapper->_obj->metaObject()->className(), qobj);
614 614 } else {
615 615 return PyString_FromFormat("%s (C++ Object %p)", typeName, wrapper->_wrappedPtr);
616 616 }
617 617 } else {
618 618 return PyString_FromFormat("%s (%s %p)", typeName, wrapper->classInfo()->className(), qobj);
619 619 }
620 620 }
621 621
622 622 static int PythonQtInstanceWrapper_builtin_nonzero(PyObject *obj)
623 623 {
624 624 PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)obj;
625 625 return (wrapper->_wrappedPtr == NULL && wrapper->_obj == NULL)?0:1;
626 626 }
627 627
628 628
629 629 static long PythonQtInstanceWrapper_hash(PythonQtInstanceWrapper *obj)
630 630 {
631 631 if (obj->_wrappedPtr != NULL) {
632 632 return reinterpret_cast<long>(obj->_wrappedPtr);
633 633 } else {
634 634 QObject* qobj = obj->_obj; // get pointer from QPointer wrapper
635 635 return reinterpret_cast<long>(qobj);
636 636 }
637 637 }
638 638
639 639
640 640
641 641 // we override nb_nonzero, so that one can do 'if' expressions to test for a NULL ptr
642 642 static PyNumberMethods PythonQtInstanceWrapper_as_number = {
643 643 0, /* nb_add */
644 644 0, /* nb_subtract */
645 645 0, /* nb_multiply */
646 646 0, /* nb_divide */
647 647 0, /* nb_remainder */
648 648 0, /* nb_divmod */
649 649 0, /* nb_power */
650 650 0, /* nb_negative */
651 651 0, /* nb_positive */
652 652 0, /* nb_absolute */
653 653 PythonQtInstanceWrapper_builtin_nonzero, /* nb_nonzero */
654 654 0, /* nb_invert */
655 655 0, /* nb_lshift */
656 656 0, /* nb_rshift */
657 657 0, /* nb_and */
658 658 0, /* nb_xor */
659 659 0, /* nb_or */
660 660 0, /* nb_coerce */
661 661 0, /* nb_int */
662 662 0, /* nb_long */
663 663 0, /* nb_float */
664 664 0, /* nb_oct */
665 665 0, /* nb_hex */
666 666 0, /* nb_inplace_add */
667 667 0, /* nb_inplace_subtract */
668 668 0, /* nb_inplace_multiply */
669 669 0, /* nb_inplace_divide */
670 670 0, /* nb_inplace_remainder */
671 671 0, /* nb_inplace_power */
672 672 0, /* nb_inplace_lshift */
673 673 0, /* nb_inplace_rshift */
674 674 0, /* nb_inplace_and */
675 675 0, /* nb_inplace_xor */
676 676 0, /* nb_inplace_or */
677 677 0, /* nb_floor_divide */
678 678 0, /* nb_true_divide */
679 679 0, /* nb_inplace_floor_divide */
680 680 0, /* nb_inplace_true_divide */
681 681 };
682 682
683 683 PyTypeObject PythonQtInstanceWrapper_Type = {
684 684 PyObject_HEAD_INIT(&PythonQtClassWrapper_Type)
685 685 0, /*ob_size*/
686 686 "PythonQt.PythonQtInstanceWrapper", /*tp_name*/
687 687 sizeof(PythonQtInstanceWrapper), /*tp_basicsize*/
688 688 0, /*tp_itemsize*/
689 689 (destructor)PythonQtInstanceWrapper_dealloc, /*tp_dealloc*/
690 690 0, /*tp_print*/
691 691 0, /*tp_getattr*/
692 692 0, /*tp_setattr*/
693 693 0, /*tp_compare*/
694 694 PythonQtInstanceWrapper_repr, /*tp_repr*/
695 695 &PythonQtInstanceWrapper_as_number, /*tp_as_number*/
696 696 0, /*tp_as_sequence*/
697 697 0, /*tp_as_mapping*/
698 698 (hashfunc)PythonQtInstanceWrapper_hash, /*tp_hash */
699 699 0, /*tp_call*/
700 700 PythonQtInstanceWrapper_str, /*tp_str*/
701 701 PythonQtInstanceWrapper_getattro, /*tp_getattro*/
702 702 PythonQtInstanceWrapper_setattro, /*tp_setattro*/
703 703 0, /*tp_as_buffer*/
704 704 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_CHECKTYPES, /*tp_flags*/
705 705 "PythonQtInstanceWrapper object", /* tp_doc */
706 706 0, /* tp_traverse */
707 707 0, /* tp_clear */
708 708 (richcmpfunc)PythonQtInstanceWrapper_richcompare, /* tp_richcompare */
709 709 0, /* tp_weaklistoffset */
710 710 0, /* tp_iter */
711 711 0, /* tp_iternext */
712 712 0, /* tp_methods */
713 713 0, /* tp_members */
714 714 0, /* tp_getset */
715 715 0, /* tp_base */
716 716 0, /* tp_dict */
717 717 0, /* tp_descr_get */
718 718 0, /* tp_descr_set */
719 719 0, /* tp_dictoffset */
720 720 (initproc)PythonQtInstanceWrapper_init, /* tp_init */
721 721 0, /* tp_alloc */
722 722 PythonQtInstanceWrapper_new, /* tp_new */
723 723 };
724 724
725 725 //-------------------------------------------------------
726 726
Show file before | Show file after | Hide comments
@@ -1,98 +1,98
1 1 #ifndef _PYTHONQTINSTANCEWRAPPER_H
2 2 #define _PYTHONQTINSTANCEWRAPPER_H
3 3
4 4 /*
5 5 *
6 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
6 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
7 7 *
8 8 * This library is free software; you can redistribute it and/or
9 9 * modify it under the terms of the GNU Lesser General Public
10 10 * License as published by the Free Software Foundation; either
11 11 * version 2.1 of the License, or (at your option) any later version.
12 12 *
13 13 * This library is distributed in the hope that it will be useful,
14 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 16 * Lesser General Public License for more details.
17 17 *
18 18 * Further, this software is distributed without any warranty that it is
19 19 * free of the rightful claim of any third person regarding infringement
20 20 * or the like. Any license provided herein, whether implied or
21 21 * otherwise, applies only to this software file. Patent licenses, if
22 22 * any, provided herein do not apply to combinations of this program with
23 23 * other software, or any other product whatsoever.
24 24 *
25 25 * You should have received a copy of the GNU Lesser General Public
26 26 * License along with this library; if not, write to the Free Software
27 27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 28 *
29 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
29 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
30 30 * 28359 Bremen, Germany or:
31 31 *
32 32 * http://www.mevis.de
33 33 *
34 34 */
35 35
36 36 //----------------------------------------------------------------------------------
37 37 /*!
38 38 // \file PythonQtInstanceWrapper.h
39 39 // \author Florian Link
40 40 // \author Last changed by $Author: florian $
41 41 // \date 2006-05
42 42 */
43 43 //----------------------------------------------------------------------------------
44 44
45 45 #include <Python.h>
46 46
47 47 #include "PythonQtSystem.h"
48 48 #include <QPointer>
49 49
50 50 #include "structmember.h"
51 51 #include "methodobject.h"
52 52 #include "compile.h"
53 53 #include "eval.h"
54 54
55 55 class PythonQtClassInfo;
56 56 class QObject;
57 57
58 58 extern PYTHONQT_EXPORT PyTypeObject PythonQtInstanceWrapper_Type;
59 59
60 60 //---------------------------------------------------------------
61 61 //! a Python wrapper object for Qt objects and C++ objects (that are themselves wrapped by wrapper QObjects)
62 62 typedef struct PythonQtInstanceWrapperStruct {
63 63 PyObject_HEAD
64 64
65 65 //! the class information, this is set even if the _obj or _wrappedPtr is NULL to support typed NULL pointers
66 66 PythonQtClassInfo* classInfo();
67 67
68 68 //! set the QObject pointer
69 69 void setQObject(QObject* object) {
70 70 _obj = object;
71 71 _objPointerCopy = object;
72 72 }
73 73
74 74 //! pointer to the wrapped Qt object or if _wrappedPtr is set, the Qt object that wraps the C++ Ptr
75 75 QPointer<QObject> _obj;
76 76 //! a copy of the _obj pointer, which is required because the wrapper needs to
77 77 //! deregister itself via the _obj pointer, even when the QPointer<QObject> object was destroyed
78 78 void* _objPointerCopy;
79 79
80 80 //! optional C++ object Ptr that is wrapped by the above _obj
81 81 void* _wrappedPtr;
82 82
83 83 // TODO xxx: put booleans into int that holds flags
84 84
85 85 //! flag that stores if the object is owned by pythonQt
86 86 bool _ownedByPythonQt;
87 87
88 88 //! stores that the owned object should be destroyed using QMetaType::destroy()
89 89 bool _useQMetaTypeDestroy;
90 90
91 91 //! stores if the object is a shell instance
92 92 bool _isShellInstance;
93 93
94 94 } PythonQtInstanceWrapper;
95 95
96 96 int PythonQtInstanceWrapper_init(PythonQtInstanceWrapper * self, PyObject * args, PyObject * kwds);
97 97
98 98 #endif No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,351 +1,351
1 1 /*
2 2 *
3 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
3 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
4 4 *
5 5 * This library is free software; you can redistribute it and/or
6 6 * modify it under the terms of the GNU Lesser General Public
7 7 * License as published by the Free Software Foundation; either
8 8 * version 2.1 of the License, or (at your option) any later version.
9 9 *
10 10 * This library is distributed in the hope that it will be useful,
11 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 13 * Lesser General Public License for more details.
14 14 *
15 15 * Further, this software is distributed without any warranty that it is
16 16 * free of the rightful claim of any third person regarding infringement
17 17 * or the like. Any license provided herein, whether implied or
18 18 * otherwise, applies only to this software file. Patent licenses, if
19 19 * any, provided herein do not apply to combinations of this program with
20 20 * other software, or any other product whatsoever.
21 21 *
22 22 * You should have received a copy of the GNU Lesser General Public
23 23 * License along with this library; if not, write to the Free Software
24 24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 25 *
26 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
26 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
27 27 * 28359 Bremen, Germany or:
28 28 *
29 29 * http://www.mevis.de
30 30 *
31 31 */
32 32
33 33 //----------------------------------------------------------------------------------
34 34 /*!
35 35 // \file PythonQtMethodInfo.cpp
36 36 // \author Florian Link
37 37 // \author Last changed by $Author: florian $
38 38 // \date 2006-05
39 39 */
40 40 //----------------------------------------------------------------------------------
41 41
42 42 #include "PythonQtMethodInfo.h"
43 43 #include "PythonQtClassInfo.h"
44 44 #include <iostream>
45 45
46 46 QHash<QByteArray, PythonQtMethodInfo*> PythonQtMethodInfo::_cachedSignatures;
47 47 QHash<QByteArray, QByteArray> PythonQtMethodInfo::_parameterNameAliases;
48 48
49 49 PythonQtMethodInfo::PythonQtMethodInfo(const QMetaMethod& meta, PythonQtClassInfo* classInfo)
50 50 {
51 51 #ifdef PYTHONQT_DEBUG
52 52 QByteArray sig(meta.signature());
53 53 sig = sig.mid(sig.indexOf('('));
54 54 QByteArray fullSig = QByteArray(meta.typeName()) + " " + sig;
55 55 std::cout << "caching " << fullSig.data() << std::endl;
56 56 #endif
57 57
58 58 ParameterInfo type;
59 59 fillParameterInfo(type, QByteArray(meta.typeName()), classInfo);
60 60 _parameters.append(type);
61 61 QList<QByteArray> names = meta.parameterTypes();
62 62 foreach (const QByteArray& name, names) {
63 63 fillParameterInfo(type, name, classInfo);
64 64 _parameters.append(type);
65 65 }
66 66 }
67 67
68 68 PythonQtMethodInfo::PythonQtMethodInfo(const QByteArray& typeName, const QList<QByteArray>& args)
69 69 {
70 70 ParameterInfo type;
71 71 fillParameterInfo(type, typeName, NULL);
72 72 _parameters.append(type);
73 73 foreach (const QByteArray& name, args) {
74 74 fillParameterInfo(type, name, NULL);
75 75 _parameters.append(type);
76 76 }
77 77 }
78 78
79 79 const PythonQtMethodInfo* PythonQtMethodInfo::getCachedMethodInfo(const QMetaMethod& signal, PythonQtClassInfo* classInfo)
80 80 {
81 81 QByteArray sig(signal.signature());
82 82 sig = sig.mid(sig.indexOf('('));
83 83 QByteArray fullSig = QByteArray(signal.typeName()) + " " + sig;
84 84 PythonQtMethodInfo* result = _cachedSignatures.value(fullSig);
85 85 if (!result) {
86 86 result = new PythonQtMethodInfo(signal, classInfo);
87 87 _cachedSignatures.insert(fullSig, result);
88 88 }
89 89 return result;
90 90 }
91 91
92 92 const PythonQtMethodInfo* PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(int numArgs, const char** args)
93 93 {
94 94 QByteArray typeName = args[0];
95 95 QList<QByteArray> arguments;
96 96 QByteArray fullSig = typeName;
97 97 fullSig += "(";
98 98 for (int i =1;i<numArgs; i++) {
99 99 if (i>1) {
100 100 fullSig += ",";
101 101 }
102 102 arguments << QByteArray(args[i]);
103 103 }
104 104 fullSig += ")";
105 105 PythonQtMethodInfo* result = _cachedSignatures.value(fullSig);
106 106 if (!result) {
107 107 result = new PythonQtMethodInfo(typeName, arguments);
108 108 _cachedSignatures.insert(fullSig, result);
109 109 }
110 110 return result;
111 111 }
112 112
113 113 void PythonQtMethodInfo::fillParameterInfo(ParameterInfo& type, const QByteArray& orgName, PythonQtClassInfo* classInfo)
114 114 {
115 115 QByteArray name = orgName;
116 116
117 117 type.enumWrapper = NULL;
118 118
119 119 int len = name.length();
120 120 if (len>0) {
121 121 if (strncmp(name.constData(), "const ", 6)==0) {
122 122 name = name.mid(6);
123 123 len -= 6;
124 124 type.isConst = true;
125 125 } else {
126 126 type.isConst = false;
127 127 }
128 128 bool hadPointer = false;
129 129 bool hadReference = false;
130 130 // remove * and & from the end of the string, handle & and * the same way
131 131 while (name.at(len-1) == '*') {
132 132 len--;
133 133 hadPointer = true;
134 134 }
135 135 while (name.at(len-1) == '&') {
136 136 len--;
137 137 hadReference = true;
138 138 }
139 139 if (len!=name.length()) {
140 140 name = name.left(len);
141 141 }
142 142 type.isPointer = hadPointer;
143 143
144 144 QByteArray alias = _parameterNameAliases.value(name);
145 145 if (!alias.isEmpty()) {
146 146 name = alias;
147 147 }
148 148
149 149 type.typeId = nameToType(name);
150 150 if (!type.isPointer && type.typeId == Unknown) {
151 151 type.typeId = QMetaType::type(name.constData());
152 152 if (type.typeId == QMetaType::Void) {
153 153 type.typeId = Unknown;
154 154 }
155 155 }
156 156 type.name = name;
157 157
158 158 if (type.typeId == PythonQtMethodInfo::Unknown || type.typeId >= QMetaType::User) {
159 159 bool isLocalEnum;
160 160 // TODOXXX: make use of this flag!
161 161 type.enumWrapper = PythonQtClassInfo::findEnumWrapper(type.name, classInfo, &isLocalEnum);
162 162 }
163 163 } else {
164 164 type.typeId = QMetaType::Void;
165 165 type.isPointer = false;
166 166 type.isConst = false;
167 167 }
168 168 }
169 169
170 170 int PythonQtMethodInfo::nameToType(const char* name)
171 171 {
172 172 if (_parameterTypeDict.isEmpty()) {
173 173 // we could also use QMetaType::nameToType, but that does a string compare search
174 174 // and does not support QVariant
175 175
176 176 // QMetaType names
177 177 _parameterTypeDict.insert("long", QMetaType::Long);
178 178 _parameterTypeDict.insert("int", QMetaType::Int);
179 179 _parameterTypeDict.insert("short", QMetaType::Short);
180 180 _parameterTypeDict.insert("char", QMetaType::Char);
181 181 _parameterTypeDict.insert("ulong", QMetaType::ULong);
182 182 _parameterTypeDict.insert("unsigned long", QMetaType::ULong);
183 183 _parameterTypeDict.insert("uint", QMetaType::UInt);
184 184 _parameterTypeDict.insert("unsigned int", QMetaType::UInt);
185 185 _parameterTypeDict.insert("ushort", QMetaType::UShort);
186 186 _parameterTypeDict.insert("unsigned short", QMetaType::UShort);
187 187 _parameterTypeDict.insert("uchar", QMetaType::UChar);
188 188 _parameterTypeDict.insert("unsigned char", QMetaType::UChar);
189 189 _parameterTypeDict.insert("bool", QMetaType::Bool);
190 190 _parameterTypeDict.insert("float", QMetaType::Float);
191 191 _parameterTypeDict.insert("double", QMetaType::Double);
192 192 _parameterTypeDict.insert("qreal", QMetaType::Double);
193 193 _parameterTypeDict.insert("QChar", QMetaType::QChar);
194 194 _parameterTypeDict.insert("QByteArray", QMetaType::QByteArray);
195 195 _parameterTypeDict.insert("Q3CString", QMetaType::QByteArray);
196 196 _parameterTypeDict.insert("QString", QMetaType::QString);
197 197 _parameterTypeDict.insert("", QMetaType::Void);
198 198 _parameterTypeDict.insert("void", QMetaType::Void);
199 199 // QVariant names
200 200 _parameterTypeDict.insert("Q_LLONG", QMetaType::LongLong);
201 201 _parameterTypeDict.insert("Q_ULLONG", QMetaType::ULongLong);
202 202 _parameterTypeDict.insert("qlonglong", QMetaType::LongLong);
203 203 _parameterTypeDict.insert("qulonglong", QMetaType::ULongLong);
204 204 _parameterTypeDict.insert("qint64", QMetaType::LongLong);
205 205 _parameterTypeDict.insert("quint64", QMetaType::ULongLong);
206 206 _parameterTypeDict.insert("QIconSet", QMetaType::QIcon);
207 207 _parameterTypeDict.insert("QVariantMap", QMetaType::QVariantMap);
208 208 _parameterTypeDict.insert("QVariantList", QMetaType::QVariantList);
209 209 _parameterTypeDict.insert("QMap<QString,QVariant>", QMetaType::QVariantMap);
210 210 _parameterTypeDict.insert("QList<QVariant>", QMetaType::QVariantList);
211 211 _parameterTypeDict.insert("QStringList", QMetaType::QStringList);
212 212 _parameterTypeDict.insert("QBitArray", QMetaType::QBitArray);
213 213 _parameterTypeDict.insert("QDate", QMetaType::QDate);
214 214 _parameterTypeDict.insert("QTime", QMetaType::QTime);
215 215 _parameterTypeDict.insert("QDateTime", QMetaType::QDateTime);
216 216 _parameterTypeDict.insert("QUrl", QMetaType::QUrl);
217 217 _parameterTypeDict.insert("QLocale", QMetaType::QLocale);
218 218 _parameterTypeDict.insert("QRect", QMetaType::QRect);
219 219 _parameterTypeDict.insert("QRectf", QMetaType::QRectF);
220 220 _parameterTypeDict.insert("QSize", QMetaType::QSize);
221 221 _parameterTypeDict.insert("QSizef", QMetaType::QSizeF);
222 222 _parameterTypeDict.insert("QLine", QMetaType::QLine);
223 223 _parameterTypeDict.insert("QLinef", QMetaType::QLineF);
224 224 _parameterTypeDict.insert("QPoint", QMetaType::QPoint);
225 225 _parameterTypeDict.insert("QPointf", QMetaType::QPointF);
226 226 _parameterTypeDict.insert("QRegExp", QMetaType::QRegExp);
227 227 // _parameterTypeDict.insert("QColorGroup", QMetaType::QColorGroup);
228 228 _parameterTypeDict.insert("QFont", QMetaType::QFont);
229 229 _parameterTypeDict.insert("QPixmap", QMetaType::QPixmap);
230 230 _parameterTypeDict.insert("QBrush", QMetaType::QBrush);
231 231 _parameterTypeDict.insert("QColor", QMetaType::QColor);
232 232 _parameterTypeDict.insert("QCursor", QMetaType::QCursor);
233 233 _parameterTypeDict.insert("QPalette", QMetaType::QPalette);
234 234 _parameterTypeDict.insert("QIcon", QMetaType::QIcon);
235 235 _parameterTypeDict.insert("QImage", QMetaType::QPolygon);
236 236 _parameterTypeDict.insert("QRegion", QMetaType::QRegion);
237 237 _parameterTypeDict.insert("QBitmap", QMetaType::QBitmap);
238 238 _parameterTypeDict.insert("QSizePolicy", QMetaType::QSizePolicy);
239 239 _parameterTypeDict.insert("QKeySequence", QMetaType::QKeySequence);
240 240 _parameterTypeDict.insert("QPen", QMetaType::QPen);
241 241 _parameterTypeDict.insert("QTextLength", QMetaType::QTextLength);
242 242 _parameterTypeDict.insert("QTextFormat", QMetaType::QTextFormat);
243 243 _parameterTypeDict.insert("QMatrix", QMetaType::QMatrix);
244 244 _parameterTypeDict.insert("QVariant", PythonQtMethodInfo::Variant);
245 245 // own special types... (none so far, could be e.g. ObjectList
246 246 }
247 247 QHash<QByteArray, int>::const_iterator it = _parameterTypeDict.find(name);
248 248 if (it!=_parameterTypeDict.end()) {
249 249 return it.value();
250 250 } else {
251 251 return PythonQtMethodInfo::Unknown;
252 252 }
253 253 }
254 254
255 255 void PythonQtMethodInfo::cleanupCachedMethodInfos()
256 256 {
257 257 QHashIterator<QByteArray, PythonQtMethodInfo *> i(_cachedSignatures);
258 258 while (i.hasNext()) {
259 259 delete i.next().value();
260 260 }
261 261 }
262 262
263 263 void PythonQtMethodInfo::addParameterTypeAlias(const QByteArray& alias, const QByteArray& name)
264 264 {
265 265 _parameterNameAliases.insert(alias, name);
266 266 }
267 267
268 268 //-------------------------------------------------------------------------------------------------
269 269
270 270 void PythonQtSlotInfo::deleteOverloadsAndThis()
271 271 {
272 272 PythonQtSlotInfo* cur = this;
273 273 while(cur->nextInfo()) {
274 274 PythonQtSlotInfo* next = cur->nextInfo();
275 275 delete cur;
276 276 cur = next;
277 277 }
278 278 }
279 279
280 280
281 281 QString PythonQtSlotInfo::fullSignature()
282 282 {
283 283 bool skipFirstArg = isInstanceDecorator();
284 284 QString result = _meta.typeName();
285 285 QByteArray sig = slotName();
286 286 QList<QByteArray> names = _meta.parameterNames();
287 287
288 288 bool isStatic = false;
289 289 bool isConstructor = false;
290 290 bool isDestructor = false;
291 291
292 292 if (_type == ClassDecorator) {
293 293 if (sig.startsWith("new_")) {
294 294 sig = sig.mid(strlen("new_"));
295 295 isConstructor = true;
296 296 } else if (sig.startsWith("delete_")) {
297 297 sig = sig.mid(strlen("delete_"));
298 298 isDestructor = true;
299 299 } else if(sig.startsWith("static_")) {
300 300 isStatic = true;
301 301 sig = sig.mid(strlen("static_"));
302 302 int idx = sig.indexOf("_");
303 303 if (idx>=0) {
304 304 sig = sig.mid(idx+1);
305 305 }
306 306 }
307 307 }
308 308
309 309 result += QByteArray(" ") + sig;
310 310 result += "(";
311 311
312 312 int lastEntry = _parameters.count()-1;
313 313 for (int i = skipFirstArg?2:1; i<_parameters.count(); i++) {
314 314 if (_parameters.at(i).isConst) {
315 315 result += "const ";
316 316 }
317 317 result += _parameters.at(i).name;
318 318 if (_parameters.at(i).isPointer) {
319 319 result += "*";
320 320 }
321 321 if (!names.at(i-1).isEmpty()) {
322 322 result += " ";
323 323 result += names.at(i-1);
324 324 }
325 325 if (i!=lastEntry) {
326 326 result += ", ";
327 327 }
328 328 }
329 329 result += ")";
330 330
331 331 if (isStatic) {
332 332 result = QString("static ") + result;
333 333 }
334 334 if (isConstructor) {
335 335 // result = QString("constructor ") + result;
336 336 }
337 337 if (isDestructor) {
338 338 result = QString("~") + result;
339 339 }
340 340 return result;
341 341 }
342 342
343 343
344 344 QByteArray PythonQtSlotInfo::slotName()
345 345 {
346 346 QByteArray sig(_meta.signature());
347 347 int idx = sig.indexOf('(');
348 348 sig = sig.left(idx);
349 349 return sig;
350 350 }
351 351
Show file before | Show file after | Hide comments
@@ -1,190 +1,190
1 1 #ifndef _PYTHONQTMETHODINFO_H
2 2 #define _PYTHONQTMETHODINFO_H
3 3
4 4 /*
5 5 *
6 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
6 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
7 7 *
8 8 * This library is free software; you can redistribute it and/or
9 9 * modify it under the terms of the GNU Lesser General Public
10 10 * License as published by the Free Software Foundation; either
11 11 * version 2.1 of the License, or (at your option) any later version.
12 12 *
13 13 * This library is distributed in the hope that it will be useful,
14 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 16 * Lesser General Public License for more details.
17 17 *
18 18 * Further, this software is distributed without any warranty that it is
19 19 * free of the rightful claim of any third person regarding infringement
20 20 * or the like. Any license provided herein, whether implied or
21 21 * otherwise, applies only to this software file. Patent licenses, if
22 22 * any, provided herein do not apply to combinations of this program with
23 23 * other software, or any other product whatsoever.
24 24 *
25 25 * You should have received a copy of the GNU Lesser General Public
26 26 * License along with this library; if not, write to the Free Software
27 27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 28 *
29 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
29 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
30 30 * 28359 Bremen, Germany or:
31 31 *
32 32 * http://www.mevis.de
33 33 *
34 34 */
35 35
36 36 //----------------------------------------------------------------------------------
37 37 /*!
38 38 // \file PythonQtMethodInfo.h
39 39 // \author Florian Link
40 40 // \author Last changed by $Author: florian $
41 41 // \date 2006-05
42 42 */
43 43 //----------------------------------------------------------------------------------
44 44
45 45 #include "PythonQtSystem.h"
46 46
47 47 #include <QByteArray>
48 48 #include <QHash>
49 49 #include <QList>
50 50 #include <QMetaMethod>
51 51
52 52 class PythonQtClassInfo;
53 53 struct _object;
54 54 typedef struct _object PyObject;
55 55
56 56 //! stores information about a specific signal/slot/method
57 57 class PYTHONQT_EXPORT PythonQtMethodInfo
58 58 {
59 59 public:
60 60 enum ParameterType {
61 61 Unknown = -1,
62 62 Variant = -2
63 63 };
64 64
65 65 //! stores the QVariant id (if available) and the name of the type
66 66 struct ParameterInfo {
67 67 QByteArray name;
68 68 PyObject* enumWrapper; // if it is an enum, a pointer to the enum wrapper
69 69 int typeId; // a mixture from QMetaType and ParameterType
70 70 bool isPointer;
71 71 bool isConst;
72 72 };
73 73
74 74 PythonQtMethodInfo() {};
75 75 ~PythonQtMethodInfo() {};
76 76 PythonQtMethodInfo(const QMetaMethod& meta, PythonQtClassInfo* classInfo);
77 77 PythonQtMethodInfo(const QByteArray& typeName, const QList<QByteArray>& args);
78 78 PythonQtMethodInfo(const PythonQtMethodInfo& other) {
79 79 _parameters = other._parameters;
80 80 }
81 81
82 82 //! returns the method info of the signature, uses a cache internally to speed up
83 83 //! multiple requests for the same method, classInfo is passed to allow local enum resolution (if NULL is passed, no local enums are recognized)
84 84 static const PythonQtMethodInfo* getCachedMethodInfo(const QMetaMethod& method, PythonQtClassInfo* classInfo);
85 85
86 86 //! get the cached method info using the passed in list of return value and arguments, return value needs to be passed as first arg
87 87 static const PythonQtMethodInfo* getCachedMethodInfoFromArgumentList(int numArgs, const char** args);
88 88
89 89 //! cleanup the cache
90 90 static void cleanupCachedMethodInfos();
91 91
92 92 //! returns the number of parameters including the return value
93 93 int parameterCount() const { return _parameters.size(); };
94 94
95 95 //! returns the id for the given type (using an internal dictionary)
96 96 static int nameToType(const char* name);
97 97
98 98 //! get the parameter infos
99 99 const QList<ParameterInfo>& parameters() const { return _parameters; }
100 100
101 101 //! add an alias for a typename, e.g. QObjectList and QList<QObject*>.
102 102 static void addParameterTypeAlias(const QByteArray& alias, const QByteArray& name);
103 103
104 104 protected:
105 105 static void fillParameterInfo(ParameterInfo& type, const QByteArray& name, PythonQtClassInfo* classInfo);
106 106
107 107 static QHash<QByteArray, int> _parameterTypeDict;
108 108 static QHash<QByteArray, QByteArray> _parameterNameAliases;
109 109
110 110 //! stores the cached signatures of methods to speedup mapping from Qt to Python types
111 111 static QHash<QByteArray, PythonQtMethodInfo*> _cachedSignatures;
112 112
113 113 QList<ParameterInfo> _parameters;
114 114 };
115 115
116 116 //! stores information about a slot, including a next pointer to overloaded slots
117 117 class PythonQtSlotInfo : public PythonQtMethodInfo
118 118 {
119 119 public:
120 120 enum Type {
121 121 MemberSlot, InstanceDecorator, ClassDecorator
122 122 };
123 123
124 124 PythonQtSlotInfo(const PythonQtSlotInfo& info):PythonQtMethodInfo() {
125 125 _meta = info._meta;
126 126 _parameters = info._parameters;
127 127 _slotIndex = info._slotIndex;
128 128 _next = NULL;
129 129 _decorator = info._decorator;
130 130 _type = info._type;
131 131 _upcastingOffset = 0;
132 132 }
133 133
134 134 PythonQtSlotInfo(PythonQtClassInfo* classInfo, const QMetaMethod& meta, int slotIndex, QObject* decorator = NULL, Type type = MemberSlot ):PythonQtMethodInfo()
135 135 {
136 136 const PythonQtMethodInfo* info = getCachedMethodInfo(meta, classInfo);
137 137 _meta = meta;
138 138 _parameters = info->parameters();
139 139 _slotIndex = slotIndex;
140 140 _next = NULL;
141 141 _decorator = decorator;
142 142 _type = type;
143 143 _upcastingOffset = 0;
144 144 }
145 145
146 146
147 147 public:
148 148
149 149 void deleteOverloadsAndThis();
150 150
151 151 const QMetaMethod* metaMethod() const { return &_meta; }
152 152
153 153 void setUpcastingOffset(int upcastingOffset) { _upcastingOffset = upcastingOffset; }
154 154
155 155 int upcastingOffset() const { return _upcastingOffset; }
156 156
157 157 //! get the index of the slot (needed for qt_metacall)
158 158 int slotIndex() const { return _slotIndex; }
159 159
160 160 //! get next overloaded slot (which has the same name)
161 161 PythonQtSlotInfo* nextInfo() const { return _next; }
162 162
163 163 //! set the next overloaded slot
164 164 void setNextInfo(PythonQtSlotInfo* next) { _next = next; }
165 165
166 166 //! returns if the slot is a decorator slot
167 167 bool isInstanceDecorator() { return _decorator!=NULL && _type == InstanceDecorator; }
168 168
169 169 //! returns if the slot is a constructor slot
170 170 bool isClassDecorator() { return _decorator!=NULL && _type == ClassDecorator; }
171 171
172 172 QObject* decorator() { return _decorator; }
173 173
174 174 //! get the full signature including return type
175 175 QString fullSignature();
176 176
177 177 //! get the short slot name
178 178 QByteArray slotName();
179 179
180 180 private:
181 181 int _slotIndex;
182 182 PythonQtSlotInfo* _next;
183 183 QObject* _decorator;
184 184 Type _type;
185 185 QMetaMethod _meta;
186 186 int _upcastingOffset;
187 187 };
188 188
189 189
190 190 #endif
Show file before | Show file after | Hide comments
@@ -1,43 +1,43
1 1 /*
2 2 *
3 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
3 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
4 4 *
5 5 * This library is free software; you can redistribute it and/or
6 6 * modify it under the terms of the GNU Lesser General Public
7 7 * License as published by the Free Software Foundation; either
8 8 * version 2.1 of the License, or (at your option) any later version.
9 9 *
10 10 * This library is distributed in the hope that it will be useful,
11 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 13 * Lesser General Public License for more details.
14 14 *
15 15 * Further, this software is distributed without any warranty that it is
16 16 * free of the rightful claim of any third person regarding infringement
17 17 * or the like. Any license provided herein, whether implied or
18 18 * otherwise, applies only to this software file. Patent licenses, if
19 19 * any, provided herein do not apply to combinations of this program with
20 20 * other software, or any other product whatsoever.
21 21 *
22 22 * You should have received a copy of the GNU Lesser General Public
23 23 * License along with this library; if not, write to the Free Software
24 24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 25 *
26 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
26 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
27 27 * 28359 Bremen, Germany or:
28 28 *
29 29 * http://www.mevis.de
30 30 *
31 31 */
32 32
33 33 //----------------------------------------------------------------------------------
34 34 /*!
35 35 // \file PythonQtMisc.cpp
36 36 // \author Florian Link
37 37 // \author Last changed by $Author: florian $
38 38 // \date 2006-05
39 39 */
40 40 //----------------------------------------------------------------------------------
41 41
42 42 #include "PythonQtMisc.h"
43 43
Show file before | Show file after | Hide comments
@@ -1,142 +1,142
1 1 #ifndef _PYTHONQTMISC_H
2 2 #define _PYTHONQTMISC_H
3 3
4 4 /*
5 5 *
6 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
6 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
7 7 *
8 8 * This library is free software; you can redistribute it and/or
9 9 * modify it under the terms of the GNU Lesser General Public
10 10 * License as published by the Free Software Foundation; either
11 11 * version 2.1 of the License, or (at your option) any later version.
12 12 *
13 13 * This library is distributed in the hope that it will be useful,
14 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 16 * Lesser General Public License for more details.
17 17 *
18 18 * Further, this software is distributed without any warranty that it is
19 19 * free of the rightful claim of any third person regarding infringement
20 20 * or the like. Any license provided herein, whether implied or
21 21 * otherwise, applies only to this software file. Patent licenses, if
22 22 * any, provided herein do not apply to combinations of this program with
23 23 * other software, or any other product whatsoever.
24 24 *
25 25 * You should have received a copy of the GNU Lesser General Public
26 26 * License along with this library; if not, write to the Free Software
27 27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 28 *
29 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
29 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
30 30 * 28359 Bremen, Germany or:
31 31 *
32 32 * http://www.mevis.de
33 33 *
34 34 */
35 35
36 36 //----------------------------------------------------------------------------------
37 37 /*!
38 38 // \file PythonQtMisc.h
39 39 // \author Florian Link
40 40 // \author Last changed by $Author: florian $
41 41 // \date 2006-05
42 42 */
43 43 //----------------------------------------------------------------------------------
44 44
45 45
46 46 #include <QList>
47 47
48 48 #define PythonQtValueStorage_ADD_VALUE(store, type, value, ptr) \
49 49 { type* item = (type*)store.nextValuePtr(); \
50 50 *item = value; \
51 51 ptr = (void*)item; \
52 52 }
53 53
54 54 #define PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedPtr,store, type, value, ptr) \
55 55 { \
56 56 type* item = (type*)(alreadyAllocatedPtr?alreadyAllocatedPtr:store.nextValuePtr()); \
57 57 *item = value; \
58 58 ptr = (void*)item; \
59 59 }
60 60
61 61 //! stores a position in the PythonQtValueStorage
62 62 class PythonQtValueStoragePosition {
63 63
64 64 public:
65 65 PythonQtValueStoragePosition() { chunkIdx = 0; chunkOffset = 0; }
66 66
67 67 int chunkIdx;
68 68 int chunkOffset;
69 69
70 70 };
71 71
72 72 //! a helper class that stores basic C++ value types in chunks
73 73 template <typename T, int chunkEntries> class PythonQtValueStorage
74 74 {
75 75 public:
76 76 PythonQtValueStorage() {
77 77 _chunkIdx = 0;
78 78 _chunkOffset = 0;
79 79 _currentChunk = new T[chunkEntries];
80 80 _chunks.append(_currentChunk);
81 81 };
82 82
83 83 //! clear all memory
84 84 void clear() {
85 85 T* chunk;
86 86 foreach(chunk, _chunks) {
87 87 delete[]chunk;
88 88 }
89 89 _chunks.clear();
90 90 }
91 91
92 92 //! reset the storage to 0 (without freeing memory, thus caching old entries for reuse)
93 93 void reset() {
94 94 _chunkIdx = 0;
95 95 _chunkOffset = 0;
96 96 _currentChunk = _chunks.at(0);
97 97 }
98 98
99 99 //! get the current position to be restored with setPos
100 100 void getPos(PythonQtValueStoragePosition & pos) {
101 101 pos.chunkIdx = _chunkIdx;
102 102 pos.chunkOffset = _chunkOffset;
103 103 }
104 104
105 105 //! set the current position (without freeing memory, thus caching old entries for reuse)
106 106 void setPos(const PythonQtValueStoragePosition& pos) {
107 107 _chunkOffset = pos.chunkOffset;
108 108 if (_chunkIdx != pos.chunkIdx) {
109 109 _chunkIdx = pos.chunkIdx;
110 110 _currentChunk = _chunks.at(_chunkIdx);
111 111 }
112 112 }
113 113
114 114 //! add one default constructed value and return the pointer to it
115 115 T* nextValuePtr() {
116 116 if (_chunkOffset>=chunkEntries) {
117 117 _chunkIdx++;
118 118 if (_chunkIdx >= _chunks.size()) {
119 119 T* newChunk = new T[chunkEntries];
120 120 _chunks.append(newChunk);
121 121 _currentChunk = newChunk;
122 122 } else {
123 123 _currentChunk = _chunks.at(_chunkIdx);
124 124 }
125 125 _chunkOffset = 0;
126 126 }
127 127 T* newEntry = _currentChunk + _chunkOffset;
128 128 _chunkOffset++;
129 129 return newEntry;
130 130 };
131 131
132 132 private:
133 133 QList<T*> _chunks;
134 134
135 135 int _chunkIdx;
136 136 int _chunkOffset;
137 137 T* _currentChunk;
138 138
139 139 };
140 140
141 141
142 142 #endif
Show file before | Show file after | Hide comments
@@ -1,101 +1,101
1 1 /*
2 2 *
3 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
3 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
4 4 *
5 5 * This library is free software; you can redistribute it and/or
6 6 * modify it under the terms of the GNU Lesser General Public
7 7 * License as published by the Free Software Foundation; either
8 8 * version 2.1 of the License, or (at your option) any later version.
9 9 *
10 10 * This library is distributed in the hope that it will be useful,
11 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 13 * Lesser General Public License for more details.
14 14 *
15 15 * Further, this software is distributed without any warranty that it is
16 16 * free of the rightful claim of any third person regarding infringement
17 17 * or the like. Any license provided herein, whether implied or
18 18 * otherwise, applies only to this software file. Patent licenses, if
19 19 * any, provided herein do not apply to combinations of this program with
20 20 * other software, or any other product whatsoever.
21 21 *
22 22 * You should have received a copy of the GNU Lesser General Public
23 23 * License along with this library; if not, write to the Free Software
24 24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 25 *
26 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
26 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
27 27 * 28359 Bremen, Germany or:
28 28 *
29 29 * http://www.mevis.de
30 30 *
31 31 */
32 32
33 33 //----------------------------------------------------------------------------------
34 34 /*!
35 35 // \file PythonQtObjectPtr.cpp
36 36 // \author Florian Link
37 37 // \author Last changed by $Author: florian $
38 38 // \date 2006-05
39 39 */
40 40 //----------------------------------------------------------------------------------
41 41
42 42 #include <PythonQt.h>
43 43
44 44 QVariant PythonQtObjectPtr::evalScript(const QString& script, int start)
45 45 {
46 46 return PythonQt::self()->evalScript(_object, script, start);
47 47 }
48 48
49 49 void PythonQtObjectPtr::evalFile(const QString& file)
50 50 {
51 51 PythonQt::self()->evalFile(_object, file);
52 52 }
53 53
54 54 QVariant PythonQtObjectPtr::evalCode(PyObject* pycode)
55 55 {
56 56 return PythonQt::self()->evalCode(_object, pycode);
57 57 }
58 58
59 59 void PythonQtObjectPtr::addObject(const QString& name, QObject* object)
60 60 {
61 61 PythonQt::self()->addObject(_object, name, object);
62 62 }
63 63
64 64 void PythonQtObjectPtr::addVariable(const QString& name, const QVariant& v)
65 65 {
66 66 PythonQt::self()->addVariable(_object, name, v);
67 67 }
68 68
69 69 void PythonQtObjectPtr::removeVariable(const QString& name)
70 70 {
71 71 PythonQt::self()->removeVariable(_object, name);
72 72 }
73 73
74 74 QVariant PythonQtObjectPtr::getVariable(const QString& name)
75 75 {
76 76 return PythonQt::self()->getVariable(_object, name);
77 77 }
78 78
79 79
80 80 QVariant PythonQtObjectPtr::call(const QString& callable, const QVariantList& args)
81 81 {
82 82 return PythonQt::self()->call(_object, callable, args);
83 83 }
84 84
85 85 QVariant PythonQtObjectPtr::call(const QVariantList& args)
86 86 {
87 87 return PythonQt::self()->call(_object, args);
88 88 }
89 89
90 90 bool PythonQtObjectPtr::fromVariant(const QVariant& variant)
91 91 {
92 92 if (!variant.isNull()) {
93 93 setObject(qVariantValue<PythonQtObjectPtr>(variant));
94 94 return true;
95 95 }
96 96 else {
97 97 setObject(0);
98 98 return false;
99 99 }
100 100
101 101 }
Show file before | Show file after | Hide comments
@@ -1,174 +1,174
1 1 #ifndef _PYTHONQTOBJECTPTR_H
2 2 #define _PYTHONQTOBJECTPTR_H
3 3
4 4 /*
5 5 *
6 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
6 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
7 7 *
8 8 * This library is free software; you can redistribute it and/or
9 9 * modify it under the terms of the GNU Lesser General Public
10 10 * License as published by the Free Software Foundation; either
11 11 * version 2.1 of the License, or (at your option) any later version.
12 12 *
13 13 * This library is distributed in the hope that it will be useful,
14 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 16 * Lesser General Public License for more details.
17 17 *
18 18 * Further, this software is distributed without any warranty that it is
19 19 * free of the rightful claim of any third person regarding infringement
20 20 * or the like. Any license provided herein, whether implied or
21 21 * otherwise, applies only to this software file. Patent licenses, if
22 22 * any, provided herein do not apply to combinations of this program with
23 23 * other software, or any other product whatsoever.
24 24 *
25 25 * You should have received a copy of the GNU Lesser General Public
26 26 * License along with this library; if not, write to the Free Software
27 27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 28 *
29 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
29 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
30 30 * 28359 Bremen, Germany or:
31 31 *
32 32 * http://www.mevis.de
33 33 *
34 34 */
35 35
36 36 //----------------------------------------------------------------------------------
37 37 /*!
38 38 // \file PythonQtObjectPtr.h
39 39 // \author Florian Link
40 40 // \author Last changed by $Author: florian $
41 41 // \date 2006-05
42 42 */
43 43 //----------------------------------------------------------------------------------
44 44
45 45 #include <Python.h>
46 46 #include "PythonQtSystem.h"
47 47 #include <QVariant>
48 48 #include <QVariantList>
49 49
50 50 //! a smart pointer that stores a PyObject pointer and that handles reference counting automatically
51 51 class PYTHONQT_EXPORT PythonQtObjectPtr
52 52 {
53 53 public:
54 54 PythonQtObjectPtr():_object(NULL) {}
55 55
56 56 PythonQtObjectPtr(const PythonQtObjectPtr &p):_object(NULL) {
57 57 setObject(p.object());
58 58 }
59 59
60 60 //! If the given variant holds a PythonQtObjectPtr, extract the value from it and hold onto the reference. This results in an increment of the reference count.
61 61 PythonQtObjectPtr(const QVariant& variant):_object(NULL) {
62 62 fromVariant(variant);
63 63 }
64 64
65 65 PythonQtObjectPtr(PyObject* o) {
66 66 _object = o;
67 67 if (o) Py_INCREF(_object);
68 68 }
69 69
70 70 ~PythonQtObjectPtr() { if (_object) Py_DECREF(_object); }
71 71
72 72 //! If the given variant holds a PythonQtObjectPtr, extract the value from it and hold onto the reference. This results in an increment of the reference count.
73 73 bool fromVariant(const QVariant& variant);
74 74
75 75 PythonQtObjectPtr &operator=(const PythonQtObjectPtr &p) {
76 76 setObject(p.object());
77 77 return *this;
78 78 }
79 79
80 80 PythonQtObjectPtr &operator=(PyObject* o) {
81 81 setObject(o);
82 82 return *this;
83 83 }
84 84
85 85
86 86 PythonQtObjectPtr &operator=(const QVariant& variant) {
87 87 fromVariant(variant);
88 88 return *this;
89 89 }
90 90
91 91
92 92 bool operator==( const PythonQtObjectPtr &p ) const {
93 93 return object() == p.object();
94 94 }
95 95
96 96 bool operator!= ( const PythonQtObjectPtr& p ) const {
97 97 return !( *this == p );
98 98 }
99 99
100 100 bool operator==( PyObject* p ) const {
101 101 return object() == p;
102 102 }
103 103
104 104 bool operator!= ( PyObject* p ) const {
105 105 return object() != p;
106 106 }
107 107
108 108 bool isNull() const { return !object(); }
109 109
110 110 PyObject* operator->() const { return object(); }
111 111
112 112 PyObject& operator*() const { return *( object() ); }
113 113
114 114 operator PyObject*() const { return object(); }
115 115
116 116 //! sets the object and passes the ownership (stealing the reference, in Python slang)
117 117 void setNewRef(PyObject* o) {
118 118 if (o != _object) {
119 119 if (_object) Py_DECREF(_object);
120 120 _object = o;
121 121 }
122 122 }
123 123
124 124 PyObject* object() const {
125 125 return _object;
126 126 }
127 127
128 128 //! evaluates the given script code in the context of this object and returns the result value
129 129 QVariant evalScript(const QString& script, int start = Py_file_input);
130 130
131 131 //! evaluates the given code and returns the result value (use Py_Compile etc. to create pycode from string)
132 132 //! If pycode is NULL, a python error is printed.
133 133 QVariant evalCode(PyObject* pycode);
134 134
135 135 //! evaluates the given code in the context
136 136 void evalFile(const QString& filename);
137 137
138 138 //! add the given \c object to the \c module as a variable with \c name (it can be removed via clearVariable)
139 139 void addObject(const QString& name, QObject* object);
140 140
141 141 //! add the given variable to the module
142 142 void addVariable(const QString& name, const QVariant& v);
143 143
144 144 //! remove the given variable
145 145 void removeVariable(const QString& name);
146 146
147 147 //! get the variable with the \c name of the \c module, returns an invalid QVariant on error
148 148 QVariant getVariable(const QString& name);
149 149
150 150 //! call the given python object (in the scope of the current object), returns the result converted to a QVariant
151 151 QVariant call(const QString& callable, const QVariantList& args = QVariantList());
152 152
153 153 //! call the contained python object directly, returns the result converted to a QVariant
154 154 QVariant call(const QVariantList& args = QVariantList());
155 155
156 156 protected:
157 157
158 158 void setObject(PyObject* o) {
159 159 if (o != _object) {
160 160 if (_object) Py_DECREF(_object);
161 161 _object = o;
162 162 if (_object) Py_INCREF(_object);
163 163 }
164 164 }
165 165
166 166 private:
167 167 PyObject* _object;
168 168 };
169 169
170 170
171 171 // register it to the meta type system
172 172 Q_DECLARE_METATYPE(PythonQtObjectPtr)
173 173
174 174 #endif No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,80 +1,80
1 1 /*
2 2 *
3 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
3 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
4 4 *
5 5 * This library is free software; you can redistribute it and/or
6 6 * modify it under the terms of the GNU Lesser General Public
7 7 * License as published by the Free Software Foundation; either
8 8 * version 2.1 of the License, or (at your option) any later version.
9 9 *
10 10 * This library is distributed in the hope that it will be useful,
11 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 13 * Lesser General Public License for more details.
14 14 *
15 15 * Further, this software is distributed without any warranty that it is
16 16 * free of the rightful claim of any third person regarding infringement
17 17 * or the like. Any license provided herein, whether implied or
18 18 * otherwise, applies only to this software file. Patent licenses, if
19 19 * any, provided herein do not apply to combinations of this program with
20 20 * other software, or any other product whatsoever.
21 21 *
22 22 * You should have received a copy of the GNU Lesser General Public
23 23 * License along with this library; if not, write to the Free Software
24 24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 25 *
26 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
26 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
27 27 * 28359 Bremen, Germany or:
28 28 *
29 29 * http://www.mevis.de
30 30 *
31 31 */
32 32
33 33 //----------------------------------------------------------------------------------
34 34 /*!
35 35 // \file PythonQtQFileImporter.h
36 36 // \author Florian Link
37 37 // \author Last changed by $Author: florian $
38 38 // \date 2009-03
39 39 */
40 40 //----------------------------------------------------------------------------------
41 41
42 42 #include <QFile>
43 43 #include <QFileInfo>
44 44
45 45 #include "PythonQtQFileImporter.h"
46 46
47 47 PythonQtQFileImporter::PythonQtQFileImporter() {
48 48 }
49 49
50 50 PythonQtQFileImporter::~PythonQtQFileImporter() {
51 51 }
52 52
53 53 QByteArray PythonQtQFileImporter::readFileAsBytes (const QString &filename) {
54 54 QFile f(filename);
55 55 if (f.open(QIODevice::ReadOnly)) {
56 56 return f.readAll();
57 57 } else {
58 58 return QByteArray();
59 59 }
60 60 }
61 61
62 62 QByteArray PythonQtQFileImporter::readSourceFile (const QString &filename, bool &ok) {
63 63 QFile f(filename);
64 64 if (f.open(QIODevice::ReadOnly | QIODevice::Text)) {
65 65 ok = true;
66 66 return f.readAll();
67 67 } else {
68 68 ok = false;
69 69 return QByteArray();
70 70 }
71 71 }
72 72
73 73 bool PythonQtQFileImporter::exists (const QString &filename) {
74 74 return QFile::exists(filename);
75 75 }
76 76
77 77 QDateTime PythonQtQFileImporter::lastModifiedDate (const QString &filename) {
78 78 QFileInfo fi(filename);
79 79 return fi.lastModified();
80 80 }
Show file before | Show file after | Hide comments
@@ -1,63 +1,63
1 1 #ifndef _PYTHONQTQFILEIMPORTER_H
2 2 #define _PYTHONQTQFILEIMPORTER_H
3 3
4 4 /*
5 5 *
6 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
6 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
7 7 *
8 8 * This library is free software; you can redistribute it and/or
9 9 * modify it under the terms of the GNU Lesser General Public
10 10 * License as published by the Free Software Foundation; either
11 11 * version 2.1 of the License, or (at your option) any later version.
12 12 *
13 13 * This library is distributed in the hope that it will be useful,
14 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 16 * Lesser General Public License for more details.
17 17 *
18 18 * Further, this software is distributed without any warranty that it is
19 19 * free of the rightful claim of any third person regarding infringement
20 20 * or the like. Any license provided herein, whether implied or
21 21 * otherwise, applies only to this software file. Patent licenses, if
22 22 * any, provided herein do not apply to combinations of this program with
23 23 * other software, or any other product whatsoever.
24 24 *
25 25 * You should have received a copy of the GNU Lesser General Public
26 26 * License along with this library; if not, write to the Free Software
27 27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 28 *
29 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
29 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
30 30 * 28359 Bremen, Germany or:
31 31 *
32 32 * http://www.mevis.de
33 33 *
34 34 */
35 35
36 36 //----------------------------------------------------------------------------------
37 37 /*!
38 38 // \file PythonQtQFileImporter.h
39 39 // \author Florian Link
40 40 // \author Last changed by $Author: florian $
41 41 // \date 2009-03
42 42 */
43 43 //----------------------------------------------------------------------------------
44 44
45 45 #include <PythonQtImportFileInterface.h>
46 46
47 47 //! default importer implementation using QFile to load python code
48 48 class PythonQtQFileImporter : public PythonQtImportFileInterface {
49 49 public:
50 50 PythonQtQFileImporter();
51 51 ~PythonQtQFileImporter();
52 52
53 53 QByteArray readFileAsBytes (const QString &filename);
54 54
55 55 QByteArray readSourceFile (const QString &filename, bool &ok);
56 56
57 57 bool exists (const QString &filename);
58 58
59 59 QDateTime lastModifiedDate (const QString &filename);
60 60
61 61 };
62 62
63 63 #endif
Show file before | Show file after | Hide comments
@@ -1,226 +1,226
1 1 /*
2 2 *
3 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
3 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
4 4 *
5 5 * This library is free software; you can redistribute it and/or
6 6 * modify it under the terms of the GNU Lesser General Public
7 7 * License as published by the Free Software Foundation; either
8 8 * version 2.1 of the License, or (at your option) any later version.
9 9 *
10 10 * This library is distributed in the hope that it will be useful,
11 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 13 * Lesser General Public License for more details.
14 14 *
15 15 * Further, this software is distributed without any warranty that it is
16 16 * free of the rightful claim of any third person regarding infringement
17 17 * or the like. Any license provided herein, whether implied or
18 18 * otherwise, applies only to this software file. Patent licenses, if
19 19 * any, provided herein do not apply to combinations of this program with
20 20 * other software, or any other product whatsoever.
21 21 *
22 22 * You should have received a copy of the GNU Lesser General Public
23 23 * License along with this library; if not, write to the Free Software
24 24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 25 *
26 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
26 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
27 27 * 28359 Bremen, Germany or:
28 28 *
29 29 * http://www.mevis.de
30 30 *
31 31 */
32 32
33 33 //----------------------------------------------------------------------------------
34 34 /*!
35 35 // \file PythonQtSignalReceiver.cpp
36 36 // \author Florian Link
37 37 // \author Last changed by $Author: florian $
38 38 // \date 2006-05
39 39 */
40 40 //----------------------------------------------------------------------------------
41 41
42 42 #include "PythonQtSignalReceiver.h"
43 43 #include "PythonQtClassInfo.h"
44 44 #include "PythonQtMethodInfo.h"
45 45 #include "PythonQtConversion.h"
46 46 #include <QMetaObject>
47 47 #include <QMetaMethod>
48 48 #include "funcobject.h"
49 49
50 50 void PythonQtSignalTarget::call(void **arguments) const {
51 51 PyObject* result = call(_callable, methodInfo(), arguments);
52 52 if (result) {
53 53 Py_DECREF(result);
54 54 }
55 55 }
56 56
57 57 PyObject* PythonQtSignalTarget::call(PyObject* callable, const PythonQtMethodInfo* methodInfos, void **arguments, bool skipFirstArgumentOfMethodInfo)
58 58 {
59 59 // Note: we check if the callable is a PyFunctionObject and has a fixed number of arguments
60 60 // if that is the case, we only pass these arguments to python and skip the additional arguments from the signal
61 61
62 62 int numPythonArgs = -1;
63 63 if (PyFunction_Check(callable)) {
64 64 PyObject* o = callable;
65 65 PyFunctionObject* func = (PyFunctionObject*)o;
66 66 PyCodeObject* code = (PyCodeObject*)func->func_code;
67 67 if (!(code->co_flags & 0x04)) {
68 68 numPythonArgs = code->co_argcount;
69 69 } else {
70 70 // variable numbers of arguments allowed
71 71 }
72 72 } else if (PyMethod_Check(callable)) {
73 73 PyObject* o = callable;
74 74 PyMethodObject* method = (PyMethodObject*)o;
75 75 if (PyFunction_Check(method->im_func)) {
76 76 PyFunctionObject* func = (PyFunctionObject*)method->im_func;
77 77 PyCodeObject* code = (PyCodeObject*)func->func_code;
78 78 if (!(code->co_flags & 0x04)) {
79 79 numPythonArgs = code->co_argcount - 1; // we subtract one because the first is "self"
80 80 } else {
81 81 // variable numbers of arguments allowed
82 82 }
83 83 }
84 84 }
85 85
86 86 const PythonQtMethodInfo* m = methodInfos;
87 87 // parameterCount includes return value:
88 88 int count = m->parameterCount();
89 89 if (numPythonArgs!=-1) {
90 90 if (count>numPythonArgs+1) {
91 91 // take less arguments
92 92 count = numPythonArgs+1;
93 93 }
94 94 }
95 95
96 96 PyObject* pargs = NULL;
97 97 if (count>1) {
98 98 pargs = PyTuple_New(count-1);
99 99 }
100 100 bool err = false;
101 101 // transform Qt values to Python
102 102 const QList<PythonQtMethodInfo::ParameterInfo>& params = m->parameters();
103 103 for (int i = 1; i < count; i++) {
104 104 const PythonQtMethodInfo::ParameterInfo& param = params.at(i);
105 105 PyObject* arg = PythonQtConv::ConvertQtValueToPython(param, arguments[i]);
106 106 if (arg) {
107 107 // steals reference, no unref
108 108 PyTuple_SetItem(pargs, i-1,arg);
109 109 } else {
110 110 err = true;
111 111 break;
112 112 }
113 113 }
114 114
115 115 PyObject* result = NULL;
116 116 if (!err) {
117 117 PyErr_Clear();
118 118 result = PyObject_CallObject(callable, pargs);
119 119 if (result) {
120 120 // ok
121 121 } else {
122 122 PythonQt::self()->handleError();
123 123 }
124 124 }
125 125 if (pargs) {
126 126 // free the arguments again
127 127 Py_DECREF(pargs);
128 128 }
129 129
130 130 return result;
131 131 }
132 132
133 133 //------------------------------------------------------------------------------
134 134
135 135 PythonQtSignalReceiver::PythonQtSignalReceiver(QObject* obj):PythonQtSignalReceiverBase(obj)
136 136 {
137 137 _obj = obj;
138 138
139 139 // fetch the class info for object, since we will need to for correct enum resolution in
140 140 // signals
141 141 _objClassInfo = PythonQt::priv()->getClassInfo(obj->metaObject());
142 142 if (!_objClassInfo || !_objClassInfo->isQObject()) {
143 143 PythonQt::self()->registerClass(obj->metaObject());
144 144 _objClassInfo = PythonQt::priv()->getClassInfo(obj->metaObject());
145 145 }
146 146 // force decorator/enum creation
147 147 _objClassInfo->decorator();
148 148
149 149 _slotCount = staticMetaObject.methodOffset();
150 150 }
151 151
152 152 PythonQtSignalReceiver::~PythonQtSignalReceiver()
153 153 {
154 154 PythonQt::priv()->removeSignalEmitter(_obj);
155 155 }
156 156
157 157
158 158 bool PythonQtSignalReceiver::addSignalHandler(const char* signal, PyObject* callable)
159 159 {
160 160 bool flag = false;
161 161 int sigId = getSignalIndex(signal);
162 162 if (sigId>=0) {
163 163 // create PythonQtMethodInfo from signal
164 164 QMetaMethod meta = _obj->metaObject()->method(sigId);
165 165 const PythonQtMethodInfo* signalInfo = PythonQtMethodInfo::getCachedMethodInfo(meta, _objClassInfo);
166 166 PythonQtSignalTarget t(sigId, signalInfo, _slotCount, callable);
167 167 _targets.append(t);
168 168 // now connect to ourselves with the new slot id
169 169 QMetaObject::connect(_obj, sigId, this, _slotCount, Qt::AutoConnection, 0);
170 170
171 171 _slotCount++;
172 172 flag = true;
173 173 }
174 174 return flag;
175 175 }
176 176
177 177 bool PythonQtSignalReceiver::removeSignalHandler(const char* signal, PyObject* callable)
178 178 {
179 179 bool found = false;
180 180 int sigId = getSignalIndex(signal);
181 181 if (sigId>=0) {
182 182 QMutableListIterator<PythonQtSignalTarget> i(_targets);
183 183 while (i.hasNext()) {
184 184 if (i.next().isSame(sigId, callable)) {
185 185 i.remove();
186 186 found = true;
187 187 break;
188 188 }
189 189 }
190 190 }
191 191 return found;
192 192 }
193 193
194 194 void PythonQtSignalReceiver::removeSignalHandlers()
195 195 {
196 196 _targets.clear();
197 197 }
198 198
199 199 int PythonQtSignalReceiver::getSignalIndex(const char* signal)
200 200 {
201 201 int sigId = _obj->metaObject()->indexOfSignal(signal+1);
202 202 if (sigId<0) {
203 203 QByteArray tmpSig = QMetaObject::normalizedSignature(signal+1);
204 204 sigId = _obj->metaObject()->indexOfSignal(tmpSig);
205 205 }
206 206 return sigId;
207 207 }
208 208
209 209 int PythonQtSignalReceiver::qt_metacall(QMetaObject::Call c, int id, void **arguments)
210 210 {
211 211 // mlabDebugConst("PythonQt", "PythonQtSignalReceiver invoke " << _obj->className() << " " << _obj->name() << " " << id);
212 212 if (c != QMetaObject::InvokeMetaMethod) {
213 213 QObject::qt_metacall(c, id, arguments);
214 214 }
215 215
216 216 bool found = false;
217 217 foreach(const PythonQtSignalTarget& t, _targets) {
218 218 if (t.slotId() == id) {
219 219 found = true;
220 220 t.call(arguments);
221 221 break;
222 222 }
223 223 }
224 224 return 0;
225 225 }
226 226
Show file before | Show file after | Hide comments
@@ -1,141 +1,141
1 1 #ifndef _PYTHONQTSIGNALRECEIVER_H
2 2 #define _PYTHONQTSIGNALRECEIVER_H
3 3
4 4 /*
5 5 *
6 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
6 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
7 7 *
8 8 * This library is free software; you can redistribute it and/or
9 9 * modify it under the terms of the GNU Lesser General Public
10 10 * License as published by the Free Software Foundation; either
11 11 * version 2.1 of the License, or (at your option) any later version.
12 12 *
13 13 * This library is distributed in the hope that it will be useful,
14 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 16 * Lesser General Public License for more details.
17 17 *
18 18 * Further, this software is distributed without any warranty that it is
19 19 * free of the rightful claim of any third person regarding infringement
20 20 * or the like. Any license provided herein, whether implied or
21 21 * otherwise, applies only to this software file. Patent licenses, if
22 22 * any, provided herein do not apply to combinations of this program with
23 23 * other software, or any other product whatsoever.
24 24 *
25 25 * You should have received a copy of the GNU Lesser General Public
26 26 * License along with this library; if not, write to the Free Software
27 27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 28 *
29 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
29 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
30 30 * 28359 Bremen, Germany or:
31 31 *
32 32 * http://www.mevis.de
33 33 *
34 34 */
35 35
36 36 //----------------------------------------------------------------------------------
37 37 /*!
38 38 // \file PythonQtSignalReceiver.h
39 39 // \author Florian Link
40 40 // \author Last changed by $Author: florian $
41 41 // \date 2006-05
42 42 */
43 43 //----------------------------------------------------------------------------------
44 44
45 45 #include <Python.h>
46 46 #include "PythonQtSystem.h"
47 47 #include "PythonQtObjectPtr.h"
48 48
49 49 class PythonQtMethodInfo;
50 50 class PythonQtClassInfo;
51 51
52 52 //! stores information about a signal target
53 53 /*! copy construction and assignment works fine with the C++ standard behaviour and are thus not implemented
54 54 */
55 55 class PYTHONQT_EXPORT PythonQtSignalTarget {
56 56 public:
57 57 PythonQtSignalTarget() {
58 58 _signalId = -1;
59 59 _methodInfo = NULL;
60 60 _slotId = -1;
61 61 }
62 62
63 63 PythonQtSignalTarget(int signalId,const PythonQtMethodInfo* methodInfo, int slotId, PyObject* callable)
64 64 {
65 65 _signalId = signalId;
66 66 _slotId = slotId;
67 67 _methodInfo = methodInfo;
68 68 _callable = callable;
69 69 };
70 70
71 71 ~PythonQtSignalTarget() {
72 72 };
73 73
74 74 //! get the id of the original signal
75 75 int signalId() const { return _signalId; }
76 76
77 77 //! get the id that was assigned to this simulated slot
78 78 int slotId() const { return _slotId; }
79 79
80 80 //! get the signals parameter info
81 81 const PythonQtMethodInfo* methodInfo() const { return _methodInfo; }
82 82
83 83 //! call the python callable with the given arguments (as defined in methodInfo)
84 84 void call(void **arguments) const;
85 85
86 86 //! check if it is the same signal target
87 87 bool isSame(int signalId, PyObject* callable) const { return callable==_callable && signalId==_signalId; }
88 88
89 89 //! call the given callable with arguments described by PythonQtMethodInfo, returns a new reference as result value (or NULL)
90 90 static PyObject* call(PyObject* callable, const PythonQtMethodInfo* methodInfo, void **arguments, bool skipFirstArgumentOfMethodInfo = false);
91 91
92 92 private:
93 93 int _signalId;
94 94 int _slotId;
95 95 const PythonQtMethodInfo* _methodInfo;
96 96 PythonQtObjectPtr _callable;
97 97 };
98 98
99 99 //! base class for signal receivers
100 100 /*!
101 101 */
102 102 class PythonQtSignalReceiverBase : public QObject {
103 103 Q_OBJECT
104 104 public:
105 105 PythonQtSignalReceiverBase(QObject* obj):QObject(obj) {};
106 106 };
107 107
108 108 //! receives all signals for one QObject
109 109 /*! we derive from our base but do not declare the QObject macro because we want to reimplement qt_metacall only.
110 110 */
111 111 class PythonQtSignalReceiver : public PythonQtSignalReceiverBase {
112 112
113 113 public:
114 114 PythonQtSignalReceiver(QObject* obj);
115 115 ~PythonQtSignalReceiver();
116 116
117 117 //! add a signal handler
118 118 bool addSignalHandler(const char* signal, PyObject* callable);
119 119
120 120 //! remove a signal handler
121 121 bool removeSignalHandler(const char* signal, PyObject* callable);
122 122
123 123 //! remove all signal handlers
124 124 void removeSignalHandlers();
125 125
126 126 //! we implement this method to simulate a number of slots that match the ids in _targets
127 127 virtual int qt_metacall(QMetaObject::Call c, int id, void **arguments);
128 128
129 129 private:
130 130 //! get the index of the signal
131 131 int getSignalIndex(const char* signal);
132 132
133 133 QObject* _obj;
134 134 PythonQtClassInfo* _objClassInfo;
135 135 int _slotCount;
136 136 // linear list may get slow on multiple targets, but I think typically we have many objects and just a few signals
137 137 QList<PythonQtSignalTarget> _targets;
138 138 };
139 139
140 140
141 141 #endif
Show file before | Show file after | Hide comments
@@ -1,511 +1,511
1 1 /*
2 2 *
3 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
3 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
4 4 *
5 5 * This library is free software; you can redistribute it and/or
6 6 * modify it under the terms of the GNU Lesser General Public
7 7 * License as published by the Free Software Foundation; either
8 8 * version 2.1 of the License, or (at your option) any later version.
9 9 *
10 10 * This library is distributed in the hope that it will be useful,
11 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 13 * Lesser General Public License for more details.
14 14 *
15 15 * Further, this software is distributed without any warranty that it is
16 16 * free of the rightful claim of any third person regarding infringement
17 17 * or the like. Any license provided herein, whether implied or
18 18 * otherwise, applies only to this software file. Patent licenses, if
19 19 * any, provided herein do not apply to combinations of this program with
20 20 * other software, or any other product whatsoever.
21 21 *
22 22 * You should have received a copy of the GNU Lesser General Public
23 23 * License along with this library; if not, write to the Free Software
24 24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 25 *
26 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
26 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
27 27 * 28359 Bremen, Germany or:
28 28 *
29 29 * http://www.mevis.de
30 30 *
31 31 */
32 32
33 33 //----------------------------------------------------------------------------------
34 34 /*!
35 35 // \file PythonQtSlot.cpp
36 36 // \author Florian Link
37 37 // \author Last changed by $Author: florian $
38 38 // \date 2006-05
39 39 */
40 40 //----------------------------------------------------------------------------------
41 41
42 42 #include "PythonQt.h"
43 43 #include "PythonQtSlot.h"
44 44 #include "PythonQtInstanceWrapper.h"
45 45 #include "PythonQtClassInfo.h"
46 46 #include "PythonQtMisc.h"
47 47 #include "PythonQtConversion.h"
48 48 #include <iostream>
49 49
50 50 #define PYTHONQT_MAX_ARGS 32
51 51
52 52
53 53 bool PythonQtCallSlot(PythonQtClassInfo* classInfo, QObject* objectToCall, PyObject* args, bool strict, PythonQtSlotInfo* info, void* firstArgument, PyObject** pythonReturnValue, void** directReturnValuePointer)
54 54 {
55 55 static unsigned int recursiveEntry = 0;
56 56
57 57 if (directReturnValuePointer) {
58 58 *directReturnValuePointer = NULL;
59 59 }
60 60 // store the current storage position, so that we can get back to this state after a slot is called
61 61 // (do this locally, so that we have all positions on the stack
62 62 PythonQtValueStoragePosition globalValueStoragePos;
63 63 PythonQtValueStoragePosition globalPtrStoragePos;
64 64 PythonQtValueStoragePosition globalVariantStoragePos;
65 65 PythonQtConv::global_valueStorage.getPos(globalValueStoragePos);
66 66 PythonQtConv::global_ptrStorage.getPos(globalPtrStoragePos);
67 67 PythonQtConv::global_variantStorage.getPos(globalVariantStoragePos);
68 68
69 69 recursiveEntry++;
70 70
71 71 // the arguments that are passed to qt_metacall
72 72 void* argList[PYTHONQT_MAX_ARGS];
73 73 PyObject* result = NULL;
74 74 int argc = info->parameterCount();
75 75 const QList<PythonQtSlotInfo::ParameterInfo>& params = info->parameters();
76 76
77 77 const PythonQtSlotInfo::ParameterInfo& returnValueParam = params.at(0);
78 78 // set return argument to NULL
79 79 argList[0] = NULL;
80 80
81 81 bool ok = true;
82 82 bool skipFirst = false;
83 83 if (info->isInstanceDecorator()) {
84 84 skipFirst = true;
85 85
86 86 // for decorators on CPP objects, we take the cpp ptr, for QObjects we take the QObject pointer
87 87 void* arg1 = firstArgument;
88 88 if (!arg1) {
89 89 arg1 = objectToCall;
90 90 }
91 91 if (arg1) {
92 92 // upcast to correct parent class
93 93 arg1 = ((char*)arg1)+info->upcastingOffset();
94 94 }
95 95
96 96 argList[1] = &arg1;
97 97 if (ok) {
98 98 for (int i = 2; i<argc && ok; i++) {
99 99 const PythonQtSlotInfo::ParameterInfo& param = params.at(i);
100 100 //std::cout << param.name.data() << " " << param.typeId << (param.isPointer?"*":"") << (param.isConst?" const":"") << std::endl;
101 101 argList[i] = PythonQtConv::ConvertPythonToQt(param, PyTuple_GET_ITEM(args, i-2), strict, classInfo);
102 102 if (argList[i]==NULL) {
103 103 ok = false;
104 104 break;
105 105 }
106 106 }
107 107 }
108 108 } else {
109 109 for (int i = 1; i<argc && ok; i++) {
110 110 const PythonQtSlotInfo::ParameterInfo& param = params.at(i);
111 111 //std::cout << param.name.data() << " " << param.typeId << (param.isPointer?"*":"") << (param.isConst?" const":"") << std::endl;
112 112 argList[i] = PythonQtConv::ConvertPythonToQt(param, PyTuple_GET_ITEM(args, i-1), strict, classInfo);
113 113 if (argList[i]==NULL) {
114 114 ok = false;
115 115 break;
116 116 }
117 117 }
118 118 }
119 119
120 120 if (ok) {
121 121 // parameters are ok, now create the qt return value which is assigned to by metacall
122 122 if (returnValueParam.typeId != QMetaType::Void) {
123 123 // create empty default value for the return value
124 124 if (!directReturnValuePointer) {
125 125 // create empty default value for the return value
126 126 argList[0] = PythonQtConv::CreateQtReturnValue(returnValueParam);
127 127 if (argList[0]==NULL) {
128 128 // return value could not be created, maybe we have a registered class with a default constructor, so that we can construct the pythonqt wrapper object and
129 129 // pass its internal pointer
130 130 PythonQtClassInfo* info = PythonQt::priv()->getClassInfo(returnValueParam.name);
131 131 if (info && info->pythonQtClassWrapper()) {
132 132 PyObject* emptyTuple = PyTuple_New(0);
133 133 // 1) default construct an empty object as python object (owned by PythonQt), by calling the meta class with empty arguments
134 134 result = PyObject_Call((PyObject*)info->pythonQtClassWrapper(), emptyTuple, NULL);
135 135 if (result) {
136 136 argList[0] = ((PythonQtInstanceWrapper*)result)->_wrappedPtr;
137 137 }
138 138 Py_DECREF(emptyTuple);
139 139 }
140 140 }
141 141 } else {
142 142 // we can use our pointer directly!
143 143 argList[0] = directReturnValuePointer;
144 144 }
145 145 }
146 146
147 147 // invoke the slot via metacall
148 148 (info->decorator()?info->decorator():objectToCall)->qt_metacall(QMetaObject::InvokeMetaMethod, info->slotIndex(), argList);
149 149
150 150 // handle the return value (which in most cases still needs to be converted to a Python object)
151 151 if (argList[0] || returnValueParam.typeId == QMetaType::Void) {
152 152 if (directReturnValuePointer) {
153 153 result = NULL;
154 154 } else {
155 155 // the resulting object maybe present already, because we created it above at 1)...
156 156 if (!result) {
157 157 result = PythonQtConv::ConvertQtValueToPython(returnValueParam, argList[0]);
158 158 }
159 159 }
160 160 } else {
161 161 QString e = QString("Called ") + info->fullSignature() + ", return type '" + returnValueParam.name + "' is ignored because it is unknown to PythonQt. Probably you should register it using qRegisterMetaType() or add a default constructor decorator to the class.";
162 162 PyErr_SetString(PyExc_ValueError, e.toLatin1().data());
163 163 result = NULL;
164 164 }
165 165 }
166 166 recursiveEntry--;
167 167
168 168 // reset the parameter storage position to the stored pos to "pop" the parameter stack
169 169 PythonQtConv::global_valueStorage.setPos(globalValueStoragePos);
170 170 PythonQtConv::global_ptrStorage.setPos(globalPtrStoragePos);
171 171 PythonQtConv::global_variantStorage.setPos(globalVariantStoragePos);
172 172
173 173 *pythonReturnValue = result;
174 174 // NOTE: it is important to only return here, otherwise the stack will not be popped!!!
175 175 return result || (directReturnValuePointer && *directReturnValuePointer);
176 176 }
177 177
178 178 //-----------------------------------------------------------------------------------
179 179
180 180 static PythonQtSlotFunctionObject *pythonqtslot_free_list = NULL;
181 181
182 182 PyObject *PythonQtSlotFunction_Call(PyObject *func, PyObject *args, PyObject *kw)
183 183 {
184 184 PythonQtSlotFunctionObject* f = (PythonQtSlotFunctionObject*)func;
185 185 PythonQtSlotInfo* info = f->m_ml;
186 186 if (PyObject_TypeCheck(f->m_self, &PythonQtInstanceWrapper_Type)) {
187 187 PythonQtInstanceWrapper* self = (PythonQtInstanceWrapper*) f->m_self;
188 188 if (!info->isClassDecorator() && (self->_obj==NULL && self->_wrappedPtr==NULL)) {
189 189 QString error = QString("Trying to call '") + f->m_ml->slotName() + "' on a destroyed " + self->classInfo()->className() + " object";
190 190 PyErr_SetString(PyExc_ValueError, error.toLatin1().data());
191 191 return NULL;
192 192 } else {
193 193 return PythonQtSlotFunction_CallImpl(self->classInfo(), self->_obj, info, args, kw, self->_wrappedPtr);
194 194 }
195 195 } else if (f->m_self->ob_type == &PythonQtClassWrapper_Type) {
196 196 PythonQtClassWrapper* type = (PythonQtClassWrapper*) f->m_self;
197 197 if (info->isClassDecorator()) {
198 198 return PythonQtSlotFunction_CallImpl(type->classInfo(), NULL, info, args, kw);
199 199 } else {
200 200 // otherwise, it is an unbound call and we have an instanceDecorator or normal slot...
201 201 Py_ssize_t argc = PyTuple_Size(args);
202 202 if (argc>0) {
203 203 PyObject* firstArg = PyTuple_GET_ITEM(args, 0);
204 204 if (PyObject_TypeCheck(firstArg, (PyTypeObject*)&PythonQtInstanceWrapper_Type)
205 205 && ((PythonQtInstanceWrapper*)firstArg)->classInfo()->inherits(type->classInfo())) {
206 206 PythonQtInstanceWrapper* self = (PythonQtInstanceWrapper*)firstArg;
207 207 if (!info->isClassDecorator() && (self->_obj==NULL && self->_wrappedPtr==NULL)) {
208 208 QString error = QString("Trying to call '") + f->m_ml->slotName() + "' on a destroyed " + self->classInfo()->className() + " object";
209 209 PyErr_SetString(PyExc_ValueError, error.toLatin1().data());
210 210 return NULL;
211 211 }
212 212 // strip the first argument...
213 213 PyObject* newargs = PyTuple_GetSlice(args, 1, argc);
214 214 PyObject* result = PythonQtSlotFunction_CallImpl(self->classInfo(), self->_obj, info, newargs, kw, self->_wrappedPtr);
215 215 Py_DECREF(newargs);
216 216 return result;
217 217 } else {
218 218 // first arg is not of correct type!
219 219 QString error = "slot " + info->fullSignature() + " requires " + type->classInfo()->className() + " instance as first argument, got " + firstArg->ob_type->tp_name;
220 220 PyErr_SetString(PyExc_ValueError, error.toLatin1().data());
221 221 return NULL;
222 222 }
223 223 } else {
224 224 // wrong number of args
225 225 QString error = "slot " + info->fullSignature() + " requires " + type->classInfo()->className() + " instance as first argument.";
226 226 PyErr_SetString(PyExc_ValueError, error.toLatin1().data());
227 227 return NULL;
228 228 }
229 229 }
230 230 }
231 231 return NULL;
232 232 }
233 233
234 234 PyObject *PythonQtSlotFunction_CallImpl(PythonQtClassInfo* classInfo, QObject* objectToCall, PythonQtSlotInfo* info, PyObject *args, PyObject * /*kw*/, void* firstArg, void** directReturnValuePointer)
235 235 {
236 236 int argc = args?PyTuple_Size(args):0;
237 237
238 238 #ifdef PYTHONQT_DEBUG
239 239 std::cout << "called " << info->metaMethod()->typeName() << " " << info->metaMethod()->signature() << std::endl;
240 240 #endif
241 241
242 242 PyObject* r = NULL;
243 243 bool ok = false;
244 244 if (directReturnValuePointer) {
245 245 *directReturnValuePointer = NULL;
246 246 }
247 247 if (info->nextInfo()) {
248 248 // overloaded slot call, try on all slots with strict conversion first
249 249 bool strict = true;
250 250 PythonQtSlotInfo* i = info;
251 251 while (i) {
252 252 bool skipFirst = i->isInstanceDecorator();
253 253 if (i->parameterCount()-1-(skipFirst?1:0) == argc) {
254 254 PyErr_Clear();
255 255 ok = PythonQtCallSlot(classInfo, objectToCall, args, strict, i, firstArg, &r, directReturnValuePointer);
256 256 if (PyErr_Occurred() || ok) break;
257 257 }
258 258 i = i->nextInfo();
259 259 if (!i) {
260 260 if (strict) {
261 261 // one more run without being strict
262 262 strict = false;
263 263 i = info;
264 264 }
265 265 }
266 266 }
267 267 if (!ok && !PyErr_Occurred()) {
268 268 QString e = QString("Could not find matching overload for given arguments:\n" + PythonQtConv::PyObjGetString(args) + "\n The following slots are available:\n");
269 269 PythonQtSlotInfo* i = info;
270 270 while (i) {
271 271 e += QString(i->fullSignature()) + "\n";
272 272 i = i->nextInfo();
273 273 }
274 274 PyErr_SetString(PyExc_ValueError, e.toLatin1().data());
275 275 }
276 276 } else {
277 277 // simple (non-overloaded) slot call
278 278 bool skipFirst = info->isInstanceDecorator();
279 279 if (info->parameterCount()-1-(skipFirst?1:0) == argc) {
280 280 PyErr_Clear();
281 281 ok = PythonQtCallSlot(classInfo, objectToCall, args, false, info, firstArg, &r, directReturnValuePointer);
282 282 if (!ok && !PyErr_Occurred()) {
283 283 QString e = QString("Called ") + info->fullSignature() + " with wrong arguments: " + PythonQtConv::PyObjGetString(args);
284 284 PyErr_SetString(PyExc_ValueError, e.toLatin1().data());
285 285 }
286 286 } else {
287 287 QString e = QString("Called ") + info->fullSignature() + " with wrong number of arguments: " + PythonQtConv::PyObjGetString(args);
288 288 PyErr_SetString(PyExc_ValueError, e.toLatin1().data());
289 289 }
290 290 }
291 291
292 292 return r;
293 293 }
294 294
295 295 PyObject *
296 296 PythonQtSlotFunction_New(PythonQtSlotInfo *ml, PyObject *self, PyObject *module)
297 297 {
298 298 PythonQtSlotFunctionObject *op;
299 299 op = pythonqtslot_free_list;
300 300 if (op != NULL) {
301 301 pythonqtslot_free_list = (PythonQtSlotFunctionObject *)(op->m_self);
302 302 PyObject_INIT(op, &PythonQtSlotFunction_Type);
303 303 }
304 304 else {
305 305 op = PyObject_GC_New(PythonQtSlotFunctionObject, &PythonQtSlotFunction_Type);
306 306 if (op == NULL)
307 307 return NULL;
308 308 }
309 309 op->m_ml = ml;
310 310 Py_XINCREF(self);
311 311 op->m_self = self;
312 312 Py_XINCREF(module);
313 313 op->m_module = module;
314 314 PyObject_GC_Track(op);
315 315 return (PyObject *)op;
316 316 }
317 317
318 318 PythonQtSlotInfo*
319 319 PythonQtSlotFunction_GetSlotInfo(PyObject *op)
320 320 {
321 321 if (!PythonQtSlotFunction_Check(op)) {
322 322 PyErr_BadInternalCall();
323 323 return NULL;
324 324 }
325 325 return ((PythonQtSlotFunctionObject *)op) -> m_ml;
326 326 }
327 327
328 328 PyObject *
329 329 PythonQtSlotFunction_GetSelf(PyObject *op)
330 330 {
331 331 if (!PythonQtSlotFunction_Check(op)) {
332 332 PyErr_BadInternalCall();
333 333 return NULL;
334 334 }
335 335 return ((PythonQtSlotFunctionObject *)op) -> m_self;
336 336 }
337 337
338 338 /* Methods (the standard built-in methods, that is) */
339 339
340 340 static void
341 341 meth_dealloc(PythonQtSlotFunctionObject *m)
342 342 {
343 343 PyObject_GC_UnTrack(m);
344 344 Py_XDECREF(m->m_self);
345 345 Py_XDECREF(m->m_module);
346 346 m->m_self = (PyObject *)pythonqtslot_free_list;
347 347 pythonqtslot_free_list = m;
348 348 }
349 349
350 350 static PyObject *
351 351 meth_get__doc__(PythonQtSlotFunctionObject * /*m*/, void * /*closure*/)
352 352 {
353 353 Py_INCREF(Py_None);
354 354 return Py_None;
355 355 }
356 356
357 357 static PyObject *
358 358 meth_get__name__(PythonQtSlotFunctionObject *m, void * /*closure*/)
359 359 {
360 360 return PyString_FromString(m->m_ml->metaMethod()->signature());
361 361 }
362 362
363 363 static int
364 364 meth_traverse(PythonQtSlotFunctionObject *m, visitproc visit, void *arg)
365 365 {
366 366 int err;
367 367 if (m->m_self != NULL) {
368 368 err = visit(m->m_self, arg);
369 369 if (err)
370 370 return err;
371 371 }
372 372 if (m->m_module != NULL) {
373 373 err = visit(m->m_module, arg);
374 374 if (err)
375 375 return err;
376 376 }
377 377 return 0;
378 378 }
379 379
380 380 static PyObject *
381 381 meth_get__self__(PythonQtSlotFunctionObject *m, void * /*closure*/)
382 382 {
383 383 PyObject *self;
384 384 if (PyEval_GetRestricted()) {
385 385 PyErr_SetString(PyExc_RuntimeError,
386 386 "method.__self__ not accessible in restricted mode");
387 387 return NULL;
388 388 }
389 389 self = m->m_self;
390 390 if (self == NULL)
391 391 self = Py_None;
392 392 Py_INCREF(self);
393 393 return self;
394 394 }
395 395
396 396 static PyGetSetDef meth_getsets [] = {
397 397 {"__doc__", (getter)meth_get__doc__, NULL, NULL},
398 398 {"__name__", (getter)meth_get__name__, NULL, NULL},
399 399 {"__self__", (getter)meth_get__self__, NULL, NULL},
400 400 {NULL, NULL, NULL,NULL},
401 401 };
402 402
403 403 #if PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION < 6
404 404 #define PY_WRITE_RESTRICTED WRITE_RESTRICTED
405 405 #endif
406 406
407 407 #define OFF(x) offsetof(PythonQtSlotFunctionObject, x)
408 408
409 409 static PyMemberDef meth_members[] = {
410 410 {"__module__", T_OBJECT, OFF(m_module), PY_WRITE_RESTRICTED},
411 411 {NULL}
412 412 };
413 413
414 414 static PyObject *
415 415 meth_repr(PythonQtSlotFunctionObject *f)
416 416 {
417 417 if (f->m_self->ob_type == &PythonQtClassWrapper_Type) {
418 418 PythonQtClassWrapper* self = (PythonQtClassWrapper*) f->m_self;
419 419 return PyString_FromFormat("<unbound qt slot %s of %s type>",
420 420 f->m_ml->slotName().data(),
421 421 self->classInfo()->className());
422 422 } else {
423 423 return PyString_FromFormat("<qt slot %s of %s instance at %p>",
424 424 f->m_ml->slotName().data(),
425 425 f->m_self->ob_type->tp_name,
426 426 f->m_self);
427 427 }
428 428 }
429 429
430 430 static int
431 431 meth_compare(PythonQtSlotFunctionObject *a, PythonQtSlotFunctionObject *b)
432 432 {
433 433 if (a->m_self != b->m_self)
434 434 return (a->m_self < b->m_self) ? -1 : 1;
435 435 if (a->m_ml == b->m_ml)
436 436 return 0;
437 437 if (strcmp(a->m_ml->metaMethod()->signature(), b->m_ml->metaMethod()->signature()) < 0)
438 438 return -1;
439 439 else
440 440 return 1;
441 441 }
442 442
443 443 static long
444 444 meth_hash(PythonQtSlotFunctionObject *a)
445 445 {
446 446 long x,y;
447 447 if (a->m_self == NULL)
448 448 x = 0;
449 449 else {
450 450 x = PyObject_Hash(a->m_self);
451 451 if (x == -1)
452 452 return -1;
453 453 }
454 454 y = _Py_HashPointer((void*)(a->m_ml));
455 455 if (y == -1)
456 456 return -1;
457 457 x ^= y;
458 458 if (x == -1)
459 459 x = -2;
460 460 return x;
461 461 }
462 462
463 463
464 464 PyTypeObject PythonQtSlotFunction_Type = {
465 465 PyObject_HEAD_INIT(&PyType_Type)
466 466 0,
467 467 "builtin_qt_slot",
468 468 sizeof(PythonQtSlotFunctionObject),
469 469 0,
470 470 (destructor)meth_dealloc, /* tp_dealloc */
471 471 0, /* tp_print */
472 472 0, /* tp_getattr */
473 473 0, /* tp_setattr */
474 474 (cmpfunc)meth_compare, /* tp_compare */
475 475 (reprfunc)meth_repr, /* tp_repr */
476 476 0, /* tp_as_number */
477 477 0, /* tp_as_sequence */
478 478 0, /* tp_as_mapping */
479 479 (hashfunc)meth_hash, /* tp_hash */
480 480 PythonQtSlotFunction_Call, /* tp_call */
481 481 0, /* tp_str */
482 482 PyObject_GenericGetAttr, /* tp_getattro */
483 483 0, /* tp_setattro */
484 484 0, /* tp_as_buffer */
485 485 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
486 486 0, /* tp_doc */
487 487 (traverseproc)meth_traverse, /* tp_traverse */
488 488 0, /* tp_clear */
489 489 0, /* tp_richcompare */
490 490 0, /* tp_weaklistoffset */
491 491 0, /* tp_iter */
492 492 0, /* tp_iternext */
493 493 0, /* tp_methods */
494 494 meth_members, /* tp_members */
495 495 meth_getsets, /* tp_getset */
496 496 0, /* tp_base */
497 497 0, /* tp_dict */
498 498 };
499 499
500 500 /* Clear out the free list */
501 501
502 502 void
503 503 PythonQtSlotFunction_Fini(void)
504 504 {
505 505 while (pythonqtslot_free_list) {
506 506 PythonQtSlotFunctionObject *v = pythonqtslot_free_list;
507 507 pythonqtslot_free_list = (PythonQtSlotFunctionObject *)(v->m_self);
508 508 PyObject_GC_Del(v);
509 509 }
510 510 }
511 511
Show file before | Show file after | Hide comments
@@ -1,80 +1,80
1 1 #ifndef _PYTHONQTSLOT_H
2 2 #define _PYTHONQTSLOT_H
3 3
4 4 /*
5 5 *
6 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
6 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
7 7 *
8 8 * This library is free software; you can redistribute it and/or
9 9 * modify it under the terms of the GNU Lesser General Public
10 10 * License as published by the Free Software Foundation; either
11 11 * version 2.1 of the License, or (at your option) any later version.
12 12 *
13 13 * This library is distributed in the hope that it will be useful,
14 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 16 * Lesser General Public License for more details.
17 17 *
18 18 * Further, this software is distributed without any warranty that it is
19 19 * free of the rightful claim of any third person regarding infringement
20 20 * or the like. Any license provided herein, whether implied or
21 21 * otherwise, applies only to this software file. Patent licenses, if
22 22 * any, provided herein do not apply to combinations of this program with
23 23 * other software, or any other product whatsoever.
24 24 *
25 25 * You should have received a copy of the GNU Lesser General Public
26 26 * License along with this library; if not, write to the Free Software
27 27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 28 *
29 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
29 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
30 30 * 28359 Bremen, Germany or:
31 31 *
32 32 * http://www.mevis.de
33 33 *
34 34 */
35 35
36 36 //----------------------------------------------------------------------------------
37 37 /*!
38 38 // \file PythonQtSlot.h
39 39 // \author Florian Link
40 40 // \author Last changed by $Author: florian $
41 41 // \date 2006-05
42 42 */
43 43 //----------------------------------------------------------------------------------
44 44
45 45 #include "Python.h"
46 46 #include "PythonQtSystem.h"
47 47 #include "structmember.h"
48 48
49 49 class PythonQtSlotInfo;
50 50
51 51 extern PYTHONQT_EXPORT PyTypeObject PythonQtSlotFunction_Type;
52 52
53 53 #define PythonQtSlotFunction_Check(op) ((op)->ob_type == &PythonQtSlotFunction_Type)
54 54
55 55 PythonQtSlotInfo* PythonQtSlotFunction_GetSlotInfo(PyObject *);
56 56 PyObject* PythonQtSlotFunction_GetSelf(PyObject *);
57 57
58 58 /* Macros for direct access to these values. Type checks are *not*
59 59 done, so use with care. */
60 60 #define PythonQtSlotFunction_GET_SELF(func) \
61 61 (((PythonQtSlotFunctionObject *)func) -> m_self)
62 62
63 63 PyObject* PythonQtSlotFunction_Call(PyObject *, PyObject *, PyObject *);
64 64
65 65 PyObject *PythonQtSlotFunction_CallImpl(PythonQtClassInfo* classInfo, QObject* objectToCall, PythonQtSlotInfo* info, PyObject *args, PyObject *kw, void* firstArg=NULL, void** directReturnValuePointer=NULL);
66 66
67 67
68 68 PyObject* PythonQtSlotFunction_New(PythonQtSlotInfo *, PyObject *,
69 69 PyObject *);
70 70
71 71 //! defines a python object that stores a Qt slot info
72 72 typedef struct {
73 73 PyObject_HEAD
74 74 PythonQtSlotInfo *m_ml; /* Description of the C function to call */
75 75 PyObject *m_self; /* Passed as 'self' arg to the C func, can be NULL */
76 76 PyObject *m_module; /* The __module__ attribute, can be anything */
77 77 } PythonQtSlotFunctionObject;
78 78
79 79
80 80 #endif
Show file before | Show file after | Hide comments
@@ -1,314 +1,314
1 1 /*
2 2 *
3 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
3 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
4 4 *
5 5 * This library is free software; you can redistribute it and/or
6 6 * modify it under the terms of the GNU Lesser General Public
7 7 * License as published by the Free Software Foundation; either
8 8 * version 2.1 of the License, or (at your option) any later version.
9 9 *
10 10 * This library is distributed in the hope that it will be useful,
11 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 13 * Lesser General Public License for more details.
14 14 *
15 15 * Further, this software is distributed without any warranty that it is
16 16 * free of the rightful claim of any third person regarding infringement
17 17 * or the like. Any license provided herein, whether implied or
18 18 * otherwise, applies only to this software file. Patent licenses, if
19 19 * any, provided herein do not apply to combinations of this program with
20 20 * other software, or any other product whatsoever.
21 21 *
22 22 * You should have received a copy of the GNU Lesser General Public
23 23 * License along with this library; if not, write to the Free Software
24 24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 25 *
26 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
26 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
27 27 * 28359 Bremen, Germany or:
28 28 *
29 29 * http://www.mevis.de
30 30 *
31 31 */
32 32
33 33 //----------------------------------------------------------------------------------
34 34 /*!
35 35 // \file PythonQtStdDecorators.cpp
36 36 // \author Florian Link
37 37 // \author Last changed by $Author: florian $
38 38 // \date 2007-04
39 39 */
40 40 //----------------------------------------------------------------------------------
41 41
42 42 #include "PythonQtStdDecorators.h"
43 43 #include "PythonQt.h"
44 44 #include "PythonQtClassInfo.h"
45 45 #include <QCoreApplication>
46 46
47 47 bool PythonQtStdDecorators::connect(QObject* sender, const QByteArray& signal, PyObject* callable)
48 48 {
49 49 QByteArray signalTmp;
50 50 char first = signal.at(0);
51 51 if (first>='0' && first<='9') {
52 52 signalTmp = signal;
53 53 } else {
54 54 signalTmp = "2" + signal;
55 55 }
56 56
57 57 if (sender) {
58 58 return PythonQt::self()->addSignalHandler(sender, signalTmp, callable);
59 59 } else {
60 60 return false;
61 61 }
62 62 }
63 63
64 64 bool PythonQtStdDecorators::connect(QObject* sender, const QByteArray& signal, QObject* receiver, const QByteArray& slot)
65 65 {
66 66 bool r = false;
67 67 if (sender && receiver) {
68 68 QByteArray signalTmp;
69 69 char first = signal.at(0);
70 70 if (first>='0' && first<='9') {
71 71 signalTmp = signal;
72 72 } else {
73 73 signalTmp = "2" + signal;
74 74 }
75 75
76 76 QByteArray slotTmp;
77 77 first = slot.at(0);
78 78 if (first>='0' && first<='9') {
79 79 slotTmp = slot;
80 80 } else {
81 81 slotTmp = "1" + slot;
82 82 }
83 83 r = QObject::connect(sender, signalTmp, receiver, slotTmp);
84 84 }
85 85 return r;
86 86 }
87 87
88 88 bool PythonQtStdDecorators::disconnect(QObject* sender, const QByteArray& signal, PyObject* callable)
89 89 {
90 90 QByteArray signalTmp;
91 91 char first = signal.at(0);
92 92 if (first>='0' && first<='9') {
93 93 signalTmp = signal;
94 94 } else {
95 95 signalTmp = "2" + signal;
96 96 }
97 97 if (sender) {
98 98 return PythonQt::self()->removeSignalHandler(sender, signalTmp, callable);
99 99 } else {
100 100 return false;
101 101 }
102 102 }
103 103
104 104 bool PythonQtStdDecorators::disconnect(QObject* sender, const QByteArray& signal, QObject* receiver, const QByteArray& slot)
105 105 {
106 106 bool r = false;
107 107 if (sender && receiver) {
108 108 QByteArray signalTmp;
109 109 char first = signal.at(0);
110 110 if (first>='0' && first<='9') {
111 111 signalTmp = signal;
112 112 } else {
113 113 signalTmp = "2" + signal;
114 114 }
115 115
116 116 QByteArray slotTmp;
117 117 first = slot.at(0);
118 118 if (first>='0' && first<='9') {
119 119 slotTmp = slot;
120 120 } else {
121 121 slotTmp = "1" + slot;
122 122 }
123 123
124 124 r = QObject::disconnect(sender, signalTmp, receiver, slotTmp);
125 125 }
126 126 return r;
127 127 }
128 128
129 129 #undef emit
130 130 void PythonQtStdDecorators::emit(QObject* sender, const QByteArray& signal, PyObject* arg1 ,PyObject* arg2 ,
131 131 PyObject* arg3 ,PyObject* arg4 ,PyObject* arg5 ,PyObject* arg6 ,PyObject* arg7 )
132 132 {
133 133 // TODO xxx
134 134 // use normal PythonQtSlot calling code, add "allowSignal" to member lookup?!
135 135 }
136 136 #define emit
137 137
138 138 QObject* PythonQtStdDecorators::parent(QObject* o) {
139 139 return o->parent();
140 140 }
141 141
142 142 void PythonQtStdDecorators::setParent(QObject* o, QObject* parent)
143 143 {
144 144 o->setParent(parent);
145 145 }
146 146
147 147 const QObjectList* PythonQtStdDecorators::children(QObject* o)
148 148 {
149 149 return &o->children();
150 150 }
151 151
152 152 bool PythonQtStdDecorators::setProperty(QObject* o, const char* name, const QVariant& value)
153 153 {
154 154 return o->setProperty(name, value);
155 155 }
156 156
157 157 QVariant PythonQtStdDecorators::property(QObject* o, const char* name)
158 158 {
159 159 return o->property(name);
160 160 }
161 161
162 162 QString PythonQtStdDecorators::tr(QObject* obj, const QByteArray& text, const QByteArray& ambig, int n)
163 163 {
164 164 return QCoreApplication::translate(obj->metaObject()->className(), text.constData(), ambig.constData(), QCoreApplication::CodecForTr, n);
165 165 }
166 166
167 167 QObject* PythonQtStdDecorators::findChild(QObject* parent, PyObject* type, const QString& name)
168 168 {
169 169 const QMetaObject* meta = NULL;
170 170 const char* typeName = NULL;
171 171
172 172 if (PyObject_TypeCheck(type, &PythonQtClassWrapper_Type)) {
173 173 meta = ((PythonQtClassWrapper*)type)->classInfo()->metaObject();
174 174 } else if (PyObject_TypeCheck(type, &PythonQtInstanceWrapper_Type)) {
175 175 meta = ((PythonQtInstanceWrapper*)type)->classInfo()->metaObject();
176 176 } else if (PyString_Check(type)) {
177 177 typeName = PyString_AsString(type);
178 178 }
179 179
180 180 if (!typeName && !meta)
181 181 return NULL;
182 182
183 183 return findChild(parent, typeName, meta, name);
184 184 }
185 185
186 186 QList<QObject*> PythonQtStdDecorators::findChildren(QObject* parent, PyObject* type, const QString& name)
187 187 {
188 188 const QMetaObject* meta = NULL;
189 189 const char* typeName = NULL;
190 190
191 191 if (PyObject_TypeCheck(type, &PythonQtClassWrapper_Type)) {
192 192 meta = ((PythonQtClassWrapper*)type)->classInfo()->metaObject();
193 193 } else if (PyObject_TypeCheck(type, &PythonQtInstanceWrapper_Type)) {
194 194 meta = ((PythonQtInstanceWrapper*)type)->classInfo()->metaObject();
195 195 } else if (PyString_Check(type)) {
196 196 typeName = PyString_AsString(type);
197 197 }
198 198
199 199 QList<QObject*> list;
200 200
201 201 if (!typeName && !meta)
202 202 return list;
203 203
204 204 findChildren(parent, typeName, meta, name, list);
205 205
206 206 return list;
207 207 }
208 208
209 209 QList<QObject*> PythonQtStdDecorators::findChildren(QObject* parent, PyObject* type, const QRegExp& regExp)
210 210 {
211 211 const QMetaObject* meta = NULL;
212 212 const char* typeName = NULL;
213 213
214 214 if (PyObject_TypeCheck(type, &PythonQtClassWrapper_Type)) {
215 215 meta = ((PythonQtClassWrapper*)type)->classInfo()->metaObject();
216 216 } else if (PyObject_TypeCheck(type, &PythonQtInstanceWrapper_Type)) {
217 217 meta = ((PythonQtInstanceWrapper*)type)->classInfo()->metaObject();
218 218 } else if (PyString_Check(type)) {
219 219 typeName = PyString_AsString(type);
220 220 }
221 221
222 222 QList<QObject*> list;
223 223
224 224 if (!typeName && !meta)
225 225 return list;
226 226
227 227 findChildren(parent, typeName, meta, regExp, list);
228 228
229 229 return list;
230 230 }
231 231
232 232 QObject* PythonQtStdDecorators::findChild(QObject* parent, const char* typeName, const QMetaObject* meta, const QString& name)
233 233 {
234 234 const QObjectList &children = parent->children();
235 235
236 236 int i;
237 237 for (i = 0; i < children.size(); ++i) {
238 238 QObject* obj = children.at(i);
239 239
240 240 if (!obj)
241 241 return NULL;
242 242
243 243 // Skip if the name doesn't match.
244 244 if (!name.isNull() && obj->objectName() != name)
245 245 continue;
246 246
247 247 if ((typeName && obj->inherits(typeName)) ||
248 248 (meta && meta->cast(obj)))
249 249 return obj;
250 250 }
251 251
252 252 for (i = 0; i < children.size(); ++i) {
253 253 QObject* obj = findChild(children.at(i), typeName, meta, name);
254 254
255 255 if (obj != NULL)
256 256 return obj;
257 257 }
258 258
259 259 return NULL;
260 260 }
261 261
262 262 int PythonQtStdDecorators::findChildren(QObject* parent, const char* typeName, const QMetaObject* meta, const QString& name, QList<QObject*>& list)
263 263 {
264 264 const QObjectList& children = parent->children();
265 265 int i;
266 266
267 267 for (i = 0; i < children.size(); ++i) {
268 268 QObject* obj = children.at(i);
269 269
270 270 if (!obj)
271 271 return -1;
272 272
273 273 // Skip if the name doesn't match.
274 274 if (!name.isNull() && obj->objectName() != name)
275 275 continue;
276 276
277 277 if ((typeName && obj->inherits(typeName)) ||
278 278 (meta && meta->cast(obj))) {
279 279 list += obj;
280 280 }
281 281
282 282 if (findChildren(obj, typeName, meta, name, list) < 0)
283 283 return -1;
284 284 }
285 285
286 286 return 0;
287 287 }
288 288
289 289 int PythonQtStdDecorators::findChildren(QObject* parent, const char* typeName, const QMetaObject* meta, const QRegExp& regExp, QList<QObject*>& list)
290 290 {
291 291 const QObjectList& children = parent->children();
292 292 int i;
293 293
294 294 for (i = 0; i < children.size(); ++i) {
295 295 QObject* obj = children.at(i);
296 296
297 297 if (!obj)
298 298 return -1;
299 299
300 300 // Skip if the name doesn't match.
301 301 if (regExp.indexIn(obj->objectName()) == -1)
302 302 continue;
303 303
304 304 if ((typeName && obj->inherits(typeName)) ||
305 305 (meta && meta->cast(obj))) {
306 306 list += obj;
307 307 }
308 308
309 309 if (findChildren(obj, typeName, meta, regExp, list) < 0)
310 310 return -1;
311 311 }
312 312
313 313 return 0;
314 314 }
Show file before | Show file after | Hide comments
@@ -1,112 +1,112
1 1 #ifndef _PYTHONQTSTDDECORATORS_H
2 2 #define _PYTHONQTSTDDECORATORS_H
3 3
4 4 /*
5 5 *
6 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
6 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
7 7 *
8 8 * This library is free software; you can redistribute it and/or
9 9 * modify it under the terms of the GNU Lesser General Public
10 10 * License as published by the Free Software Foundation; either
11 11 * version 2.1 of the License, or (at your option) any later version.
12 12 *
13 13 * This library is distributed in the hope that it will be useful,
14 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 16 * Lesser General Public License for more details.
17 17 *
18 18 * Further, this software is distributed without any warranty that it is
19 19 * free of the rightful claim of any third person regarding infringement
20 20 * or the like. Any license provided herein, whether implied or
21 21 * otherwise, applies only to this software file. Patent licenses, if
22 22 * any, provided herein do not apply to combinations of this program with
23 23 * other software, or any other product whatsoever.
24 24 *
25 25 * You should have received a copy of the GNU Lesser General Public
26 26 * License along with this library; if not, write to the Free Software
27 27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 28 *
29 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
29 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
30 30 * 28359 Bremen, Germany or:
31 31 *
32 32 * http://www.mevis.de
33 33 *
34 34 */
35 35
36 36 //----------------------------------------------------------------------------------
37 37 /*!
38 38 // \file PythonQtStdDecorators.h
39 39 // \author Florian Link
40 40 // \author Last changed by $Author: florian $
41 41 // \date 2007-04
42 42 */
43 43 //----------------------------------------------------------------------------------
44 44
45 45 #include "PythonQtSystem.h"
46 46 #include <Python.h>
47 47 #include <QObject>
48 48 #include <QVariantList>
49 49 #include <QTextDocument>
50 50 #include <QColor>
51 51 #include <QDateTime>
52 52 #include <QDate>
53 53 #include <QTime>
54 54
55 55 class PYTHONQT_EXPORT PythonQtStdDecorators : public QObject
56 56 {
57 57 Q_OBJECT
58 58
59 59 public slots:
60 60 bool connect(QObject* sender, const QByteArray& signal, PyObject* callable);
61 61 bool connect(QObject* sender, const QByteArray& signal, QObject* receiver, const QByteArray& slot);
62 62 bool disconnect(QObject* sender, const QByteArray& signal, PyObject* callable);
63 63 bool disconnect(QObject* sender, const QByteArray& signal, QObject* receiver, const QByteArray& slot);
64 64
65 65 #undef emit
66 66 void emit(QObject* sender, const QByteArray& signal, PyObject* arg1 = NULL,PyObject* arg2 = NULL,
67 67 PyObject* arg3 = NULL,PyObject* arg4 = NULL,PyObject* arg5 = NULL,PyObject* arg6 = NULL,PyObject* arg7 = NULL);
68 68 #define emit
69 69
70 70 QObject* parent(QObject* o);
71 71 void setParent(QObject* o, QObject* parent);
72 72
73 73 const QObjectList* children(QObject* o);
74 74 QObject* findChild(QObject* parent, PyObject* type, const QString& name = QString());
75 75 QList<QObject*> findChildren(QObject* parent, PyObject* type, const QString& name= QString());
76 76 QList<QObject*> findChildren(QObject* parent, PyObject* type, const QRegExp& regExp);
77 77
78 78 bool setProperty(QObject* o, const char* name, const QVariant& value);
79 79 QVariant property(QObject* o, const char* name);
80 80
81 81 double static_Qt_qAbs(double a) { return qAbs(a); }
82 82 double static_Qt_qBound(double a,double b,double c) { return qBound(a,b,c); }
83 83 void static_Qt_qDebug(const QByteArray& msg) { qDebug(msg.constData()); }
84 84 // TODO: multi arg qDebug...
85 85 void static_Qt_qWarning(const QByteArray& msg) { qWarning(msg.constData()); }
86 86 // TODO: multi arg qWarning...
87 87 void static_Qt_qCritical(const QByteArray& msg) { qCritical(msg.constData()); }
88 88 // TODO: multi arg qCritical...
89 89 void static_Qt_qFatal(const QByteArray& msg) { qFatal(msg.constData()); }
90 90 // TODO: multi arg qFatal...
91 91 bool static_Qt_qFuzzyCompare(double a, double b) { return qFuzzyCompare(a, b); }
92 92 double static_Qt_qMax(double a, double b) { return qMax(a, b); }
93 93 double static_Qt_qMin(double a, double b) { return qMin(a, b); }
94 94 int static_Qt_qRound(double a) { return qRound(a); }
95 95 qint64 static_Qt_qRound64(double a) { return qRound64(a); }
96 96 const char* static_Qt_qVersion() { return qVersion(); }
97 97 int static_Qt_qrand() { return qrand(); }
98 98 void static_Qt_qsrand(uint a) { qsrand(a); }
99 99
100 100 QString tr(QObject* obj, const QByteArray& text, const QByteArray& ambig = QByteArray(), int n = -1);
101 101
102 102 QByteArray static_Qt_SIGNAL(const QByteArray& s) { return QByteArray("2") + s; }
103 103 QByteArray static_Qt_SLOT(const QByteArray& s) { return QByteArray("1") + s; }
104 104
105 105 private:
106 106 QObject* findChild(QObject* parent, const char* typeName, const QMetaObject* meta, const QString& name);
107 107 int findChildren(QObject* parent, const char* typeName, const QMetaObject* meta, const QString& name, QList<QObject*>& list);
108 108 int findChildren(QObject* parent, const char* typeName, const QMetaObject* meta, const QRegExp& regExp, QList<QObject*>& list);
109 109 };
110 110
111 111
112 112 #endif
Show file before | Show file after | Hide comments
@@ -1,136 +1,136
1 1 /*
2 2 *
3 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
3 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
4 4 *
5 5 * This library is free software; you can redistribute it and/or
6 6 * modify it under the terms of the GNU Lesser General Public
7 7 * License as published by the Free Software Foundation; either
8 8 * version 2.1 of the License, or (at your option) any later version.
9 9 *
10 10 * This library is distributed in the hope that it will be useful,
11 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 13 * Lesser General Public License for more details.
14 14 *
15 15 * Further, this software is distributed without any warranty that it is
16 16 * free of the rightful claim of any third person regarding infringement
17 17 * or the like. Any license provided herein, whether implied or
18 18 * otherwise, applies only to this software file. Patent licenses, if
19 19 * any, provided herein do not apply to combinations of this program with
20 20 * other software, or any other product whatsoever.
21 21 *
22 22 * You should have received a copy of the GNU Lesser General Public
23 23 * License along with this library; if not, write to the Free Software
24 24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 25 *
26 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
26 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
27 27 * 28359 Bremen, Germany or:
28 28 *
29 29 * http://www.mevis.de
30 30 *
31 31 */
32 32
33 33 //----------------------------------------------------------------------------------
34 34 /*!
35 35 // \file PythonQtStdOut.cpp
36 36 // \author Florian Link
37 37 // \author Last changed by $Author: florian $
38 38 // \date 2006-05
39 39 */
40 40 //----------------------------------------------------------------------------------
41 41
42 42 #include "PythonQtStdOut.h"
43 43
44 44 static PyObject *PythonQtStdOutRedirect_new(PyTypeObject *type, PyObject * /*args*/, PyObject * /*kwds*/)
45 45 {
46 46 PythonQtStdOutRedirect *self;
47 47 self = (PythonQtStdOutRedirect *)type->tp_alloc(type, 0);
48 48
49 49 self->softspace = 0;
50 50 self->_cb = NULL;
51 51
52 52 return (PyObject *)self;
53 53 }
54 54
55 55 static PyObject *PythonQtStdOutRedirect_write(PyObject *self, PyObject *args)
56 56 {
57 57 PythonQtStdOutRedirect* s = (PythonQtStdOutRedirect*)self;
58 58 if (s->_cb) {
59 59 char *string;
60 60 if (!PyArg_ParseTuple(args, "s", &string))
61 61 return NULL;
62 62
63 63 if (s->softspace > 0) {
64 64 (*s->_cb)(QString(""));
65 65 s->softspace = 0;
66 66 }
67 67
68 68 (*s->_cb)(QString(string));
69 69 }
70 70 return Py_BuildValue("");
71 71 }
72 72
73 73 static PyObject *PythonQtStdOutRedirect_flush(PyObject * /*self*/, PyObject * /*args*/)
74 74 {
75 75 return Py_BuildValue("");
76 76 }
77 77
78 78
79 79
80 80 static PyMethodDef PythonQtStdOutRedirect_methods[] = {
81 81 {"write", (PyCFunction)PythonQtStdOutRedirect_write, METH_VARARGS,
82 82 "redirect the writing to a callback"},
83 83 {"flush", (PyCFunction)PythonQtStdOutRedirect_flush, METH_VARARGS,
84 84 "flush the output, currently not implemented but needed for logging framework"
85 85 },
86 86 {NULL, NULL, 0 , NULL} /* sentinel */
87 87 };
88 88
89 89 static PyMemberDef PythonQtStdOutRedirect_members[] = {
90 90 {"softspace", T_INT, offsetof(PythonQtStdOutRedirect, softspace), 0,
91 91 "soft space flag"
92 92 },
93 93 {NULL} /* Sentinel */
94 94 };
95 95
96 96 PyTypeObject PythonQtStdOutRedirectType = {
97 97 PyObject_HEAD_INIT(NULL)
98 98 0, /*ob_size*/
99 99 "PythonQtStdOutRedirect", /*tp_name*/
100 100 sizeof(PythonQtStdOutRedirect), /*tp_basicsize*/
101 101 0, /*tp_itemsize*/
102 102 0, /*tp_dealloc*/
103 103 0, /*tp_print*/
104 104 0, /*tp_getattr*/
105 105 0, /*tp_setattr*/
106 106 0, /*tp_compare*/
107 107 0, /*tp_repr*/
108 108 0, /*tp_as_number*/
109 109 0, /*tp_as_sequence*/
110 110 0, /*tp_as_mapping*/
111 111 0, /*tp_hash */
112 112 0, /*tp_call*/
113 113 0, /*tp_str*/
114 114 0, /*tp_getattro*/
115 115 0, /*tp_setattro*/
116 116 0, /*tp_as_buffer*/
117 117 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
118 118 "PythonQtStdOutRedirect", /* tp_doc */
119 119 0, /* tp_traverse */
120 120 0, /* tp_clear */
121 121 0, /* tp_richcompare */
122 122 0, /* tp_weaklistoffset */
123 123 0, /* tp_iter */
124 124 0, /* tp_iternext */
125 125 PythonQtStdOutRedirect_methods, /* tp_methods */
126 126 PythonQtStdOutRedirect_members, /* tp_members */
127 127 0, /* tp_getset */
128 128 0, /* tp_base */
129 129 0, /* tp_dict */
130 130 0, /* tp_descr_get */
131 131 0, /* tp_descr_set */
132 132 0, /* tp_dictoffset */
133 133 0, /* tp_init */
134 134 0, /* tp_alloc */
135 135 PythonQtStdOutRedirect_new, /* tp_new */
136 136 };
Show file before | Show file after | Hide comments
@@ -1,63 +1,63
1 1 #ifndef _PYTHONQTSTDOUT_H
2 2 #define _PYTHONQTSTDOUT_H
3 3
4 4 /*
5 5 *
6 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
6 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
7 7 *
8 8 * This library is free software; you can redistribute it and/or
9 9 * modify it under the terms of the GNU Lesser General Public
10 10 * License as published by the Free Software Foundation; either
11 11 * version 2.1 of the License, or (at your option) any later version.
12 12 *
13 13 * This library is distributed in the hope that it will be useful,
14 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 16 * Lesser General Public License for more details.
17 17 *
18 18 * Further, this software is distributed without any warranty that it is
19 19 * free of the rightful claim of any third person regarding infringement
20 20 * or the like. Any license provided herein, whether implied or
21 21 * otherwise, applies only to this software file. Patent licenses, if
22 22 * any, provided herein do not apply to combinations of this program with
23 23 * other software, or any other product whatsoever.
24 24 *
25 25 * You should have received a copy of the GNU Lesser General Public
26 26 * License along with this library; if not, write to the Free Software
27 27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 28 *
29 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
29 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
30 30 * 28359 Bremen, Germany or:
31 31 *
32 32 * http://www.mevis.de
33 33 *
34 34 */
35 35
36 36 //----------------------------------------------------------------------------------
37 37 /*!
38 38 // \file PythonQtStdOut.h
39 39 // \author Florian Link
40 40 // \author Last changed by $Author: florian $
41 41 // \date 2006-05
42 42 */
43 43 //----------------------------------------------------------------------------------
44 44
45 45
46 46 #include <Python.h>
47 47 #include "structmember.h"
48 48 #include <QString>
49 49
50 50 //! declares the type of the stdout redirection class
51 51 extern PyTypeObject PythonQtStdOutRedirectType;
52 52
53 53 //! declares the callback that is called from the write() function
54 54 typedef void PythonQtOutputChangedCB(const QString& str);
55 55
56 56 //! declares the stdout redirection class
57 57 typedef struct {
58 58 PyObject_HEAD
59 59 PythonQtOutputChangedCB* _cb;
60 60 int softspace;
61 61 } PythonQtStdOutRedirect;
62 62
63 63 #endif
Show file before | Show file after | Hide comments
@@ -1,56 +1,56
1 1 #ifndef _PYTHONQTSYSTEM_
2 2 #define _PYTHONQTSYSTEM_
3 3
4 4 /*
5 5 *
6 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
6 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
7 7 *
8 8 * This library is free software; you can redistribute it and/or
9 9 * modify it under the terms of the GNU Lesser General Public
10 10 * License as published by the Free Software Foundation; either
11 11 * version 2.1 of the License, or (at your option) any later version.
12 12 *
13 13 * This library is distributed in the hope that it will be useful,
14 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 16 * Lesser General Public License for more details.
17 17 *
18 18 * Further, this software is distributed without any warranty that it is
19 19 * free of the rightful claim of any third person regarding infringement
20 20 * or the like. Any license provided herein, whether implied or
21 21 * otherwise, applies only to this software file. Patent licenses, if
22 22 * any, provided herein do not apply to combinations of this program with
23 23 * other software, or any other product whatsoever.
24 24 *
25 25 * You should have received a copy of the GNU Lesser General Public
26 26 * License along with this library; if not, write to the Free Software
27 27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 28 *
29 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
29 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
30 30 * 28359 Bremen, Germany or:
31 31 *
32 32 * http://www.mevis.de
33 33 *
34 34 */
35 35
36 36 //----------------------------------------------------------------------------------
37 37 /*!
38 38 // \file PythonQtSystem.h
39 39 // \author Florian Link
40 40 // \author Last changed by $Author: florian $
41 41 // \date 2006-05
42 42 */
43 43 //----------------------------------------------------------------------------------
44 44
45 45 #ifdef WIN32
46 46 #ifdef PYTHONQT_EXPORTS
47 47 #define PYTHONQT_EXPORT __declspec(dllexport)
48 48 #else
49 49 #define PYTHONQT_EXPORT __declspec(dllimport)
50 50 #endif
51 51 #else
52 52 #define PYTHONQT_EXPORT
53 53 #endif
54 54
55 55 #endif
56 56
Show file before | Show file after | Hide comments
@@ -1,78 +1,78
1 1 #ifndef _PYTHONQTVARIANTS_
2 2 #define _PYTHONQTVARIANTS_
3 3
4 4 /*
5 5 *
6 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
6 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
7 7 *
8 8 * This library is free software; you can redistribute it and/or
9 9 * modify it under the terms of the GNU Lesser General Public
10 10 * License as published by the Free Software Foundation; either
11 11 * version 2.1 of the License, or (at your option) any later version.
12 12 *
13 13 * This library is distributed in the hope that it will be useful,
14 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 16 * Lesser General Public License for more details.
17 17 *
18 18 * Further, this software is distributed without any warranty that it is
19 19 * free of the rightful claim of any third person regarding infringement
20 20 * or the like. Any license provided herein, whether implied or
21 21 * otherwise, applies only to this software file. Patent licenses, if
22 22 * any, provided herein do not apply to combinations of this program with
23 23 * other software, or any other product whatsoever.
24 24 *
25 25 * You should have received a copy of the GNU Lesser General Public
26 26 * License along with this library; if not, write to the Free Software
27 27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 28 *
29 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
29 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
30 30 * 28359 Bremen, Germany or:
31 31 *
32 32 * http://www.mevis.de
33 33 *
34 34 */
35 35
36 36 //----------------------------------------------------------------------------------
37 37 /*!
38 38 // \file PythonQtVariants.h
39 39 // \author Florian Link
40 40 // \author Last changed by $Author: stk $
41 41 // \date 2006-08
42 42 */
43 43 //----------------------------------------------------------------------------------
44 44
45 45 #include <QBitArray>
46 46 #include <QDate>
47 47 #include <QTime>
48 48 #include <QDateTime>
49 49 #include <QUrl>
50 50 #include <QLocale>
51 51 #include <QRect>
52 52 #include <QRectF>
53 53 #include <QLine>
54 54 #include <QLineF>
55 55 #include <QPoint>
56 56 #include <QPointF>
57 57 #include <QRegExp>
58 58
59 59 #include <QFont>
60 60 #include <QBitmap>
61 61 #include <QBrush>
62 62 #include <QColor>
63 63 #include <QPalette>
64 64 #include <QIcon>
65 65 #include <QImage>
66 66 #include <QPolygon>
67 67 #include <QRegion>
68 68 #include <QBitmap>
69 69 #include <QCursor>
70 70 #include <QSizePolicy>
71 71 #include <QKeySequence>
72 72 #include <QPen>
73 73 #include <QTextLength>
74 74 #include <QTextFormat>
75 75 #include <QMatrix>
76 76
77 77 #endif
78 78
Show file before | Show file after | Hide comments
@@ -1,575 +1,575
1 1 /*
2 2 *
3 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
3 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
4 4 *
5 5 * This library is free software; you can redistribute it and/or
6 6 * modify it under the terms of the GNU Lesser General Public
7 7 * License as published by the Free Software Foundation; either
8 8 * version 2.1 of the License, or (at your option) any later version.
9 9 *
10 10 * This library is distributed in the hope that it will be useful,
11 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 13 * Lesser General Public License for more details.
14 14 *
15 15 * Further, this software is distributed without any warranty that it is
16 16 * free of the rightful claim of any third person regarding infringement
17 17 * or the like. Any license provided herein, whether implied or
18 18 * otherwise, applies only to this software file. Patent licenses, if
19 19 * any, provided herein do not apply to combinations of this program with
20 20 * other software, or any other product whatsoever.
21 21 *
22 22 * You should have received a copy of the GNU Lesser General Public
23 23 * License along with this library; if not, write to the Free Software
24 24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 25 *
26 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
26 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
27 27 * 28359 Bremen, Germany or:
28 28 *
29 29 * http://www.mevis.de
30 30 *
31 31 */
32 32
33 33 //----------------------------------------------------------------------------------
34 34 /*!
35 35 // \file PythonQtScriptingConsole.cpp
36 36 // \author Florian Link
37 37 // \author Last changed by $Author: florian $
38 38 // \date 2006-10
39 39 */
40 40 //----------------------------------------------------------------------------------
41 41
42 42 #include "PythonQtScriptingConsole.h"
43 43
44 44 #include <QMenu>
45 45 #include <QMouseEvent>
46 46 #include <QKeyEvent>
47 47 #include <QApplication>
48 48 #include <QTextDocumentFragment>
49 49 #include <QTextBlock>
50 50 #include <QTextCursor>
51 51 #include <QDebug>
52 52 #include <QCompleter>
53 53 #include <QStringListModel>
54 54 #include <QScrollBar>
55 55
56 56 //-----------------------------------------------------------------------------
57 57
58 58 PythonQtScriptingConsole::PythonQtScriptingConsole(QWidget* parent, const PythonQtObjectPtr& context, Qt::WindowFlags windowFlags)
59 59 : QTextEdit(parent) {
60 60
61 61 setWindowFlags(windowFlags);
62 62
63 63 _defaultTextCharacterFormat = currentCharFormat();
64 64 _context = context;
65 65 _historyPosition = 0;
66 66 _hadError = false;
67 67
68 68 _completer = new QCompleter(this);
69 69 _completer->setWidget(this);
70 70 QObject::connect(_completer, SIGNAL(activated(const QString&)),
71 71 this, SLOT(insertCompletion(const QString&)));
72 72
73 73 clear();
74 74
75 75 connect(PythonQt::self(), SIGNAL(pythonStdOut(const QString&)), this, SLOT(stdOut(const QString&)));
76 76 connect(PythonQt::self(), SIGNAL(pythonStdErr(const QString&)), this, SLOT(stdErr(const QString&)));
77 77 }
78 78
79 79 //-----------------------------------------------------------------------------
80 80
81 81 void PythonQtScriptingConsole::stdOut(const QString& s)
82 82 {
83 83 _stdOut += s;
84 84 int idx;
85 85 while ((idx = _stdOut.indexOf('\n'))!=-1) {
86 86 consoleMessage(_stdOut.left(idx));
87 87 std::cout << _stdOut.left(idx).toLatin1().data() << std::endl;
88 88 _stdOut = _stdOut.mid(idx+1);
89 89 }
90 90 }
91 91
92 92 void PythonQtScriptingConsole::stdErr(const QString& s)
93 93 {
94 94 _hadError = true;
95 95 _stdErr += s;
96 96 int idx;
97 97 while ((idx = _stdErr.indexOf('\n'))!=-1) {
98 98 consoleMessage(_stdErr.left(idx));
99 99 std::cerr << _stdErr.left(idx).toLatin1().data() << std::endl;
100 100 _stdErr = _stdErr.mid(idx+1);
101 101 }
102 102 }
103 103
104 104 void PythonQtScriptingConsole::flushStdOut()
105 105 {
106 106 if (!_stdOut.isEmpty()) {
107 107 stdOut("\n");
108 108 }
109 109 if (!_stdErr.isEmpty()) {
110 110 stdErr("\n");
111 111 }
112 112 }
113 113
114 114 //-----------------------------------------------------------------------------
115 115
116 116 PythonQtScriptingConsole::~PythonQtScriptingConsole() {
117 117 }
118 118
119 119
120 120
121 121 //-----------------------------------------------------------------------------
122 122
123 123 void PythonQtScriptingConsole::clear() {
124 124
125 125 QTextEdit::clear();
126 126 appendCommandPrompt();
127 127 }
128 128
129 129 //-----------------------------------------------------------------------------
130 130
131 131 void PythonQtScriptingConsole::executeLine(bool storeOnly)
132 132 {
133 133 QTextCursor textCursor = this->textCursor();
134 134 textCursor.movePosition(QTextCursor::End);
135 135
136 136 // Select the text from the command prompt until the end of the block
137 137 // and get the selected text.
138 138 textCursor.setPosition(commandPromptPosition());
139 139 textCursor.movePosition(QTextCursor::End, QTextCursor::KeepAnchor);
140 140 QString code = textCursor.selectedText();
141 141
142 142 // i don't know where this trailing space is coming from, blast it!
143 143 if (code.endsWith(" ")) {
144 144 code.truncate(code.length()-1);
145 145 }
146 146
147 147 if (!code.isEmpty()) {
148 148 // Update the history
149 149 _history << code;
150 150 _historyPosition = _history.count();
151 151 _currentMultiLineCode += code + "\n";
152 152
153 153 if (!storeOnly) {
154 154 executeCode(_currentMultiLineCode);
155 155 _currentMultiLineCode = "";
156 156 }
157 157 }
158 158 // Insert a new command prompt
159 159 appendCommandPrompt(storeOnly);
160 160
161 161 }
162 162
163 163 void PythonQtScriptingConsole::executeCode(const QString& code)
164 164 {
165 165 // put visible cursor to the end of the line
166 166 QTextCursor cursor = QTextEdit::textCursor();
167 167 cursor.movePosition(QTextCursor::End);
168 168 setTextCursor(cursor);
169 169
170 170 int cursorPosition = this->textCursor().position();
171 171
172 172 // evaluate the code
173 173 _stdOut = "";
174 174 _stdErr = "";
175 175 PythonQtObjectPtr p;
176 176 PyObject* dict = NULL;
177 177 if (PyModule_Check(_context)) {
178 178 dict = PyModule_GetDict(_context);
179 179 } else if (PyDict_Check(_context)) {
180 180 dict = _context;
181 181 }
182 182 if (dict) {
183 183 p.setNewRef(PyRun_String(code.toLatin1().data(), Py_single_input, dict, dict));
184 184 }
185 185
186 186 if (!p) {
187 187 PythonQt::self()->handleError();
188 188 }
189 189
190 190 flushStdOut();
191 191
192 192 bool messageInserted = (this->textCursor().position() != cursorPosition);
193 193
194 194 // If a message was inserted, then put another empty line before the command prompt
195 195 // to improve readability.
196 196 if (messageInserted) {
197 197 append(QString());
198 198 }
199 199 }
200 200
201 201
202 202 //-----------------------------------------------------------------------------
203 203
204 204 void PythonQtScriptingConsole::appendCommandPrompt(bool storeOnly) {
205 205 if (storeOnly) {
206 206 _commandPrompt = "...> ";
207 207 } else {
208 208 _commandPrompt = "py> ";
209 209 }
210 210 append(_commandPrompt);
211 211
212 212 QTextCursor cursor = textCursor();
213 213 cursor.movePosition(QTextCursor::End);
214 214 setTextCursor(cursor);
215 215 }
216 216
217 217
218 218
219 219 //-----------------------------------------------------------------------------
220 220
221 221 void PythonQtScriptingConsole::setCurrentFont(const QColor& color, bool bold) {
222 222
223 223 QTextCharFormat charFormat(_defaultTextCharacterFormat);
224 224
225 225 QFont font(charFormat.font());
226 226 font.setBold(bold);
227 227 charFormat.setFont(font);
228 228
229 229 QBrush brush(charFormat.foreground());
230 230 brush.setColor(color);
231 231 charFormat.setForeground(brush);
232 232
233 233 setCurrentCharFormat(charFormat);
234 234 }
235 235
236 236
237 237
238 238 //-----------------------------------------------------------------------------
239 239
240 240 int PythonQtScriptingConsole::commandPromptPosition() {
241 241
242 242 QTextCursor textCursor(this->textCursor());
243 243 textCursor.movePosition(QTextCursor::End);
244 244
245 245 return textCursor.block().position() + _commandPrompt.length();
246 246 }
247 247
248 248
249 249
250 250 //-----------------------------------------------------------------------------
251 251
252 252 void PythonQtScriptingConsole::insertCompletion(const QString& completion)
253 253 {
254 254 QTextCursor tc = textCursor();
255 255 tc.movePosition(QTextCursor::Left, QTextCursor::KeepAnchor);
256 256 if (tc.selectedText()==".") {
257 257 tc.insertText(QString(".") + completion);
258 258 } else {
259 259 tc = textCursor();
260 260 tc.movePosition(QTextCursor::StartOfWord, QTextCursor::MoveAnchor);
261 261 tc.movePosition(QTextCursor::EndOfWord, QTextCursor::KeepAnchor);
262 262 tc.insertText(completion);
263 263 setTextCursor(tc);
264 264 }
265 265 }
266 266
267 267 //-----------------------------------------------------------------------------
268 268 void PythonQtScriptingConsole::handleTabCompletion()
269 269 {
270 270 QTextCursor textCursor = this->textCursor();
271 271 int pos = textCursor.position();
272 272 textCursor.setPosition(commandPromptPosition());
273 273 textCursor.movePosition(QTextCursor::End, QTextCursor::KeepAnchor);
274 274 int startPos = textCursor.selectionStart();
275 275
276 276 int offset = pos-startPos;
277 277 QString text = textCursor.selectedText();
278 278
279 279 QString textToComplete;
280 280 int cur = offset;
281 281 while (cur--) {
282 282 QChar c = text.at(cur);
283 283 if (c.isLetterOrNumber() || c == '.' || c == '_') {
284 284 textToComplete.prepend(c);
285 285 } else {
286 286 break;
287 287 }
288 288 }
289 289
290 290
291 291 QString lookup;
292 292 QString compareText = textToComplete;
293 293 int dot = compareText.lastIndexOf('.');
294 294 if (dot!=-1) {
295 295 lookup = compareText.mid(0, dot);
296 296 compareText = compareText.mid(dot+1, offset);
297 297 }
298 298 if (!lookup.isEmpty() || !compareText.isEmpty()) {
299 299 compareText = compareText.toLower();
300 300 QStringList found;
301 301 QStringList l = PythonQt::self()->introspection(_context, lookup, PythonQt::Anything);
302 302 foreach (QString n, l) {
303 303 if (n.toLower().startsWith(compareText)) {
304 304 found << n;
305 305 }
306 306 }
307 307
308 308 if (!found.isEmpty()) {
309 309 _completer->setCompletionPrefix(compareText);
310 310 _completer->setCompletionMode(QCompleter::PopupCompletion);
311 311 _completer->setModel(new QStringListModel(found, _completer));
312 312 _completer->setCaseSensitivity(Qt::CaseInsensitive);
313 313 QTextCursor c = this->textCursor();
314 314 c.movePosition(QTextCursor::StartOfWord);
315 315 QRect cr = cursorRect(c);
316 316 cr.setWidth(_completer->popup()->sizeHintForColumn(0)
317 317 + _completer->popup()->verticalScrollBar()->sizeHint().width());
318 318 cr.translate(0,8);
319 319 _completer->complete(cr);
320 320 } else {
321 321 _completer->popup()->hide();
322 322 }
323 323 } else {
324 324 _completer->popup()->hide();
325 325 }
326 326 }
327 327
328 328 void PythonQtScriptingConsole::keyPressEvent(QKeyEvent* event) {
329 329
330 330 if (_completer && _completer->popup()->isVisible()) {
331 331 // The following keys are forwarded by the completer to the widget
332 332 switch (event->key()) {
333 333 case Qt::Key_Return:
334 334 if (!_completer->popup()->currentIndex().isValid()) {
335 335 insertCompletion(_completer->currentCompletion());
336 336 _completer->popup()->hide();
337 337 event->accept();
338 338 }
339 339 event->ignore();
340 340 return;
341 341 break;
342 342 case Qt::Key_Enter:
343 343 case Qt::Key_Escape:
344 344 case Qt::Key_Tab:
345 345 case Qt::Key_Backtab:
346 346
347 347 event->ignore();
348 348 return; // let the completer do default behavior
349 349 default:
350 350 break;
351 351 }
352 352 }
353 353 bool eventHandled = false;
354 354 QTextCursor textCursor = this->textCursor();
355 355
356 356 int key = event->key();
357 357 switch (key) {
358 358
359 359 case Qt::Key_Left:
360 360
361 361 // Moving the cursor left is limited to the position
362 362 // of the command prompt.
363 363
364 364 if (textCursor.position() <= commandPromptPosition()) {
365 365
366 366 QApplication::beep();
367 367 eventHandled = true;
368 368 }
369 369 break;
370 370
371 371 case Qt::Key_Up:
372 372
373 373 // Display the previous command in the history
374 374 if (_historyPosition>0) {
375 375 _historyPosition--;
376 376 changeHistory();
377 377 }
378 378
379 379 eventHandled = true;
380 380 break;
381 381
382 382 case Qt::Key_Down:
383 383
384 384 // Display the next command in the history
385 385 if (_historyPosition+1<_history.count()) {
386 386 _historyPosition++;
387 387 changeHistory();
388 388 }
389 389
390 390 eventHandled = true;
391 391 break;
392 392
393 393 case Qt::Key_Return:
394 394
395 395 executeLine(event->modifiers() & Qt::ShiftModifier);
396 396 eventHandled = true;
397 397 break;
398 398
399 399 case Qt::Key_Backspace:
400 400
401 401 if (textCursor.hasSelection()) {
402 402
403 403 cut();
404 404 eventHandled = true;
405 405
406 406 } else {
407 407
408 408 // Intercept backspace key event to check if
409 409 // deleting a character is allowed. It is not
410 410 // allowed, if the user wants to delete the
411 411 // command prompt.
412 412
413 413 if (textCursor.position() <= commandPromptPosition()) {
414 414
415 415 QApplication::beep();
416 416 eventHandled = true;
417 417 }
418 418 }
419 419 break;
420 420
421 421 case Qt::Key_Delete:
422 422
423 423 cut();
424 424 eventHandled = true;
425 425 break;
426 426
427 427 default:
428 428
429 429 if (key >= Qt::Key_Space && key <= Qt::Key_division) {
430 430
431 431 if (textCursor.hasSelection() && !verifySelectionBeforeDeletion()) {
432 432
433 433 // The selection must not be deleted.
434 434 eventHandled = true;
435 435
436 436 } else {
437 437
438 438 // The key is an input character, check if the cursor is
439 439 // behind the last command prompt, else inserting the
440 440 // character is not allowed.
441 441
442 442 int commandPromptPosition = this->commandPromptPosition();
443 443 if (textCursor.position() < commandPromptPosition) {
444 444
445 445 textCursor.setPosition(commandPromptPosition);
446 446 setTextCursor(textCursor);
447 447 }
448 448 }
449 449 }
450 450 }
451 451
452 452 if (eventHandled) {
453 453
454 454 _completer->popup()->hide();
455 455 event->accept();
456 456
457 457 } else {
458 458
459 459 QTextEdit::keyPressEvent(event);
460 460 QString text = event->text();
461 461 if (!text.isEmpty()) {
462 462 handleTabCompletion();
463 463 } else {
464 464 _completer->popup()->hide();
465 465 }
466 466 eventHandled = true;
467 467 }
468 468 }
469 469
470 470
471 471
472 472 //-----------------------------------------------------------------------------
473 473
474 474 void PythonQtScriptingConsole::cut() {
475 475
476 476 bool deletionAllowed = verifySelectionBeforeDeletion();
477 477 if (deletionAllowed) {
478 478 QTextEdit::cut();
479 479 }
480 480 }
481 481
482 482
483 483
484 484 //-----------------------------------------------------------------------------
485 485
486 486 bool PythonQtScriptingConsole::verifySelectionBeforeDeletion() {
487 487
488 488 bool deletionAllowed = true;
489 489
490 490
491 491 QTextCursor textCursor = this->textCursor();
492 492
493 493 int commandPromptPosition = this->commandPromptPosition();
494 494 int selectionStart = textCursor.selectionStart();
495 495 int selectionEnd = textCursor.selectionEnd();
496 496
497 497 if (textCursor.hasSelection()) {
498 498
499 499 // Selected text may only be deleted after the last command prompt.
500 500 // If the selection is partly after the command prompt set the selection
501 501 // to the part and deletion is allowed. If the selection occurs before the
502 502 // last command prompt, then deletion is not allowed.
503 503
504 504 if (selectionStart < commandPromptPosition ||
505 505 selectionEnd < commandPromptPosition) {
506 506
507 507 // Assure selectionEnd is bigger than selection start
508 508 if (selectionStart > selectionEnd) {
509 509 int tmp = selectionEnd;
510 510 selectionEnd = selectionStart;
511 511 selectionStart = tmp;
512 512 }
513 513
514 514 if (selectionEnd < commandPromptPosition) {
515 515
516 516 // Selection is completely before command prompt,
517 517 // so deletion is not allowed.
518 518 QApplication::beep();
519 519 deletionAllowed = false;
520 520
521 521 } else {
522 522
523 523 // The selectionEnd is after the command prompt, so set
524 524 // the selection start to the commandPromptPosition.
525 525 selectionStart = commandPromptPosition;
526 526 textCursor.setPosition(selectionStart);
527 527 textCursor.setPosition(selectionStart, QTextCursor::KeepAnchor);
528 528 setTextCursor(textCursor);
529 529 }
530 530 }
531 531
532 532 } else { // if (hasSelectedText())
533 533
534 534 // When there is no selected text, deletion is not allowed before the
535 535 // command prompt.
536 536 if (textCursor.position() < commandPromptPosition) {
537 537
538 538 QApplication::beep();
539 539 deletionAllowed = false;
540 540 }
541 541 }
542 542
543 543 return deletionAllowed;
544 544 }
545 545
546 546
547 547
548 548 //-----------------------------------------------------------------------------
549 549
550 550 void PythonQtScriptingConsole::changeHistory() {
551 551
552 552 // Select the text after the last command prompt ...
553 553 QTextCursor textCursor = this->textCursor();
554 554 textCursor.movePosition(QTextCursor::End);
555 555 textCursor.setPosition(commandPromptPosition(), QTextCursor::KeepAnchor);
556 556
557 557 // ... and replace it with the history text.
558 558 textCursor.insertText(_history.value(_historyPosition));
559 559
560 560 textCursor.movePosition(QTextCursor::End);
561 561 setTextCursor(textCursor);
562 562 }
563 563
564 564
565 565
566 566 //-----------------------------------------------------------------------------
567 567
568 568 void PythonQtScriptingConsole::consoleMessage(const QString & message) {
569 569
570 570 append(QString());
571 571 insertPlainText(message);
572 572
573 573 // Reset all font modifications done by the html string
574 574 setCurrentCharFormat(_defaultTextCharacterFormat);
575 575 }
Show file before | Show file after | Hide comments
@@ -1,149 +1,149
1 1 #ifndef _PythonQtScriptingConsole_H
2 2 #define _PythonQtScriptingConsole_H
3 3
4 4 /*
5 5 *
6 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
6 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
7 7 *
8 8 * This library is free software; you can redistribute it and/or
9 9 * modify it under the terms of the GNU Lesser General Public
10 10 * License as published by the Free Software Foundation; either
11 11 * version 2.1 of the License, or (at your option) any later version.
12 12 *
13 13 * This library is distributed in the hope that it will be useful,
14 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 16 * Lesser General Public License for more details.
17 17 *
18 18 * Further, this software is distributed without any warranty that it is
19 19 * free of the rightful claim of any third person regarding infringement
20 20 * or the like. Any license provided herein, whether implied or
21 21 * otherwise, applies only to this software file. Patent licenses, if
22 22 * any, provided herein do not apply to combinations of this program with
23 23 * other software, or any other product whatsoever.
24 24 *
25 25 * You should have received a copy of the GNU Lesser General Public
26 26 * License along with this library; if not, write to the Free Software
27 27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 28 *
29 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
29 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
30 30 * 28359 Bremen, Germany or:
31 31 *
32 32 * http://www.mevis.de
33 33 *
34 34 */
35 35
36 36 //----------------------------------------------------------------------------------
37 37 /*!
38 38 // \file PythonQtScriptingConsole.h
39 39 // \author Florian Link
40 40 // \author Last changed by $Author: florian $
41 41 // \date 2006-10
42 42 */
43 43 //----------------------------------------------------------------------------------
44 44
45 45 #include "PythonQt.h"
46 46 #include <QVariant>
47 47 #include <QTextEdit>
48 48
49 49 class QCompleter;
50 50
51 51 //-------------------------------------------------------------------------------
52 52 //! A simple console for python scripting
53 53 class PYTHONQT_EXPORT PythonQtScriptingConsole : public QTextEdit
54 54 {
55 55 Q_OBJECT
56 56
57 57 public:
58 58 PythonQtScriptingConsole(QWidget* parent, const PythonQtObjectPtr& context, Qt::WindowFlags i = 0);
59 59
60 60 ~PythonQtScriptingConsole();
61 61
62 62 public slots:
63 63 //! execute current line
64 64 void executeLine(bool storeOnly);
65 65
66 66 //! derived key press event
67 67 void keyPressEvent (QKeyEvent * e);
68 68
69 69 //! output from console
70 70 void consoleMessage(const QString & message);
71 71
72 72 //! get history
73 73 QStringList history() { return _history; }
74 74
75 75 //! set history
76 76 void setHistory(const QStringList& h) { _history = h; _historyPosition = 0; }
77 77
78 78 //! clear the console
79 79 void clear();
80 80
81 81 //! overridden to control which characters a user may delete
82 82 virtual void cut();
83 83
84 84 //! output redirection
85 85 void stdOut(const QString& s);
86 86 //! output redirection
87 87 void stdErr(const QString& s);
88 88
89 89 void insertCompletion(const QString&);
90 90
91 91 //! Appends a newline and command prompt at the end of the document.
92 92 void appendCommandPrompt(bool storeOnly = false);
93 93
94 94 public:
95 95 //! returns true if python cerr had an error
96 96 bool hadError() { return _hadError; }
97 97
98 98 //! returns true if python cerr had an error
99 99 void clearError() {
100 100 _hadError = false;
101 101 }
102 102
103 103 protected:
104 104 //! handle the pressing of tab
105 105 void handleTabCompletion();
106 106
107 107 //! Returns the position of the command prompt
108 108 int commandPromptPosition();
109 109
110 110 //! Returns if deletion is allowed at the current cursor
111 111 //! (with and without selected text)
112 112 bool verifySelectionBeforeDeletion();
113 113
114 114 //! Sets the current font
115 115 void setCurrentFont(const QColor& color = QColor(0,0,0), bool bold = false);
116 116
117 117 //! change the history according to _historyPos
118 118 void changeHistory();
119 119
120 120 //! flush output that was not yet printed
121 121 void flushStdOut();
122 122
123 123
124 124 private:
125 125 void executeCode(const QString& code);
126 126
127 127 PythonQtObjectPtr _context;
128 128
129 129 QStringList _history;
130 130 int _historyPosition;
131 131
132 132 QString _clickedAnchor;
133 133 QString _storageKey;
134 134 QString _commandPrompt;
135 135
136 136 QString _currentMultiLineCode;
137 137
138 138 QString _stdOut;
139 139 QString _stdErr;
140 140
141 141 QTextCharFormat _defaultTextCharacterFormat;
142 142 QCompleter* _completer;
143 143
144 144 bool _hadError;
145 145 };
146 146
147 147
148 148
149 149 #endif No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,68 +1,68
1 1 /*
2 2 *
3 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
3 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
4 4 *
5 5 * This library is free software; you can redistribute it and/or
6 6 * modify it under the terms of the GNU Lesser General Public
7 7 * License as published by the Free Software Foundation; either
8 8 * version 2.1 of the License, or (at your option) any later version.
9 9 *
10 10 * This library is distributed in the hope that it will be useful,
11 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 13 * Lesser General Public License for more details.
14 14 *
15 15 * Further, this software is distributed without any warranty that it is
16 16 * free of the rightful claim of any third person regarding infringement
17 17 * or the like. Any license provided herein, whether implied or
18 18 * otherwise, applies only to this software file. Patent licenses, if
19 19 * any, provided herein do not apply to combinations of this program with
20 20 * other software, or any other product whatsoever.
21 21 *
22 22 * You should have received a copy of the GNU Lesser General Public
23 23 * License along with this library; if not, write to the Free Software
24 24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 25 *
26 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
26 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
27 27 * 28359 Bremen, Germany or:
28 28 *
29 29 * http://www.mevis.de
30 30 *
31 31 */
32 32
33 33 //----------------------------------------------------------------------------------
34 34 /*!
35 35 // \file PythonQtTests.cpp
36 36 // \author Florian Link
37 37 // \author Last changed by $Author: florian $
38 38 // \date 2006-05
39 39 */
40 40 //----------------------------------------------------------------------------------
41 41
42 42 #include "PythonQt.h"
43 43 #include "PythonQtTests.h"
44 44
45 45 int main( int argc, char **argv )
46 46 {
47 47 QApplication qapp(argc, argv);
48 48
49 49 PythonQt::init(PythonQt::IgnoreSiteModule | PythonQt::RedirectStdOut);
50 50
51 51 int failCount = 0;
52 52 PythonQtTestApi api;
53 53 failCount += QTest::qExec(&api, argc, argv);
54 54 PythonQtTestSignalHandler signalHandler;
55 55 failCount += QTest::qExec(&signalHandler, argc, argv);
56 56 PythonQtTestSlotCalling slotCalling;
57 57 failCount += QTest::qExec(&slotCalling, argc, argv);
58 58
59 59 PythonQt::cleanup();
60 60
61 61 if (failCount>0) {
62 62 std::cerr << "Tests failed: " << failCount << std::endl;
63 63 } else {
64 64 std::cout << "All tests passed successfully." << std::endl;
65 65 }
66 66 return failCount;
67 67 }
68 68
Show file before | Show file after | Hide comments
@@ -1,585 +1,585
1 1 /*
2 2 *
3 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
3 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
4 4 *
5 5 * This library is free software; you can redistribute it and/or
6 6 * modify it under the terms of the GNU Lesser General Public
7 7 * License as published by the Free Software Foundation; either
8 8 * version 2.1 of the License, or (at your option) any later version.
9 9 *
10 10 * This library is distributed in the hope that it will be useful,
11 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 13 * Lesser General Public License for more details.
14 14 *
15 15 * Further, this software is distributed without any warranty that it is
16 16 * free of the rightful claim of any third person regarding infringement
17 17 * or the like. Any license provided herein, whether implied or
18 18 * otherwise, applies only to this software file. Patent licenses, if
19 19 * any, provided herein do not apply to combinations of this program with
20 20 * other software, or any other product whatsoever.
21 21 *
22 22 * You should have received a copy of the GNU Lesser General Public
23 23 * License along with this library; if not, write to the Free Software
24 24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 25 *
26 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
26 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
27 27 * 28359 Bremen, Germany or:
28 28 *
29 29 * http://www.mevis.de
30 30 *
31 31 */
32 32
33 33 //----------------------------------------------------------------------------------
34 34 /*!
35 35 // \file PythonQtTests.cpp
36 36 // \author Florian Link
37 37 // \author Last changed by $Author: florian $
38 38 // \date 2006-05
39 39 */
40 40 //----------------------------------------------------------------------------------
41 41
42 42 #include "PythonQtTests.h"
43 43
44 44 void PythonQtTestSlotCalling::initTestCase()
45 45 {
46 46 _helper = new PythonQtTestSlotCallingHelper(this);
47 47 PythonQtObjectPtr main = PythonQt::self()->getMainModule();
48 48 main.evalScript("import PythonQt");
49 49 PythonQt::self()->addObject(main, "obj", _helper);
50 50 }
51 51
52 52 void PythonQtTestSlotCalling::init() {
53 53
54 54 }
55 55
56 56
57 57 void* polymorphic_ClassB_Handler(const void* ptr, char** className) {
58 58 ClassB* o = (ClassB*)ptr;
59 59 if (o->type()==2) {
60 60 *className = "ClassB";
61 61 return (ClassB*)o;
62 62 }
63 63 if (o->type()==3) {
64 64 *className = "ClassC";
65 65 return (ClassC*)o;
66 66 }
67 67 if (o->type()==4) {
68 68 *className = "ClassD";
69 69 return (ClassD*)o;
70 70 }
71 71 return NULL;
72 72 }
73 73
74 74 void PythonQtTestSlotCalling::testInheritance() {
75 75 PythonQt::self()->registerCPPClass("ClassA",NULL,NULL, PythonQtCreateObject<ClassAWrapper>);
76 76 PythonQt::self()->registerCPPClass("ClassB",NULL,NULL, PythonQtCreateObject<ClassBWrapper>);
77 77 PythonQt::self()->registerCPPClass("ClassC",NULL,NULL, PythonQtCreateObject<ClassCWrapper>);
78 78 PythonQt::self()->addParentClass("ClassC", "ClassA", PythonQtUpcastingOffset<ClassC,ClassA>());
79 79 PythonQt::self()->addParentClass("ClassC", "ClassB", PythonQtUpcastingOffset<ClassC,ClassB>());
80 80 PythonQt::self()->registerClass(&ClassD::staticMetaObject, NULL, PythonQtCreateObject<ClassDWrapper>);
81 81 PythonQt::self()->addParentClass("ClassD", "ClassA", PythonQtUpcastingOffset<ClassD,ClassA>());
82 82 PythonQt::self()->addParentClass("ClassD", "ClassB", PythonQtUpcastingOffset<ClassD,ClassB>());
83 83
84 84 PythonQtObjectPtr classA = PythonQt::self()->getMainModule().getVariable("PythonQt.private.ClassA");
85 85 PythonQtObjectPtr classB = PythonQt::self()->getMainModule().getVariable("PythonQt.private.ClassB");
86 86 PythonQtObjectPtr classC = PythonQt::self()->getMainModule().getVariable("PythonQt.private.ClassC");
87 87 PythonQtObjectPtr classD = PythonQt::self()->getMainModule().getVariable("PythonQt.private.ClassD");
88 88 QVERIFY(classA);
89 89 QVERIFY(classB);
90 90 QVERIFY(classC);
91 91 QVERIFY(classD);
92 92
93 93 QVERIFY(_helper->runScript("a = PythonQt.private.ClassA();\nif obj.getClassAPtr(a).getX()==1: obj.setPassed();\n"));
94 94 QEXPECT_FAIL("", "ClassB can not be converted to ClassA", Continue);
95 95 QVERIFY(_helper->runScript("a = PythonQt.private.ClassB();\nif obj.getClassAPtr(a).getX()==1: obj.setPassed();\n"));
96 96 QVERIFY(_helper->runScript("a = PythonQt.private.ClassC();\nif obj.getClassAPtr(a).getX()==1: obj.setPassed();\n"));
97 97 QVERIFY(_helper->runScript("a = PythonQt.private.ClassD();\nif obj.getClassAPtr(a).getX()==1: obj.setPassed();\n"));
98 98
99 99 QEXPECT_FAIL("", "ClassA can not be converted to ClassB", Continue);
100 100 QVERIFY(_helper->runScript("a = PythonQt.private.ClassA();\nif obj.getClassBPtr(a).getY()==2: obj.setPassed();\n"));
101 101 QVERIFY(_helper->runScript("a = PythonQt.private.ClassB();\nif obj.getClassBPtr(a).getY()==2: obj.setPassed();\n"));
102 102 QVERIFY(_helper->runScript("a = PythonQt.private.ClassC();\nif obj.getClassBPtr(a).getY()==2: obj.setPassed();\n"));
103 103 QVERIFY(_helper->runScript("a = PythonQt.private.ClassD();\nif obj.getClassBPtr(a).getY()==2: obj.setPassed();\n"));
104 104
105 105 QEXPECT_FAIL("", "ClassA can not be converted to ClassC", Continue);
106 106 QVERIFY(_helper->runScript("a = PythonQt.private.ClassA();\nif obj.getClassCPtr(a).getX()==1: obj.setPassed();\n"));
107 107 QEXPECT_FAIL("", "ClassB can not be converted to ClassC", Continue);
108 108 QVERIFY(_helper->runScript("a = PythonQt.private.ClassB();\nif obj.getClassCPtr(a).getX()==1: obj.setPassed();\n"));
109 109 QVERIFY(_helper->runScript("a = PythonQt.private.ClassC();\nif obj.getClassCPtr(a).getX()==1: obj.setPassed();\n"));
110 110 QEXPECT_FAIL("", "ClassD can not be converted to ClassC", Continue);
111 111 QVERIFY(_helper->runScript("a = PythonQt.private.ClassD();\nif obj.getClassCPtr(a).getX()==1: obj.setPassed();\n"));
112 112
113 113 QVERIFY(_helper->runScript("if type(obj.createClassA())==PythonQt.private.ClassA: obj.setPassed();\n"));
114 114 QVERIFY(_helper->runScript("if type(obj.createClassB())==PythonQt.private.ClassB: obj.setPassed();\n"));
115 115 QVERIFY(_helper->runScript("if type(obj.createClassCAsA())==PythonQt.private.ClassA: obj.setPassed();\n"));
116 116 QVERIFY(_helper->runScript("if type(obj.createClassCAsB())==PythonQt.private.ClassB: obj.setPassed();\n"));
117 117 QVERIFY(_helper->runScript("if type(obj.createClassD())==PythonQt.private.ClassD: obj.setPassed();\n"));
118 118 QVERIFY(_helper->runScript("if type(obj.createClassDAsA())==PythonQt.private.ClassA: obj.setPassed();\n"));
119 119 QVERIFY(_helper->runScript("if type(obj.createClassDAsB())==PythonQt.private.ClassB: obj.setPassed();\n"));
120 120
121 121 PythonQt::self()->addPolymorphicHandler("ClassB", polymorphic_ClassB_Handler);
122 122
123 123 QVERIFY(_helper->runScript("if type(obj.getClassBPtr(obj.createClassB()))==PythonQt.private.ClassB: obj.setPassed();\n"));
124 124 QVERIFY(_helper->runScript("if type(obj.createClassCAsB())==PythonQt.private.ClassC: obj.setPassed();\n"));
125 125 QVERIFY(_helper->runScript("if type(obj.createClassDAsB())==PythonQt.private.ClassD: obj.setPassed();\n"));
126 126
127 127 }
128 128
129 129 void PythonQtTestSlotCalling::testAutoConversion() {
130 130 QVERIFY(_helper->runScript("if obj.setAutoConvertColor(PythonQt.QtCore.Qt.red)==PythonQt.Qt.QColor(PythonQt.QtCore.Qt.red): obj.setPassed();\n"));
131 131 QVERIFY(_helper->runScript("if obj.setAutoConvertBrush(PythonQt.QtCore.Qt.red)==PythonQt.Qt.QBrush(PythonQt.QtCore.Qt.red): obj.setPassed();\n"));
132 132 QVERIFY(_helper->runScript("if obj.setAutoConvertPen(PythonQt.QtCore.Qt.red)==PythonQt.Qt.QPen(PythonQt.QtCore.Qt.red): obj.setPassed();\n"));
133 133 QVERIFY(_helper->runScript("if obj.setAutoConvertBrush(PythonQt.Qt.QColor(PythonQt.QtCore.Qt.red))==PythonQt.Qt.QBrush(PythonQt.QtCore.Qt.red): obj.setPassed();\n"));
134 134 QVERIFY(_helper->runScript("if obj.setAutoConvertPen(PythonQt.Qt.QColor(PythonQt.QtCore.Qt.red))==PythonQt.Qt.QPen(PythonQt.QtCore.Qt.red): obj.setPassed();\n"));
135 135 QVERIFY(_helper->runScript("if obj.setAutoConvertCursor(PythonQt.Qt.QCursor(PythonQt.QtCore.Qt.UpArrowCursor)).shape()==PythonQt.Qt.QCursor(PythonQt.QtCore.Qt.UpArrowCursor).shape(): obj.setPassed();\n"));
136 136 QVERIFY(_helper->runScript("if obj.setAutoConvertCursor(PythonQt.QtCore.Qt.UpArrowCursor).shape()==PythonQt.Qt.QCursor(PythonQt.QtCore.Qt.UpArrowCursor).shape(): obj.setPassed();\n"));
137 137 }
138 138
139 139 void PythonQtTestSlotCalling::testNoArgSlotCall()
140 140 {
141 141 QVERIFY(_helper->runScript("obj.testNoArg(); obj.setPassed();\n"));
142 142 }
143 143
144 144 void PythonQtTestSlotCalling::testOverloadedCall()
145 145 {
146 146 QVERIFY(_helper->runScript("obj.overload(False); obj.setPassed();\n", 0));
147 147 QVERIFY(_helper->runScript("obj.overload(True); obj.setPassed();\n", 0));
148 148 QVERIFY(_helper->runScript("obj.overload(12.5); obj.setPassed();\n", 1));
149 149 QVERIFY(_helper->runScript("obj.overload(12); obj.setPassed();\n", 2));
150 150 QVERIFY(_helper->runScript("obj.overload('test'); obj.setPassed();\n", 3));
151 151 QVERIFY(_helper->runScript("obj.overload(u'test'); obj.setPassed();\n", 3));
152 152 QVERIFY(_helper->runScript("obj.overload(('test','test2')); obj.setPassed();\n", 4));
153 153 QVERIFY(_helper->runScript("obj.overload(obj); obj.setPassed();\n", 5));
154 154 QVERIFY(_helper->runScript("obj.overload(12,13); obj.setPassed();\n", 6));
155 155 }
156 156
157 157 void PythonQtTestSlotCalling::testPyObjectSlotCall()
158 158 {
159 159 QVERIFY(_helper->runScript("if obj.getPyObject(PythonQt)==PythonQt: obj.setPassed();\n"));
160 160 QVERIFY(_helper->runScript("if obj.getPyObject('Hello')=='Hello': obj.setPassed();\n"));
161 161 QVERIFY(_helper->runScript("if obj.getPyObjectFromVariant(PythonQt)==PythonQt: obj.setPassed();\n"));
162 162 QVERIFY(_helper->runScript("if obj.getPyObjectFromVariant2(PythonQt)==PythonQt: obj.setPassed();\n"));
163 163 // QVERIFY(_helper->runScript("if obj.getPyObjectFromPtr(PythonQt)==PythonQt: obj.setPassed();\n"));
164 164 }
165 165
166 166 void PythonQtTestSlotCalling::testCPPSlotCalls()
167 167 {
168 168 // test QColor compare operation
169 169 QVERIFY(_helper->runScript("if PythonQt.QtGui.QColor(1,2,3)==PythonQt.QtGui.QColor(1,2,3): obj.setPassed();obj.testNoArg()\n"));
170 170 QVERIFY(_helper->runScript("if PythonQt.QtGui.QColor(1,2,3)!=PythonQt.QtGui.QColor(3,2,1): obj.setPassed();obj.testNoArg()\n"));
171 171
172 172 // test passing/returning QColors
173 173 QVERIFY(_helper->runScript("if obj.getQColor1(PythonQt.QtGui.QColor(1,2,3))==PythonQt.QtGui.QColor(1,2,3): obj.setPassed();\n"));
174 174 QVERIFY(_helper->runScript("if obj.getQColor2(PythonQt.QtGui.QColor(1,2,3))==PythonQt.QtGui.QColor(1,2,3): obj.setPassed();\n"));
175 175 QVERIFY(_helper->runScript("if obj.getQColor3(PythonQt.QtGui.QColor(1,2,3))==PythonQt.QtGui.QColor(1,2,3): obj.setPassed();\n"));
176 176 QVERIFY(_helper->runScript("if obj.getQColor4(PythonQt.QtGui.QColor(1,2,3))==PythonQt.QtGui.QColor(1,2,3): obj.setPassed();\n"));
177 177 QVERIFY(_helper->runScript("if obj.getQColor5()==PythonQt.QtGui.QColor(1,2,3): obj.setPassed();\n"));
178 178 }
179 179
180 180 void PythonQtTestSlotCalling::testPODSlotCalls()
181 181 {
182 182 QVERIFY(_helper->runScript("if obj.getBool(False)==False: obj.setPassed();\n"));
183 183 QVERIFY(_helper->runScript("if obj.getBool(True)==True: obj.setPassed();\n"));
184 184 QVERIFY(_helper->runScript("if obj.getInt(-42)==-42: obj.setPassed();\n"));
185 185 QVERIFY(_helper->runScript("if obj.getUInt(42)==42: obj.setPassed();\n"));
186 186 QVERIFY(_helper->runScript("if obj.getShort(-43)==-43: obj.setPassed();\n"));
187 187 QVERIFY(_helper->runScript("if obj.getUShort(43)==43: obj.setPassed();\n"));
188 188 QVERIFY(_helper->runScript("if obj.getChar(-12)==-12: obj.setPassed();\n"));
189 189 QVERIFY(_helper->runScript("if obj.getUChar(12)==12: obj.setPassed();\n"));
190 190 QVERIFY(_helper->runScript("if obj.getLong(-256*256*256)==-256*256*256: obj.setPassed();\n"));
191 191 QVERIFY(_helper->runScript("if obj.getULong(256*256*256)==256*256*256: obj.setPassed();\n"));
192 192 QVERIFY(_helper->runScript("if obj.getLongLong(-42)==-42: obj.setPassed();\n"));
193 193 QVERIFY(_helper->runScript("if obj.getULongLong(42)==42: obj.setPassed();\n"));
194 194 QVERIFY(_helper->runScript("if obj.getQChar(4096)==4096: obj.setPassed();\n"));
195 195 QVERIFY(_helper->runScript("if obj.getDouble(47.12)==47.12: obj.setPassed();\n"));
196 196 QVERIFY(_helper->runScript("if abs(obj.getFloat(47.11)-47.11)<0.01: obj.setPassed();\n"));
197 197 QVERIFY(_helper->runScript("if obj.getQString('testStr')=='testStr': obj.setPassed();\n"));
198 198 QVERIFY(_helper->runScript("if obj.getQString('')=='': obj.setPassed();\n"));
199 199 QVERIFY(_helper->runScript("if obj.getQStringList(('test','test2'))==('test','test2'): obj.setPassed();\n"));
200 200 }
201 201
202 202 void PythonQtTestSlotCalling::testQVariantSlotCalls()
203 203 {
204 204 QVERIFY(_helper->runScript("if obj.getQVariant(-42)==-42: obj.setPassed();\n"));
205 205 QVERIFY(_helper->runScript("if obj.getQVariant('testStr')=='testStr': obj.setPassed();\n"));
206 206 QVERIFY(_helper->runScript("if obj.getQVariant(('test','test2'))==('test','test2'): obj.setPassed();\n"));
207 207 QVERIFY(_helper->runScript("if obj.getQVariant(('test',12, 47.11))==('test',12, 47.11): obj.setPassed();\n"));
208 208 QVERIFY(_helper->runScript("if obj.getQVariant({'test':'bla','test2':47.11})=={'test':'bla','test2':47.11}: obj.setPassed();\n"));
209 209 QEXPECT_FAIL("", "Testing to pass a map and compare with a different map", Continue);
210 210 QVERIFY(_helper->runScript("if obj.getQVariant({'test':'bla2','test2':47.11})=={'test':'bla','test2':47.11}: obj.setPassed();\n"));
211 211 QVERIFY(_helper->runScript("if obj.getQVariant(obj)==obj: obj.setPassed();\n"));
212 212 }
213 213
214 214 void PythonQtTestSlotCalling::testObjectSlotCalls()
215 215 {
216 216 QVERIFY(_helper->runScript("if obj.getQObject(obj)==obj: obj.setPassed();\n"));
217 217 QVERIFY(_helper->runScript("if obj.getTestObject(obj)==obj: obj.setPassed();\n"));
218 218 QVERIFY(_helper->runScript("if obj.getNewObject().className()=='PythonQtTestSlotCallingHelper': obj.setPassed();\n"));
219 219 QEXPECT_FAIL("", "Testing to pass a QObject when another object was expected", Continue);
220 220 QVERIFY(_helper->runScript("if obj.getQWidget(obj)==obj: obj.setPassed();\n"));
221 221 }
222 222
223 223 void PythonQtTestSlotCalling::testCppFactory()
224 224 {
225 225 PythonQtTestCppFactory* f = new PythonQtTestCppFactory;
226 226 PythonQt::self()->addInstanceDecorators(new PQCppObjectDecorator);
227 227 // do not register, since we want to know if that works as well
228 228 //qRegisterMetaType<PQCppObjectNoWrap>("PQCppObjectNoWrap");
229 229 PythonQt::self()->addDecorators(new PQCppObjectNoWrapDecorator);
230 230
231 231 PythonQt::self()->addWrapperFactory(f);
232 232 QVERIFY(_helper->runScript("if obj.createPQCppObject(12).getHeight()==12: obj.setPassed();\n"));
233 233 QVERIFY(_helper->runScript("if obj.createPQCppObject(12).getH()==12: obj.setPassed();\n"));
234 234 QVERIFY(_helper->runScript("pq1 = obj.createPQCppObject(12);\n"
235 235 "pq2 = obj.createPQCppObject(13);\n"
236 236 "pq3 = obj.getPQCppObject(pq1);\n"
237 237 "pq4 = obj.getPQCppObject(pq2);\n"
238 238 "if pq3.getHeight()==12 and pq4.getHeight()==13: obj.setPassed();\n"
239 239 ));
240 240
241 241 QVERIFY(_helper->runScript("if obj.createPQCppObjectNoWrap(12).getH()==12: obj.setPassed();\n"));
242 242
243 243 QVERIFY(_helper->runScript("if obj.getPQCppObjectNoWrapAsValue().getH()==47: obj.setPassed();\n"));
244 244
245 245 qRegisterMetaType<PQUnknownButRegisteredValueObject>("PQUnknownButRegisteredValueObject");
246 246 QVERIFY(_helper->runScript("a = obj.getUnknownButRegisteredValueObjectAsPtr();print a;\nif a!=None: obj.setPassed();\n"));
247 247 QVERIFY(_helper->runScript("a = obj.getUnknownButRegisteredValueObjectAsValue();print a;\nif a!=None: obj.setPassed();\n"));
248 248 QVERIFY(_helper->runScript("a = obj.getUnknownValueObjectAsPtr();print a;\nif a!=None: obj.setPassed();\n"));
249 249 QEXPECT_FAIL("", "Testing by value return without the object being registered as QMetaType or having registered a default constructor decorator", Continue);
250 250 QVERIFY(_helper->runScript("a = obj.getUnknownValueObjectAsValue();print a;\nif a!=None: obj.setPassed();\n"));
251 251
252 252 // expect to get strict call to double overload
253 253 QVERIFY(_helper->runScript("obj.testNoArg()\nfrom PythonQt.private import PQCppObjectNoWrap\na = PQCppObjectNoWrap(22.2)\nif a.getH()==2: obj.setPassed();\n"));
254 254 // expect to get un-strict call to double overload
255 255 QVERIFY(_helper->runScript("obj.testNoArg()\nfrom PythonQt.private import PQCppObjectNoWrap\na = PQCppObjectNoWrap(22)\nif a.getH()==2: obj.setPassed();\n"));
256 256 // expect to get strict call to copy constructor overload
257 257 QVERIFY(_helper->runScript("obj.testNoArg()\nfrom PythonQt.private import PQCppObjectNoWrap\na = PQCppObjectNoWrap(PQCppObjectNoWrap())\nprint a.getH()\nif a.getH()==1: obj.setPassed();\n"));
258 258
259 259 // test decorated enums
260 260 // already registered by signals test
261 261 //PythonQt::self()->registerCPPClass("PQCppObject2",NULL,NULL, PythonQtCreateObject<PQCppObject2Decorator>);
262 262
263 263 // local enum (decorated)
264 264 QVERIFY(_helper->runScript("obj.testNoArg()\nfrom PythonQt.private import PQCppObject2\na = PQCppObject2()\nprint a.testEnumFlag1\nif a.testEnumFlag1(PQCppObject2.TestEnumValue2)==PQCppObject2.TestEnumValue2: obj.setPassed();\n"));
265 265 // enum with namespace (decorated)
266 266 QVERIFY(_helper->runScript("obj.testNoArg()\nfrom PythonQt.private import PQCppObject2\na = PQCppObject2()\nif a.testEnumFlag2(PQCppObject2.TestEnumValue2)==PQCppObject2.TestEnumValue2: obj.setPassed();\n"));
267 267 // with int overload to check overloading
268 268 QVERIFY(_helper->runScript("obj.testNoArg()\nfrom PythonQt.private import PQCppObject2\na = PQCppObject2()\nif a.testEnumFlag3(PQCppObject2.TestEnumValue2)==PQCppObject2.TestEnumValue2: obj.setPassed();\n"));
269 269
270 270 }
271 271
272 272 PQCppObject2Decorator::TestEnumFlag PQCppObject2Decorator::testEnumFlag1(PQCppObject2* obj, PQCppObject2Decorator::TestEnumFlag flag) {
273 273 return flag;
274 274 }
275 275
276 276 PQCppObject2::TestEnumFlag PQCppObject2Decorator::testEnumFlag2(PQCppObject2* obj, PQCppObject2::TestEnumFlag flag) {
277 277 return flag;
278 278 }
279 279
280 280 // with int overload
281 281 PQCppObject2Decorator::TestEnumFlag PQCppObject2Decorator::testEnumFlag3(PQCppObject2* obj, int flag) {
282 282 return (TestEnumFlag)-1;
283 283 }
284 284 PQCppObject2Decorator::TestEnumFlag PQCppObject2Decorator::testEnumFlag3(PQCppObject2* obj, PQCppObject2Decorator::TestEnumFlag flag) {
285 285 return flag;
286 286 }
287 287
288 288 void PythonQtTestSlotCalling::testMultiArgsSlotCall()
289 289 {
290 290 QVERIFY(_helper->runScript("if obj.getMultiArgs(12,47.11,'test')==(12,47.11,'test'): obj.setPassed();\n"));
291 291 }
292 292
293 293 bool PythonQtTestSlotCallingHelper::runScript(const char* script, int expectedOverload)
294 294 {
295 295 _called = false;
296 296 _passed = false;
297 297 _calledOverload = -1;
298 298 PyRun_SimpleString(script);
299 299 return _called && _passed && _calledOverload==expectedOverload;
300 300 }
301 301
302 302
303 303 void PythonQtTestSignalHandler::initTestCase()
304 304 {
305 305 _helper = new PythonQtTestSignalHandlerHelper(this);
306 306 PythonQtObjectPtr main = PythonQt::self()->getMainModule();
307 307 PythonQt::self()->addObject(main, "obj", _helper);
308 308 }
309 309
310 310 void PythonQtTestSignalHandler::testSignalHandler()
311 311 {
312 312 PythonQtObjectPtr main = PythonQt::self()->getMainModule();
313 313 PyRun_SimpleString("def testIntSignal(a):\n if a==12: obj.setPassed();\n");
314 314 QVERIFY(PythonQt::self()->addSignalHandler(_helper, SIGNAL(intSignal(int)), main, "testIntSignal"));
315 315 QVERIFY(_helper->emitIntSignal(12));
316 316
317 317 PyRun_SimpleString("def testFloatSignal(a):\n if a==12: obj.setPassed();\n");
318 318 QVERIFY(PythonQt::self()->addSignalHandler(_helper, SIGNAL(floatSignal(float)), main, "testFloatSignal"));
319 319 QVERIFY(_helper->emitFloatSignal(12));
320 320
321 321 // test decorated enums
322 322 PythonQt::self()->registerCPPClass("PQCppObject2",NULL,NULL, PythonQtCreateObject<PQCppObject2Decorator>);
323 323
324 324 PyRun_SimpleString("def testEnumSignal(a):\n if a==1: obj.setPassed();\n");
325 325 QVERIFY(PythonQt::self()->addSignalHandler(_helper, SIGNAL(enumSignal(PQCppObject2::TestEnumFlag)), main, "testEnumSignal"));
326 326 QVERIFY(_helper->emitEnumSignal(PQCppObject2::TestEnumValue2));
327 327
328 328 PyRun_SimpleString("def testVariantSignal(a):\n if a==obj.expectedVariant(): obj.setPassed();\n");
329 329 QVERIFY(PythonQt::self()->addSignalHandler(_helper, SIGNAL(variantSignal(QVariant)), main, "testVariantSignal"));
330 330 _helper->setExpectedVariant(QString("Test"));
331 331 QVERIFY(_helper->emitVariantSignal(QString("Test")));
332 332 _helper->setExpectedVariant(12);
333 333 QVERIFY(_helper->emitVariantSignal(12));
334 334 _helper->setExpectedVariant(QStringList() << "test1" << "test2");
335 335 QVERIFY(_helper->emitVariantSignal(QStringList() << "test1" << "test2"));
336 336 _helper->setExpectedVariant(qVariantFromValue((QObject*)_helper));
337 337 QVERIFY(_helper->emitVariantSignal(qVariantFromValue((QObject*)_helper)));
338 338
339 339 PyRun_SimpleString("def testComplexSignal(a,b,l,o):\n if a==12 and b==13 and l==('test1','test2') and o == obj: obj.setPassed();\n");
340 340 // intentionally not normalized signal:
341 341 QVERIFY(PythonQt::self()->addSignalHandler(_helper, SIGNAL(complexSignal( int, float , const QStringList , QObject*)), main, "testComplexSignal"));
342 342 QVERIFY(_helper->emitComplexSignal(12,13,QStringList() << "test1" << "test2", _helper));
343 343
344 344 // try removing the handler
345 345 QVERIFY(PythonQt::self()->removeSignalHandler(_helper, SIGNAL(complexSignal( int, float , const QStringList , QObject*)), main, "testComplexSignal"));
346 346 // and emit the signal, which should fail because the handler was removed
347 347 QVERIFY(!_helper->emitComplexSignal(12,13,QStringList() << "test1" << "test2", _helper));
348 348
349 349 QVERIFY(PythonQt::self()->removeSignalHandler(_helper, SIGNAL(intSignal(int)), main, "testIntSignal"));
350 350 QVERIFY(PythonQt::self()->removeSignalHandler(_helper, SIGNAL(floatSignal(float)), main, "testFloatSignal"));
351 351 QVERIFY(PythonQt::self()->removeSignalHandler(_helper, SIGNAL(variantSignal(QVariant)), main, "testVariantSignal"));
352 352 QVERIFY(PythonQt::self()->removeSignalHandler(_helper, SIGNAL(enumSignal(PQCppObject2::TestEnumFlag)), main, "testEnumSignal"));
353 353
354 354 }
355 355
356 356 void PythonQtTestSignalHandler::testRecursiveSignalHandler()
357 357 {
358 358 PythonQtObjectPtr main = PythonQt::self()->getMainModule();
359 359 PyRun_SimpleString("def testSignal1(a):\n obj.emitSignal2(a);\n");
360 360 PyRun_SimpleString("def testSignal2(a):\n obj.emitSignal3(float(a));\n");
361 361 PyRun_SimpleString("def testSignal3(a):\n if a==12: obj.setPassed();\n");
362 362 QVERIFY(PythonQt::self()->addSignalHandler(_helper, SIGNAL(signal1(int)), main, "testSignal1"));
363 363 QVERIFY(PythonQt::self()->addSignalHandler(_helper, SIGNAL(signal2(const QString&)), main, "testSignal2"));
364 364 QVERIFY(PythonQt::self()->addSignalHandler(_helper, SIGNAL(signal3(float)), main, "testSignal3"));
365 365 QVERIFY(_helper->emitSignal1(12));
366 366 }
367 367
368 368
369 369 void PythonQtTestApi::initTestCase()
370 370 {
371 371 _helper = new PythonQtTestApiHelper();
372 372 _main = PythonQt::self()->getMainModule();
373 373 _main.evalScript("import PythonQt");
374 374 _main.addObject("obj", _helper);
375 375 }
376 376
377 377 void PythonQtTestApi::testProperties()
378 378 {
379 379 PythonQtObjectPtr main = PythonQt::self()->getMainModule();
380 380 // check for name alias (for backward comp to Qt3)
381 381 main.evalScript("obj.name = 'hello'");
382 382 QVERIFY(QString("hello") == main.getVariable("obj.name").toString());
383 383
384 384 main.evalScript("obj.objectName = 'hello2'");
385 385 QVERIFY(QString("hello2") == main.getVariable("obj.objectName").toString());
386 386
387 387 }
388 388
389 389 void PythonQtTestApi::testDynamicProperties()
390 390 {
391 391 PythonQtObjectPtr main = PythonQt::self()->getMainModule();
392 392
393 393 // this fails and should fail, but how could that be tested?
394 394 // main.evalScript("obj.testProp = 1");
395 395
396 396 // create a new dynamic property
397 397 main.evalScript("obj.setProperty('testProp','testValue')");
398 398
399 399 // read the property
400 400 QVERIFY(QString("testValue") == main.getVariable("obj.testProp").toString());
401 401 // modify and read again
402 402 main.evalScript("obj.testProp = 12");
403 403 QVERIFY(12 == main.getVariable("obj.testProp").toInt());
404 404
405 405 // check if dynamic property is in dict
406 406 QVERIFY(12 == main.evalScript("obj.__dict__['testProp']", Py_eval_input).toInt());
407 407
408 408 // check if dynamic property is in introspection
409 409 QStringList l = PythonQt::self()->introspection(PythonQt::self()->getMainModule(), "obj", PythonQt::Anything);
410 410 QVERIFY(l.contains("testProp"));
411 411
412 412 // check with None, previous value expected
413 413 main.evalScript("obj.testProp = None");
414 414 QVERIFY(12 == main.getVariable("obj.testProp").toInt());
415 415
416 416 // remove the dynamic property
417 417 main.evalScript("obj.setProperty('testProp', None)");
418 418
419 419 // check if dynamic property is really gone
420 420 QStringList l2 = PythonQt::self()->introspection(PythonQt::self()->getMainModule(), "obj", PythonQt::Anything);
421 421 QVERIFY(!l2.contains("testProp"));
422 422
423 423 }
424 424
425 425
426 426 bool PythonQtTestApiHelper::call(const QString& function, const QVariantList& args, const QVariant& expectedResult) {
427 427 _passed = false;
428 428 QVariant r = PythonQt::self()->call(PythonQt::self()->getMainModule(), function, args);
429 429 return _passed && expectedResult==r;
430 430 }
431 431
432 432 void PythonQtTestApi::testCall()
433 433 {
434 434 PythonQtObjectPtr main = PythonQt::self()->getMainModule();
435 435
436 436 QVERIFY(qVariantValue<QObject*>(PythonQt::self()->getVariable(main, "obj"))==_helper);
437 437
438 438 PyRun_SimpleString("def testCallNoArgs():\n obj.setPassed();\n");
439 439 QVERIFY(_helper->call("testCallNoArgs", QVariantList(), QVariant()));
440 440
441 441 PyRun_SimpleString("def testCall1(a):\n if a=='test': obj.setPassed();\n return 'test2';\n");
442 442 QVERIFY(_helper->call("testCall1", QVariantList() << QVariant("test"), QVariant(QString("test2"))));
443 443
444 444 PyRun_SimpleString("def testCall2(a, b):\n if a=='test' and b==obj: obj.setPassed();\n return obj;\n");
445 445 QVariant r = PythonQt::self()->call(PythonQt::self()->getMainModule(), "testCall2", QVariantList() << QVariant("test") << qVariantFromValue((QObject*)_helper));
446 446 QObject* p = qVariantValue<QObject*>(r);
447 447 QVERIFY(p==_helper);
448 448 }
449 449
450 450 void PythonQtTestApi::testVariables()
451 451 {
452 452 PythonQt::self()->addObject(PythonQt::self()->getMainModule(), "someObject", _helper);
453 453 QVariant v = PythonQt::self()->getVariable(PythonQt::self()->getMainModule(), "someObject");
454 454 QObject* p = qVariantValue<QObject*>(v);
455 455 QVERIFY(p==_helper);
456 456 // test for unset variable
457 457 QVariant v2 = PythonQt::self()->getVariable(PythonQt::self()->getMainModule(), "someObject2");
458 458 QVERIFY(v2==QVariant());
459 459
460 460 PythonQt::self()->addVariable(PythonQt::self()->getMainModule(), "someValue", QStringList() << "test1" << "test2");
461 461 QVariant v3 = PythonQt::self()->getVariable(PythonQt::self()->getMainModule(), "someValue");
462 462 QVERIFY(v3 == QVariant(QStringList() << "test1" << "test2"));
463 463
464 464 QStringList l = PythonQt::self()->introspection(PythonQt::self()->getMainModule(), QString::null, PythonQt::Variable);
465 465 QSet<QString> s;
466 466 // check that at least these three variables are set
467 467 s << "obj" << "someObject" << "someValue";
468 468 foreach (QString value, s) {
469 469 QVERIFY(l.indexOf(value)!=-1);
470 470 }
471 471
472 472 // insert a second time!
473 473 PythonQt::self()->addObject(PythonQt::self()->getMainModule(), "someObject", _helper);
474 474 // and remove
475 475 PythonQt::self()->removeVariable(PythonQt::self()->getMainModule(), "someObject");
476 476 // we expect to find no variable
477 477 QVariant v4 = PythonQt::self()->getVariable(PythonQt::self()->getMainModule(), "someObject");
478 478 QVERIFY(v4==QVariant());
479 479 }
480 480
481 481 void PythonQtTestApi::testImporter()
482 482 {
483 483 PythonQt::self()->setImporter(_helper);
484 484 PythonQt::self()->overwriteSysPath(QStringList() << "c:\\test");
485 485 PyRun_SimpleString("import bla\n");
486 486 }
487 487
488 488 void PythonQtTestApi::testQtNamespace()
489 489 {
490 490 QVERIFY(_main.getVariable("PythonQt.QtCore.Qt.red").toInt()==Qt::red);
491 491 QVERIFY(_main.getVariable("PythonQt.QtCore.Qt.FlatCap").toInt()==Qt::FlatCap);
492 492 QVERIFY(PythonQtObjectPtr(_main.getVariable("PythonQt.QtCore.Qt.escape")));
493 493 // check for an enum type wrapper
494 494 QVERIFY(PythonQtObjectPtr(_main.getVariable("PythonQt.QtCore.Qt.AlignmentFlag")));
495 495 // check for a flags type wrapper
496 496 QVERIFY(PythonQtObjectPtr(_main.getVariable("PythonQt.QtCore.Qt.Alignment")));
497 497 }
498 498
499 499 void PythonQtTestApi::testConnects()
500 500 {
501 501 // QVERIFY(qVariantValue<QColor>(_main.evalScript("PythonQt.Qt.QColor(PythonQt.Qt.Qt.red)" ,Py_eval_input)) == QColor(Qt::red));
502 502 //TODO: add signal/slot connect both with QObject.connect and connect
503 503 }
504 504
505 505 void PythonQtTestApi::testQColorDecorators()
506 506 {
507 507 PythonQtObjectPtr colorClass = _main.getVariable("PythonQt.QtGui.QColor");
508 508 QVERIFY(colorClass);
509 509 // verify that the class is in the correct module
510 510 QVERIFY(colorClass.getVariable("__module__") == "PythonQt.QtGui");
511 511 // test on Qt module as well:
512 512 colorClass = _main.getVariable("PythonQt.Qt.QColor");
513 513 QVERIFY(colorClass);
514 514 // constructors
515 515 QVERIFY(qVariantValue<QColor>(colorClass.call(QVariantList() << 1 << 2 << 3)) == QColor(1,2,3));
516 516 QVERIFY(qVariantValue<QColor>(colorClass.call()) == QColor());
517 517 QEXPECT_FAIL("", "Testing non-existing constructor", Continue);
518 518 QVERIFY(colorClass.call(QVariantList() << 1 << 2) != QVariant());
519 519
520 520 // check that enum overload is taken over int
521 521 QVERIFY(qVariantValue<QColor>(_main.evalScript("PythonQt.Qt.QColor(PythonQt.Qt.Qt.red)" ,Py_eval_input)) == QColor(Qt::red));
522 522 // check that int overload is taken over enum
523 523 QVERIFY(qVariantValue<QColor>(_main.evalScript("PythonQt.Qt.QColor(0x112233)" ,Py_eval_input)) == QColor(0x112233));
524 524
525 525 // check for decorated Cmyk enum value
526 526 QVERIFY(colorClass.getVariable("Cmyk").toInt() == QColor::Cmyk);
527 527 PythonQtObjectPtr staticMethod = colorClass.getVariable("fromRgb");
528 528 QVERIFY(staticMethod);
529 529 // direct call of static method via class
530 530 QVERIFY(qVariantValue<QColor>(colorClass.call("fromRgb", QVariantList() << 1 << 2 << 3)) == QColor(1,2,3));
531 531 // direct call of static method
532 532 QVERIFY(qVariantValue<QColor>(staticMethod.call(QVariantList() << 1 << 2 << 3)) == QColor(1,2,3));
533 533 PythonQtObjectPtr publicMethod = colorClass.getVariable("red");
534 534 QVERIFY(publicMethod);
535 535 // call with passing self in:
536 536 QVERIFY(colorClass.call("red", QVariantList() << QColor(255,0,0)).toInt() == 255);
537 537 }
538 538
539 539 QByteArray PythonQtTestApiHelper::readFileAsBytes(const QString& filename)
540 540 {
541 541 QByteArray b;
542 542 return b;
543 543 }
544 544
545 545 QByteArray PythonQtTestApiHelper::readSourceFile(const QString& filename, bool& ok)
546 546 {
547 547 QByteArray b;
548 548 ok = true;
549 549 return b;
550 550 }
551 551
552 552 bool PythonQtTestApiHelper::exists(const QString& filename)
553 553 {
554 554 return true;
555 555 }
556 556
557 557 QDateTime PythonQtTestApiHelper::lastModifiedDate(const QString& filename) {
558 558 return QDateTime::currentDateTime();
559 559 }
560 560
561 561
562 562 void PythonQtTestApi::testRedirect()
563 563 {
564 564 connect(PythonQt::self(), SIGNAL(pythonStdOut(const QString&)), _helper, SLOT(stdOut(const QString&)));
565 565 connect(PythonQt::self(), SIGNAL(pythonStdErr(const QString&)), _helper, SLOT(stdErr(const QString&)));
566 566 PyRun_SimpleString("print 'test'\n");
567 567 }
568 568
569 569 void PythonQtTestApiHelper::stdOut(const QString& s)
570 570 {
571 571 qDebug() << s;
572 572 }
573 573
574 574 void PythonQtTestApiHelper::stdErr(const QString& s)
575 575 {
576 576 qDebug() << s;
577 577 }
578 578
579 579 QObject* PythonQtTestCppFactory::create(const QByteArray& name, void *ptr)
580 580 {
581 581 if (name == "PQCppObject") {
582 582 return new PQCppObjectWrapper(ptr);
583 583 }
584 584 return NULL;
585 585 }
Show file before | Show file after | Hide comments
@@ -1,515 +1,515
1 1 #ifndef _PYTHONQTTESTS_H
2 2 #define _PYTHONQTTESTS_H
3 3
4 4 /*
5 5 *
6 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
6 * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
7 7 *
8 8 * This library is free software; you can redistribute it and/or
9 9 * modify it under the terms of the GNU Lesser General Public
10 10 * License as published by the Free Software Foundation; either
11 11 * version 2.1 of the License, or (at your option) any later version.
12 12 *
13 13 * This library is distributed in the hope that it will be useful,
14 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 16 * Lesser General Public License for more details.
17 17 *
18 18 * Further, this software is distributed without any warranty that it is
19 19 * free of the rightful claim of any third person regarding infringement
20 20 * or the like. Any license provided herein, whether implied or
21 21 * otherwise, applies only to this software file. Patent licenses, if
22 22 * any, provided herein do not apply to combinations of this program with
23 23 * other software, or any other product whatsoever.
24 24 *
25 25 * You should have received a copy of the GNU Lesser General Public
26 26 * License along with this library; if not, write to the Free Software
27 27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 28 *
29 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
29 * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
30 30 * 28359 Bremen, Germany or:
31 31 *
32 32 * http://www.mevis.de
33 33 *
34 34 */
35 35
36 36 //----------------------------------------------------------------------------------
37 37 /*!
38 38 // \file PythonQtTests.h
39 39 // \author Florian Link
40 40 // \author Last changed by $Author: florian $
41 41 // \date 2006-05
42 42 */
43 43 //----------------------------------------------------------------------------------
44 44
45 45 #include "PythonQt.h"
46 46 #include <QtTest/QtTest>
47 47 #include <QVariant>
48 48 #include "PythonQtImportFileInterface.h"
49 49 #include "PythonQtCppWrapperFactory.h"
50 50
51 51 #include <QPen>
52 52 #include <QColor>
53 53 #include <QBrush>
54 54 #include <QCursor>
55 55
56 56 class PythonQtTestSlotCallingHelper;
57 57 class PythonQtTestApiHelper;
58 58 class QWidget;
59 59
60 60 //! test the PythonQt api
61 61 class PythonQtTestApi : public QObject
62 62 {
63 63 Q_OBJECT
64 64
65 65 private slots:
66 66 void initTestCase();
67 67 void testCall();
68 68 void testVariables();
69 69 void testRedirect();
70 70 void testImporter();
71 71 void testQColorDecorators();
72 72 void testQtNamespace();
73 73 void testConnects();
74 74
75 75 void testProperties();
76 76 void testDynamicProperties();
77 77
78 78 private:
79 79 PythonQtTestApiHelper* _helper;
80 80 PythonQtObjectPtr _main;
81 81
82 82 };
83 83
84 84 class ClassA {
85 85 public:
86 86 ClassA() { x = 1; }
87 87 int x;
88 88 };
89 89
90 90 class ClassB {
91 91 public:
92 92 ClassB() { y = 2; }
93 93 int y;
94 94
95 95 virtual int type() { return 2; }
96 96 };
97 97
98 98 class ClassC : public ClassA, public ClassB {
99 99 public:
100 100 ClassC() { z = 3; }
101 101 int z;
102 102
103 103 virtual int type() { return 3; }
104 104 };
105 105
106 106 class ClassD : public QObject, public ClassA, public ClassB {
107 107 Q_OBJECT
108 108 public:
109 109 ClassD() { d = 4; }
110 110 public slots:
111 111 int getD() { return d; }
112 112 private:
113 113 int d;
114 114
115 115 virtual int type() { return 4; }
116 116 };
117 117
118 118 class ClassAWrapper : public QObject {
119 119 Q_OBJECT
120 120 public slots:
121 121 ClassA* new_ClassA() { return new ClassA; }
122 122 int getX(ClassA* o) { return o->x; }
123 123 };
124 124
125 125 class ClassBWrapper : public QObject {
126 126 Q_OBJECT
127 127 public slots:
128 128 ClassB* new_ClassB() { return new ClassB; }
129 129 int getY(ClassB* o) { return o->y; }
130 130 };
131 131
132 132 class ClassCWrapper : public QObject {
133 133 Q_OBJECT
134 134 public slots:
135 135 ClassC* new_ClassC() { return new ClassC; }
136 136 int getZ(ClassC* o) { return o->z; }
137 137 };
138 138
139 139 class ClassDWrapper : public QObject {
140 140 Q_OBJECT
141 141 public slots:
142 142 ClassD* new_ClassD() { return new ClassD; }
143 143 };
144 144
145 145
146 146 //! test the PythonQt api (helper)
147 147 class PythonQtTestApiHelper : public QObject , public PythonQtImportFileInterface
148 148 {
149 149 Q_OBJECT
150 150 public:
151 151 PythonQtTestApiHelper() {
152 152 };
153 153
154 154 bool call(const QString& function, const QVariantList& args, const QVariant& expectedResult);
155 155
156 156 virtual QByteArray readFileAsBytes(const QString& filename);
157 157
158 158 virtual QByteArray readSourceFile(const QString& filename, bool& ok);
159 159
160 160 virtual bool exists(const QString& filename);
161 161
162 162 virtual QDateTime lastModifiedDate(const QString& filename);
163 163
164 164 public slots:
165 165
166 166 //! call to set that the test has passed (from Python!)
167 167 void setPassed() { _passed = true; }
168 168
169 169 void stdOut(const QString&);
170 170 void stdErr(const QString&);
171 171
172 172 private:
173 173 bool _passed;
174 174 };
175 175
176 176
177 177 // test implementation of the wrapper factory
178 178 class PythonQtTestCppFactory : public PythonQtCppWrapperFactory
179 179 {
180 180 public:
181 181 virtual QObject* create(const QByteArray& name, void *ptr);
182 182 };
183 183
184 184 //! an cpp object to be wrapped
185 185 class PQCppObject {
186 186
187 187 public:
188 188 PQCppObject(int h) { _height = h; }
189 189
190 190 int getHeight() { return _height; }
191 191 void setHeight(int h) { _height = h; }
192 192
193 193 private:
194 194 int _height;
195 195 };
196 196
197 197 //! an qobject that wraps the existing cpp object
198 198 class PQCppObjectWrapper : public QObject {
199 199 Q_OBJECT
200 200 public:
201 201 PQCppObjectWrapper(void* ptr) {
202 202 _ptr = (PQCppObject*)ptr;
203 203 }
204 204
205 205 public slots:
206 206 int getHeight() { return _ptr->getHeight(); }
207 207 void setHeight(int h) { _ptr->setHeight(h); }
208 208
209 209 private:
210 210 PQCppObject* _ptr;
211 211 };
212 212
213 213 class PQCppObjectDecorator : public QObject {
214 214 Q_OBJECT
215 215 public slots:
216 216 int getH(PQCppObject* obj) { return obj->getHeight(); }
217 217
218 218 };
219 219
220 220 //! an cpp object to be wrapped by decorators only
221 221 class PQCppObjectNoWrap {
222 222
223 223 public:
224 224 PQCppObjectNoWrap() { _height = 0; }
225 225 PQCppObjectNoWrap(int h) { _height = h; }
226 226
227 227 int getHeight() { return _height; }
228 228 void setHeight(int h) { _height = h; }
229 229
230 230 private:
231 231 int _height;
232 232 };
233 233
234 234 class PQCppObjectNoWrapDecorator : public QObject {
235 235 Q_OBJECT
236 236
237 237 public slots:
238 238 PQCppObjectNoWrap* new_PQCppObjectNoWrap() {
239 239 return new PQCppObjectNoWrap(0);
240 240 }
241 241 PQCppObjectNoWrap* new_PQCppObjectNoWrap(const PQCppObjectNoWrap& other) {
242 242 return new PQCppObjectNoWrap(1);
243 243 }
244 244 PQCppObjectNoWrap* new_PQCppObjectNoWrap(double value) {
245 245 return new PQCppObjectNoWrap(2);
246 246 }
247 247
248 248 int getH(PQCppObjectNoWrap* obj) { return obj->getHeight(); }
249 249
250 250 };
251 251
252 252
253 253 //! an cpp object that is to be wrapped by decorators only
254 254 class PQCppObject2 {
255 255
256 256 public:
257 257 enum TestEnumFlag {
258 258 TestEnumValue1 = 0,
259 259 TestEnumValue2 = 1
260 260 };
261 261
262 262 PQCppObject2() {}
263 263
264 264 };
265 265
266 266 class PQCppObject2Decorator : public QObject {
267 267 Q_OBJECT
268 268
269 269 public:
270 270 Q_ENUMS(TestEnumFlag)
271 271 Q_FLAGS(TestEnum)
272 272
273 273 enum TestEnumFlag {
274 274 TestEnumValue1 = 0,
275 275 TestEnumValue2 = 1
276 276 };
277 277
278 278 Q_DECLARE_FLAGS(TestEnum, TestEnumFlag)
279 279
280 280 public slots:
281 281 PQCppObject2* new_PQCppObject2() {
282 282 return new PQCppObject2();
283 283 }
284 284
285 285 TestEnumFlag testEnumFlag1(PQCppObject2* obj, TestEnumFlag flag);
286 286
287 287 PQCppObject2::TestEnumFlag testEnumFlag2(PQCppObject2* obj, PQCppObject2::TestEnumFlag flag);
288 288
289 289 // with int overload
290 290 TestEnumFlag testEnumFlag3(PQCppObject2* obj, int flag);
291 291 TestEnumFlag testEnumFlag3(PQCppObject2* obj, TestEnumFlag flag);
292 292
293 293 };
294 294
295 295 class PQUnknownValueObject
296 296 {
297 297 public:
298 298 PQUnknownValueObject() {};
299 299 };
300 300
301 301 class PQUnknownButRegisteredValueObject
302 302 {
303 303 public:
304 304 PQUnknownButRegisteredValueObject() {};
305 305 };
306 306
307 307 //! test the calling of slots
308 308 class PythonQtTestSlotCalling : public QObject
309 309 {
310 310 Q_OBJECT
311 311
312 312 private slots:
313 313 void initTestCase();
314 314 void init();
315 315
316 316 void testNoArgSlotCall();
317 317 void testPODSlotCalls();
318 318 void testCPPSlotCalls();
319 319 void testQVariantSlotCalls();
320 320 void testObjectSlotCalls();
321 321 void testMultiArgsSlotCall();
322 322 void testPyObjectSlotCall();
323 323 void testOverloadedCall();
324 324 void testCppFactory();
325 325 void testInheritance();
326 326 void testAutoConversion();
327 327
328 328 private:
329 329 PythonQtTestSlotCallingHelper* _helper;
330 330
331 331 };
332 332
333 333 //! helper class for slot calling test
334 334 class PythonQtTestSlotCallingHelper : public QObject
335 335 {
336 336 Q_OBJECT
337 337 public:
338 338 PythonQtTestSlotCallingHelper(PythonQtTestSlotCalling* test) {
339 339 _test = test;
340 340 };
341 341
342 342 bool runScript(const char* script, int expectedOverload = -1);
343 343
344 344 public slots:
345 345
346 346 //! call to set that the test has passed (from Python!)
347 347 void setPassed() { _passed = true; }
348 348
349 349 //! no arguments, no return value:
350 350 void testNoArg() { _called = true; }
351 351
352 352 //! overload test!
353 353 void overload(bool a) { _calledOverload = 0; _called = true; }
354 354 void overload(float a) { _calledOverload = 1; _called = true;}
355 355 void overload(int a) { _calledOverload = 2; _called = true;}
356 356 void overload(const QString& str) { _calledOverload = 3; _called = true;}
357 357 void overload(const QStringList& str) { _calledOverload = 4; _called = true;}
358 358 void overload(QObject* str) { _calledOverload = 5; _called = true;}
359 359 void overload(float a, int b) { _calledOverload = 6; _called = true;}
360 360
361 361 //! POD values:
362 362 int getInt(int a) { _called = true; return a; }
363 363 unsigned int getUInt(unsigned int a) { _called = true; return a; }
364 364 bool getBool(bool a) { _called = true; return a; }
365 365 char getChar(char a) { _called = true; return a; }
366 366 unsigned char getUChar(unsigned char a) { _called = true; return a; }
367 367 long getLong(long a) { _called = true; return a; }
368 368 unsigned long getULong(unsigned long a) { _called = true; return a; }
369 369 short getShort(short a) { _called = true; return a; }
370 370 unsigned short getUShort(unsigned short a) { _called = true; return a; }
371 371 QChar getQChar(QChar a) { _called = true; return a; }
372 372 qint64 getLongLong(qint64 a) { _called = true; return a; }
373 373 quint64 getULongLong(quint64 a) { _called = true; return a; }
374 374 double getDouble(double d) { _called = true; return d; }
375 375 float getFloat(float d) { _called = true; return d; }
376 376
377 377 //! important qt types:
378 378 QString getQString(const QString& s) { _called = true; return s; }
379 379 QStringList getQStringList(const QStringList& l) { _called = true; return l; }
380 380 QVariant getQVariant(const QVariant& var) { _called = true; return var; }
381 381
382 382 // QColor as representative for C++ value classes
383 383 QColor getQColor1(const QColor& var) { _called = true; return var; }
384 384 QColor getQColor2(QColor& var) { _called = true; return var; }
385 385 QColor getQColor3(QColor* col) { _called = true; return *col; }
386 386 QColor getQColor4(const QVariant& color) { _called = true; return qVariantValue<QColor>(color); }
387 387 QColor* getQColor5() { _called = true; static QColor c(1,2,3); return &c; }
388 388
389 389 PyObject* getPyObject(PyObject* obj) { _called = true; return obj; }
390 390 PyObject* getPyObjectFromVariant(const QVariant& val) { _called = true; return PythonQtObjectPtr(val); };
391 391 QVariant getPyObjectFromVariant2(const QVariant& val) { _called = true; return val; };
392 392 // this does not yet work but is not required to work:
393 393 //PyObject* getPyObjectFromPtr(const PythonQtObjectPtr& val) { _called = true; return val; };
394 394
395 395 //! testing pointer passing
396 396 PythonQtTestSlotCallingHelper* getTestObject(PythonQtTestSlotCallingHelper* obj) { _called = true; return obj; }
397 397 //! testing inheritance checking
398 398 QObject* getQObject(QObject* obj) { _called = true; return obj; }
399 399 QWidget* getQWidget(QWidget* obj) { _called = true; return obj; }
400 400 //! testing if an object that was not wrapped is wrapped earlier is wrapped correctly
401 401 QObject* getNewObject() { _called = true; return new PythonQtTestSlotCallingHelper(NULL); }
402 402
403 403 QVariantList getMultiArgs(int a, double b, const QString& str) { _called = true; return (QVariantList() << a << b << str); }
404 404
405 405 //! cpp wrapper factory test
406 406 PQCppObject* createPQCppObject(int h) { _called = true; return new PQCppObject(h); }
407 407
408 408 //! cpp wrapper factory test
409 409 PQCppObject* getPQCppObject(PQCppObject* p) { _called = true; return p; }
410 410
411 411 //! cpp wrapper factory test
412 412 PQCppObjectNoWrap* createPQCppObjectNoWrap(int h) { _called = true; return new PQCppObjectNoWrap(h); }
413 413
414 414 //! cpp wrapper factory test
415 415 PQCppObjectNoWrap* getPQCppObjectNoWrap(PQCppObjectNoWrap* p) { _called = true; return p; }
416 416
417 417 //! get a return by value PQCppObjectNoWrap
418 418 PQCppObjectNoWrap getPQCppObjectNoWrapAsValue() { _called = true; return PQCppObjectNoWrap(47); }
419 419
420 420 PQUnknownButRegisteredValueObject getUnknownButRegisteredValueObjectAsValue() { _called = true; return PQUnknownButRegisteredValueObject(); }
421 421 PQUnknownValueObject getUnknownValueObjectAsValue() { _called = true; return PQUnknownValueObject(); }
422 422
423 423 PQUnknownButRegisteredValueObject* getUnknownButRegisteredValueObjectAsPtr() { _called = true; return new PQUnknownButRegisteredValueObject(); }
424 424 PQUnknownValueObject* getUnknownValueObjectAsPtr() { _called = true; return new PQUnknownValueObject(); }
425 425
426 426 ClassA* getClassAPtr(ClassA* o) { _called = true; return o; }
427 427 ClassB* getClassBPtr(ClassB* o) { _called = true; return o; }
428 428 ClassC* getClassCPtr(ClassC* o) { _called = true; return o; }
429 429 ClassD* getClassDPtr(ClassD* o) { _called = true; return o; }
430 430
431 431 ClassA* createClassA() { _called = true; return new ClassA; }
432 432 ClassB* createClassB() { _called = true; return new ClassB; }
433 433 ClassC* createClassC() { _called = true; return new ClassC; }
434 434 ClassD* createClassD() { _called = true; return new ClassD; }
435 435 ClassA* createClassCAsA() { _called = true; return new ClassC; }
436 436 ClassB* createClassCAsB() { _called = true; return new ClassC; }
437 437 ClassA* createClassDAsA() { _called = true; return new ClassD; }
438 438 ClassB* createClassDAsB() { _called = true; return new ClassD; }
439 439
440 440 QColor setAutoConvertColor(const QColor& color) { _called = true; return color; };
441 441 QBrush setAutoConvertBrush(const QBrush& brush) { _called = true; return brush; };
442 442 QPen setAutoConvertPen(const QPen& pen) { _called = true; return pen; };
443 443 QCursor setAutoConvertCursor(const QCursor& cursor) { _called = true; return cursor; };
444 444
445 445 private:
446 446 bool _passed;
447 447 bool _called;
448 448 int _calledOverload;
449 449 PythonQtTestSlotCalling* _test;
450 450 };
451 451
452 452 class PythonQtTestSignalHandlerHelper;
453 453
454 454 //! test the connection of signals to python
455 455 class PythonQtTestSignalHandler : public QObject
456 456 {
457 457 Q_OBJECT
458 458
459 459 private slots:
460 460 void initTestCase();
461 461
462 462 void testSignalHandler();
463 463 void testRecursiveSignalHandler();
464 464
465 465 private:
466 466 PythonQtTestSignalHandlerHelper* _helper;
467 467
468 468 };
469 469
470 470 //! helper class for signal testing
471 471 class PythonQtTestSignalHandlerHelper : public QObject
472 472 {
473 473 Q_OBJECT
474 474
475 475 public:
476 476 PythonQtTestSignalHandlerHelper(PythonQtTestSignalHandler* test) {
477 477 _test = test;
478 478 };
479 479
480 480 public slots:
481 481 void setPassed() { _passed = true; }
482 482
483 483 bool emitIntSignal(int a) { _passed = false; emit intSignal(a); return _passed; };
484 484 bool emitFloatSignal(float a) { _passed = false; emit floatSignal(a); return _passed; };
485 485 bool emitEnumSignal(PQCppObject2::TestEnumFlag flag) { _passed = false; emit enumSignal(flag); return _passed; };
486 486
487 487 bool emitVariantSignal(const QVariant& v) { _passed = false; emit variantSignal(v); return _passed; };
488 488 QVariant expectedVariant() { return _v; }
489 489 void setExpectedVariant(const QVariant& v) { _v = v; }
490 490
491 491 bool emitComplexSignal(int a, float b, const QStringList& l, QObject* obj) { _passed = false; emit complexSignal(a,b,l,obj); return _passed; };
492 492
493 493 bool emitSignal1(int a) { _passed = false; emit signal1(a); return _passed; };
494 494 bool emitSignal2(const QString& s) { _passed = false; emit signal2(s); return _passed; };
495 495 bool emitSignal3(float a) { _passed = false; emit signal3(a); return _passed; };
496 496
497 497 signals:
498 498 void intSignal(int);
499 499 void floatSignal(float);
500 500 void variantSignal(const QVariant& v);
501 501 void complexSignal(int a, float b, const QStringList& l, QObject* obj);
502 502 void enumSignal(PQCppObject2::TestEnumFlag flag);
503 503
504 504 void signal1(int);
505 505 void signal2(const QString&);
506 506 void signal3(float);
507 507
508 508 private:
509 509 bool _passed;
510 510 QVariant _v;
511 511
512 512 PythonQtTestSignalHandler* _test;
513 513 };
514 514
515 515 #endif
General Comments 0
You need to be logged in to leave comments. Login now