##// END OF EJS Templates
HG_REPOSITORIES » LPP » INSTRUMENTATION » USERS » JEANDET » QLop
RSS
A lot of refactoring:...
jeandet -
r6:665de41c4c74 default
parent child
Show More
Show file before | Show file after | Hide comments
@@ -0,0 +1,2
1 ListView Icon : Quan Do @ https://thenounproject.com
2 TreeView Icon : Anisha Varghese @ https://thenounproject.com
Show file before | Show file after | Hide comments
@@ -0,0 +1,61
1 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
2 <!-- Created with Inkscape (http://www.inkscape.org/) -->
3 <svg xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:cc="http://web.resource.org/cc/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:svg="http://www.w3.org/2000/svg" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd" xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape" width="48" height="48" id="svg2" sodipodi:version="0.32" inkscape:version="0.45" version="1.0" sodipodi:docbase="/home/dobey/Projects/gnome-icon-theme/scalable/actions" sodipodi:docname="go-up.svg" inkscape:export-filename="/home/jimmac/src/cvs/gnome/gnome-icon-theme/16x16/actions/go-previous.png" inkscape:export-xdpi="90" inkscape:export-ydpi="90" inkscape:output_extension="org.inkscape.output.svg.inkscape">
4 <defs id="defs4">
5 <linearGradient inkscape:collect="always" id="linearGradient5105">
6 <stop style="stop-color:black;stop-opacity:1;" offset="0" id="stop5107"/>
7 <stop style="stop-color:black;stop-opacity:0;" offset="1" id="stop5109"/>
8 </linearGradient>
9 <linearGradient inkscape:collect="always" id="linearGradient5113">
10 <stop style="stop-color:white;stop-opacity:1;" offset="0" id="stop5115"/>
11 <stop style="stop-color:white;stop-opacity:0;" offset="1" id="stop5117"/>
12 </linearGradient>
13 <radialGradient inkscape:collect="always" xlink:href="#linearGradient5105" id="radialGradient4354" gradientUnits="userSpaceOnUse" gradientTransform="matrix(1,0,0,0.282946,0,13.64644)" cx="11.25" cy="19.03125" fx="11.25" fy="19.03125" r="8.0625"/>
14 <linearGradient inkscape:collect="always" xlink:href="#linearGradient5113" id="linearGradient5315" x1="43.129921" y1="15.195395" x2="7.9313831" y2="34.731434" gradientUnits="userSpaceOnUse" gradientTransform="matrix(0,-1.004639,1,0,-1.992125,51.04405)"/>
15 </defs>
16 <sodipodi:namedview id="base" pagecolor="#ffffff" bordercolor="#666" borderopacity="0.17254902" inkscape:pageopacity="0.0" inkscape:pageshadow="2" inkscape:zoom="22.627417" inkscape:cx="27.580601" inkscape:cy="22.230627" inkscape:document-units="px" inkscape:current-layer="layer1" width="48px" height="48px" inkscape:showpageshadow="false" showgrid="false" inkscape:window-width="1680" inkscape:window-height="973" inkscape:window-x="0" inkscape:window-y="27"/>
17 <metadata id="metadata7">
18 <rdf:RDF>
19 <cc:Work rdf:about="">
20 <dc:format>image/svg+xml</dc:format>
21 <dc:type rdf:resource="http://purl.org/dc/dcmitype/StillImage"/>
22 <dc:title>Go up</dc:title>
23 <dc:date>August 2006</dc:date>
24 <dc:creator>
25 <cc:Agent>
26 <dc:title>Andreas Nilsson</dc:title>
27 </cc:Agent>
28 </dc:creator>
29 <dc:contributor>
30 <cc:Agent>
31 <dc:title>Jakub Steiner</dc:title>
32 </cc:Agent>
33 </dc:contributor>
34 <dc:source>http://www.gnome.org</dc:source>
35 <dc:subject>
36 <rdf:Bag>
37 <rdf:li>up</rdf:li>
38 <rdf:li>arrow</rdf:li>
39 <rdf:li>go</rdf:li>
40 </rdf:Bag>
41 </dc:subject>
42 <cc:license rdf:resource="http://creativecommons.org/licenses/GPL/2.0/"/>
43 <dc:description/>
44 </cc:Work>
45 <cc:License rdf:about="http://creativecommons.org/licenses/GPL/2.0/">
46 <cc:permits rdf:resource="http://web.resource.org/cc/Reproduction"/>
47 <cc:permits rdf:resource="http://web.resource.org/cc/Distribution"/>
48 <cc:requires rdf:resource="http://web.resource.org/cc/Notice"/>
49 <cc:permits rdf:resource="http://web.resource.org/cc/DerivativeWorks"/>
50 <cc:requires rdf:resource="http://web.resource.org/cc/ShareAlike"/>
51 <cc:requires rdf:resource="http://web.resource.org/cc/SourceCode"/>
52 </cc:License>
53 </rdf:RDF>
54 </metadata>
55 <g inkscape:label="Layer 1" inkscape:groupmode="layer" id="layer1">
56 <path sodipodi:type="arc" style="opacity:0.16292138;color:black;fill:url(#radialGradient4354);fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:1;stroke-linecap:butt;stroke-linejoin:miter;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible" id="path4346" sodipodi:cx="11.25" sodipodi:cy="19.03125" sodipodi:rx="8.0625" sodipodi:ry="2.28125" d="M 19.3125 19.03125 A 8.0625 2.28125 0 1 1 3.1875,19.03125 A 8.0625 2.28125 0 1 1 19.3125 19.03125 z" transform="matrix(2.48062,0,0,2.410961,-3.906976,-5.38361)"/>
57 <path style="opacity:1;color:black;fill:#3465a4;fill-opacity:1;fill-rule:nonzero;stroke:#204a87;stroke-width:0.99999958;stroke-linecap:butt;stroke-linejoin:miter;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible" d="M 7.4999998,27.504161 L 24.006024,8.5000164 L 40.429315,27.504161 L 32.55948,27.504161 L 32.55948,42.5 L 15.504348,42.5 L 15.504348,27.504161 L 7.4999998,27.504161 z " id="path4348" sodipodi:nodetypes="cccccccc"/>
58 <path style="opacity:0.35393258;color:black;fill:#729fcf;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:1;stroke-linecap:butt;stroke-linejoin:miter;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible" d="M 16.007932,42.006365 L 23.960194,42.006365 L 23.936091,9.2374984 L 8.5915668,26.852103 L 16.007932,26.852103 L 16.007932,42.006365 z " id="path4352" sodipodi:nodetypes="cccccc"/>
59 <path style="opacity:0.35400002;color:black;fill:none;fill-opacity:1;fill-rule:nonzero;stroke:url(#linearGradient5315);stroke-width:0.99999958;stroke-linecap:butt;stroke-linejoin:miter;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible" d="M 9.6410568,26.433312 L 24.02733,9.9166734 L 38.226631,26.433312 L 31.488262,26.433312 L 31.488262,41.499995 L 16.509928,41.499995 L 16.509928,26.433312 L 9.6410568,26.433312 z " id="path4360" sodipodi:nodetypes="cccccccc"/>
60 </g>
61 </svg> No newline at end of file
Show file before | Show file after | Hide comments
@@ -0,0 +1,54
1 <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" x="0px" y="0px" width="100px" height="100px" viewBox="5.0 -10.0 100.0 135.0" enable-background="new 0 0 100 100" xml:space="preserve">
2 <g id="Captions">
3 <rect x="-192" width="185" height="99"/>
4 <rect y="-36" width="100" height="30"/>
5 <text transform="matrix(1 0 0 1 66 -19.5)" fill="#000000" font-family="'Helvetica'" font-size="2.4">http://thenounproject.com</text>
6 <text transform="matrix(1 0 0 1 7.166 -24.5)"><tspan x="0" y="0" fill="#000000" font-family="'Helvetica-Bold'" font-size="6.1578">The Noun Project</tspan><tspan x="1.12" y="4.8" fill="#000000" font-family="'Helvetica-Bold'" font-size="4">Icon Template</tspan></text>
7 <text transform="matrix(1 0 0 1 -178.5 10.5)" fill="#000000" font-family="'Helvetica-Bold'" font-size="6.1578">Reminders</text>
8 <line fill="#000000" stroke="#FFFFFF" stroke-miterlimit="10" x1="8" y1="-14.5" x2="18" y2="-14.5"/>
9 <line fill="#000000" stroke="#FFFFFF" stroke-miterlimit="10" x1="-179" y1="16.5" x2="-162" y2="16.5"/>
10 <g>
11 <g>
12 <g>
13 <rect x="-170.802" y="31.318" fill="#000000" width="8.721" height="8.642"/>
14 <path fill="#000000" d="M-164.455,42.312h4.747v-4.703h-4.747V42.312z M-159.266,42.749h-5.63V37.17h5.63V42.749 L-159.266,42.749z M-166.221,44.062h8.279v-8.203h-8.279V44.062L-166.221,44.062z M-157.5,44.5h-9.163v-9.079h9.163V44.5 L-157.5,44.5z"/>
15 <polygon fill="#000000" points="-166.149,44.133 -166.292,43.991 -158.013,35.787 -157.871,35.929 "/>
16 </g>
17 </g>
18 </g>
19 <rect x="-179" y="58" fill="none" width="35" height="32.5"/>
20 <text transform="matrix(1 0 0 1 -179 60.1572)"><tspan x="0" y="0" fill="#000000" font-family="'Helvetica-Bold'" font-size="3">Strokes</tspan><tspan x="0" y="5" fill="#000000" font-family="'Helvetica'" font-size="2.4">Try to keep strokes at 4px</tspan><tspan x="0" y="10" fill="#000000" font-family="'Helvetica'" font-size="2.4">Minimum stroke weight is 2px</tspan><tspan x="0" y="14.5" fill="#000000" font-family="'Helvetica'" font-size="2.4">For thicker strokes use even </tspan><tspan x="0" y="17.5" fill="#000000" font-family="'Helvetica'" font-size="2.4">numbers: 6px, 8px etc.</tspan><tspan x="0" y="22" fill="#000000" font-family="'Helvetica-Bold'" font-size="2.4">Remember to expand strokes </tspan><tspan x="0" y="25" fill="#000000" font-family="'Helvetica-Bold'" font-size="2.4">before saving as an SVG </tspan></text>
21 <rect x="-136.5" y="58" fill="none" width="35" height="32.5"/>
22 <text transform="matrix(1 0 0 1 -136.5 60.1572)"><tspan x="0" y="0" fill="#000000" font-family="'Helvetica-Bold'" font-size="3">Size</tspan><tspan x="0" y="5" fill="#000000" font-family="'Helvetica'" font-size="2.4">Cannot be wider or taller than </tspan><tspan x="0" y="8.5" fill="#000000" font-family="'Helvetica'" font-size="2.4">100px (artboard size)</tspan><tspan x="0" y="13.5" fill="#000000" font-family="'Helvetica'" font-size="2.4">Scale your icon to fill as much of </tspan><tspan x="0" y="16.5" fill="#000000" font-family="'Helvetica'" font-size="2.4">the artboard as possible</tspan></text>
23 <rect x="-94" y="58" fill="none" width="35" height="32.5"/>
24 <text transform="matrix(1 0 0 1 -94 60.1572)"><tspan x="0" y="0" fill="#000000" font-family="'Helvetica-Bold'" font-size="3">Ungroup</tspan><tspan x="0" y="5" fill="#000000" font-family="'Helvetica'" font-size="2.4">If your design has more than one </tspan><tspan x="0" y="8" fill="#000000" font-family="'Helvetica'" font-size="2.4">shape, make sure to ungroup</tspan></text>
25 <rect x="-50" y="58" fill="none" width="35" height="32.5"/>
26 <text transform="matrix(1 0 0 1 -50 60.1572)"><tspan x="0" y="0" fill="#000000" font-family="'Helvetica-Bold'" font-size="3">Save as</tspan><tspan x="0" y="5" fill="#000000" font-family="'Helvetica'" font-size="2.4">Save as .SVG and make sure </tspan><tspan x="0" y="8" fill="#000000" font-family="'Helvetica'" font-size="2.4">&#8220;Use Artboards&#8221; is checked</tspan></text>
27 <text transform="matrix(1.0074 0 0 1 -125.542 30.5933)" fill="#000000" font-family="'Helvetica'" font-size="2.5731">100px</text>
28 <text transform="matrix(1.0074 0 0 1 -41 39)" fill="#000000" font-family="'Helvetica-Bold'" font-size="5.1462">.SVG</text>
29 <rect x="-126.514" y="34.815" fill="#000000" width="10.261" height="10.185"/>
30 <rect x="-126.477" y="31.766" fill="#000000" width="0.522" height="2.337"/>
31 <rect x="-116.812" y="31.766" fill="#000000" width="0.523" height="2.337"/>
32 <rect x="-127" y="32.337" fill="#000000" width="11.233" height="0.572"/>
33 <g>
34 <rect x="-83.805" y="33.844" fill="#000000" width="10.305" height="10.156"/>
35 <rect x="-76.809" y="28.707" fill="#000000" width="3.308" height="3.261"/>
36 </g>
37 <rect x="-178.5" y="22.5" fill="#000000" stroke="#FFFFFF" stroke-miterlimit="10" width="30" height="30"/>
38 <rect x="-136.5" y="22.5" fill="#000000" stroke="#FFFFFF" stroke-miterlimit="10" width="30" height="30"/>
39 <rect x="-93.5" y="22.5" fill="#000000" stroke="#FFFFFF" stroke-miterlimit="10" width="30" height="30"/>
40 <rect x="-49.5" y="22.5" fill="#000000" stroke="#FFFFFF" stroke-miterlimit="10" width="30" height="30"/>
41 </g>
42 <g id="Your_Icon">
43 <path d="M92.085,23.914H42.56c-3.503,0-6.346-2.843-6.346-6.346c0-3.504,2.842-6.347,6.346-6.347h49.525 c3.504,0,6.35,2.842,6.35,6.347C98.435,21.071,95.589,23.914,92.085,23.914z"/>
44 <path d="M18.022,25.841H8.346C4.842,25.841,2,23,2,19.495v-4.149C2,11.842,4.842,9,8.346,9h9.676c3.503,0,6.346,2.842,6.346,6.346 v4.149C24.368,23,21.525,25.841,18.022,25.841z"/>
45 <g>
46 <path d="M92.085,55.456H42.56c-3.503,0-6.346-2.843-6.346-6.345c0-3.504,2.842-6.347,6.346-6.347h49.525 c3.504,0,6.35,2.843,6.35,6.347C98.435,52.613,95.589,55.456,92.085,55.456z"/>
47 <path d="M18.022,57.532H8.346C4.842,57.532,2,54.69,2,51.186v-4.149c0-3.503,2.842-6.345,6.346-6.345h9.676 c3.503,0,6.346,2.842,6.346,6.345v4.149C24.368,54.69,21.525,57.532,18.022,57.532z"/>
48 </g>
49 <g>
50 <path d="M92.085,87.146H42.56c-3.503,0-6.346-2.841-6.346-6.345c0-3.505,2.842-6.346,6.346-6.346h49.525 c3.504,0,6.35,2.841,6.35,6.346C98.435,84.306,95.589,87.146,92.085,87.146z"/>
51 <path d="M18.022,89.221H8.346C4.842,89.221,2,86.378,2,82.875v-4.146c0-3.504,2.842-6.347,6.346-6.347h9.676 c3.503,0,6.346,2.843,6.346,6.347v4.146C24.368,86.378,21.525,89.221,18.022,89.221z"/>
52 </g>
53 </g>
54 </svg>
Show file before | Show file after | Hide comments
@@ -0,0 +1,10
1 <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" id="Layer_1" x="0px" y="0px" width="100px" height="100px" viewBox="5.0 -10.0 100.0 135.0" enable-background="new 0 0 100 100" xml:space="preserve">
2 <g id="NAV_BARS">
3 </g>
4 <g id="NAVIGATION">
5 </g>
6 <g id="REFERENCCE" display="none">
7 </g>
8 <g id="Layer_4">
9 <path d="M71.707,69.741c-6.473,0-11.893,3.64-13.432,10.64H39.8c-3.933,0-6.8-3.613-6.8-7.545v-15.15 c2,0.58,2.907,0.695,4.664,0.695h22.15c2.428,3,6.838,6.855,11.893,6.855c7.666,0,13.881-6.16,13.881-13.828 c0-7.666-6.215-13.548-13.881-13.548c-7.434,0-13.482,5.521-13.848,13.521H39.8c-3.933,0-6.8-3.801-6.8-7.732V29.715 c6-1.873,9.213-7.031,9.213-13.117c0-7.668-6.294-13.883-13.961-13.883S14.618,8.93,14.618,16.598 C14.618,22.594,18,27.69,24,29.629v43.919c0,7.861,5.8,13.832,13.664,13.832h20.875c1.834,5,7.031,9.71,13.168,9.71 c7.666,0,13.881-6.008,13.881-13.676C85.588,75.749,79.373,69.741,71.707,69.741z M71.707,45.77c3.145,0,5.693,2.549,5.693,5.695 c0,3.145-2.549,5.693-5.693,5.693c-3.146,0-5.695-2.549-5.695-5.693C66.012,48.318,68.561,45.77,71.707,45.77z M28.172,10.902 c3.146,0,5.695,2.551,5.695,5.695c0,3.146-2.55,5.695-5.695,5.695s-5.695-2.549-5.695-5.695 C22.477,13.453,25.026,10.902,28.172,10.902z M71.707,89.107c-3.146,0-5.695-2.551-5.695-5.697c0-3.145,2.549-5.693,5.695-5.693 c3.145,0,5.693,2.549,5.693,5.693C77.4,86.557,74.852,89.107,71.707,89.107z"/>
10 </g></svg>
Show file before | Show file after | Hide comments
@@ -0,0 +1,153
1 #include "filebrowser.h"
2 #include "ui_filebrowser.h"
3 #include <QListView>
4 #include <QTreeView>
5
6 FileBrowser::FileBrowser(QWidget *parent) :
7 QDockWidget(parent),
8 ui(new Ui::FileBrowser)
9 {
10 ui->setupUi(this);
11 this->model = new FileSystemModel(this);
12 this->model->setRootPath(QDir::currentPath());
13 this->view = new QTreeView();
14 this->ui->gridLayout->addWidget(this->view,1,0,1,-1);
15 this->view->setModel(this->model);
16 this->cd(model->rootPath());
17 connect(this->view,SIGNAL(clicked(QModelIndex)),this,SLOT(clicked(QModelIndex)));
18 connect(this->view,SIGNAL(doubleClicked(QModelIndex)),this,SLOT(doubleClicked(QModelIndex)));
19 connect(this->ui->ListViewQpb,SIGNAL(clicked()),this,SLOT(changeToListView()));
20 connect(this->ui->TreeViewQpb,SIGNAL(clicked()),this,SLOT(changeToTreeView()));
21 connect(this->ui->parentDirQpb,SIGNAL(clicked()),this,SLOT(parentDir()));
22 view->setSelectionMode(QAbstractItemView::ExtendedSelection);
23 view->setDragEnabled(true);
24 view->setAcceptDrops(true);
25 view->setDropIndicatorShown(true);
26 view->setDragDropMode(QAbstractItemView::DragDrop);
27 this->pathCompleter = new QCompleter(this->model,this);
28 this->ui->pathLineEdit->setCompleter(pathCompleter);
29 this->pathLineEditEnterEditMode(false);
30 }
31
32 FileBrowser::~FileBrowser()
33 {
34 delete ui;
35 }
36
37 void FileBrowser::setNameFilters(const QStringList &filters,bool disables)
38 {
39 this->model->setNameFilters(filters);
40 this->model->setNameFilterDisables(disables);
41 }
42
43 void FileBrowser::changeToTreeView()
44 {
45 this->ui->gridLayout->removeWidget(this->view);
46 delete this->view;
47 this->view = new QTreeView();
48 this->ui->gridLayout->addWidget(this->view,1,0,1,-1);
49 this->view->setModel(this->model);
50 connect(this->view,SIGNAL(clicked(QModelIndex)),this,SLOT(clicked(QModelIndex)));
51 connect(this->view,SIGNAL(doubleClicked(QModelIndex)),this,SLOT(doubleClicked(QModelIndex)));
52 this->cd(model->rootPath());
53 view->setSelectionMode(QAbstractItemView::ExtendedSelection);
54 view->setDragEnabled(true);
55 view->setAcceptDrops(true);
56 view->setDropIndicatorShown(true);
57 }
58
59 void FileBrowser::changeToListView()
60 {
61 this->ui->gridLayout->removeWidget(this->view);
62 delete this->view;
63 this->view = new QListView();
64 this->ui->gridLayout->addWidget(this->view,1,0,1,-1);
65 this->view->setModel(this->model);
66 connect(this->view,SIGNAL(clicked(QModelIndex)),this,SLOT(clicked(QModelIndex)));
67 connect(this->view,SIGNAL(doubleClicked(QModelIndex)),this,SLOT(doubleClicked(QModelIndex)));
68 this->cd(model->rootPath());
69 view->setSelectionMode(QAbstractItemView::ExtendedSelection);
70 view->setDragEnabled(true);
71 view->setAcceptDrops(true);
72 view->setDropIndicatorShown(true);
73 }
74
75 void FileBrowser::clicked(QModelIndex index)
76 {
77 QString file=model->filePath(index);
78 if(QFile::exists(file))
79 emit fileClicked(file);
80 }
81
82 void FileBrowser::doubleClicked(QModelIndex index)
83 {
84 if(model->isDir(index))
85 {
86 this->cd(model->filePath(index));
87 }
88 else
89 {
90 QString file=model->filePath(index);
91 if(QFile::exists(file))
92 emit fileDoubleClicked(file);
93 }
94 }
95
96 void FileBrowser::parentDir()
97 {
98 this->cd(model->rootPath()+"/..");
99 }
100
101 void FileBrowser::cd(const QString &newPath)
102 {
103 model->setRootPath(newPath);
104 this->view->setRootIndex(model->index(model->rootPath()));
105 this->ui->pathLineEdit->setText(model->rootPath());
106 }
107
108
109 void FileBrowser::changeEvent(QEvent *e)
110 {
111 QDockWidget::changeEvent(e);
112 switch (e->type()) {
113 case QEvent::LanguageChange:
114 ui->retranslateUi(this);
115 break;
116 default:
117 break;
118 }
119 }
120
121 void FileBrowser::keyPressEvent(QKeyEvent *e)
122 {
123 switch (e->key())
124 {
125 case Qt::Key_L:
126 if(e->modifiers()==Qt::ControlModifier)
127 {
128 pathLineEditEnterEditMode(true);
129 e->accept();
130 }
131 break;
132 case Qt::Key_Return:
133 pathLineEditEnterEditMode(false);
134 if(QFile::exists(this->ui->pathLineEdit->text()))
135 {
136 this->cd(this->ui->pathLineEdit->text());
137 e->accept();
138 }
139 break;
140 default:
141 break;
142 }
143 if(!e->isAccepted())
144 QDockWidget::keyPressEvent(e);
145 }
146
147 void FileBrowser::pathLineEditEnterEditMode(bool enter)
148 {
149 this->ui->pathLineEdit->setReadOnly(!enter);
150 this->ui->pathLineEdit->setDisabled(!enter);
151 if(enter)
152 this->ui->pathLineEdit->setFocus();
153 }
Show file before | Show file after | Hide comments
@@ -0,0 +1,44
1 #ifndef FILEBROWSER_H
2 #define FILEBROWSER_H
3
4 #include <QDockWidget>
5 #include <QFileSystemModel>
6 #include <QAbstractItemView>
7 #include <filesystemmodel.h>
8 #include <QKeyEvent>
9 #include <QCompleter>
10
11 namespace Ui {
12 class FileBrowser;
13 }
14
15 class FileBrowser : public QDockWidget
16 {
17 Q_OBJECT
18
19 public:
20 explicit FileBrowser(QWidget *parent = 0);
21 ~FileBrowser();
22 void setNameFilters(const QStringList & filters, bool disables=false);
23 signals:
24 void fileClicked(const QString& file);
25 void fileDoubleClicked(const QString& file);
26 private slots:
27 void changeToTreeView();
28 void changeToListView();
29 void clicked(QModelIndex index);
30 void doubleClicked(QModelIndex index);
31 void parentDir();
32 void cd(const QString& newPath);
33 protected:
34 void changeEvent(QEvent *e);
35 void keyPressEvent(QKeyEvent *e);
36 private:
37 void pathLineEditEnterEditMode(bool enter=true);
38 Ui::FileBrowser *ui;
39 FileSystemModel* model;
40 QAbstractItemView* view;
41 QCompleter* pathCompleter;
42 };
43
44 #endif // FILEBROWSER_H
Show file before | Show file after | Hide comments
@@ -0,0 +1,90
1 <?xml version="1.0" encoding="UTF-8"?>
2 <ui version="4.0">
3 <class>FileBrowser</class>
4 <widget class="QDockWidget" name="FileBrowser">
5 <property name="geometry">
6 <rect>
7 <x>0</x>
8 <y>0</y>
9 <width>685</width>
10 <height>469</height>
11 </rect>
12 </property>
13 <property name="windowTitle">
14 <string>DockWidget</string>
15 </property>
16 <widget class="QWidget" name="dockWidgetContents">
17 <layout class="QGridLayout" name="gridLayout">
18 <item row="0" column="2">
19 <spacer name="horizontalSpacer">
20 <property name="orientation">
21 <enum>Qt::Horizontal</enum>
22 </property>
23 <property name="sizeHint" stdset="0">
24 <size>
25 <width>40</width>
26 <height>20</height>
27 </size>
28 </property>
29 </spacer>
30 </item>
31 <item row="0" column="0">
32 <widget class="QPushButton" name="parentDirQpb">
33 <property name="text">
34 <string/>
35 </property>
36 <property name="icon">
37 <iconset resource="../../../resources/qlop.qrc">
38 <normaloff>:/img/Gnome-go-up.svg</normaloff>:/img/Gnome-go-up.svg</iconset>
39 </property>
40 </widget>
41 </item>
42 <item row="0" column="4">
43 <widget class="QPushButton" name="ListViewQpb">
44 <property name="text">
45 <string/>
46 </property>
47 <property name="icon">
48 <iconset resource="../../../resources/qlop.qrc">
49 <normaloff>:/img/ListView.svg</normaloff>:/img/ListView.svg</iconset>
50 </property>
51 </widget>
52 </item>
53 <item row="0" column="3">
54 <widget class="QPushButton" name="TreeViewQpb">
55 <property name="text">
56 <string/>
57 </property>
58 <property name="icon">
59 <iconset resource="../../../resources/qlop.qrc">
60 <normaloff>:/img/TreeView.svg</normaloff>:/img/TreeView.svg</iconset>
61 </property>
62 <property name="checkable">
63 <bool>false</bool>
64 </property>
65 <property name="checked">
66 <bool>false</bool>
67 </property>
68 <property name="default">
69 <bool>false</bool>
70 </property>
71 <property name="flat">
72 <bool>false</bool>
73 </property>
74 </widget>
75 </item>
76 <item row="0" column="1">
77 <widget class="QLineEdit" name="pathLineEdit">
78 <property name="readOnly">
79 <bool>true</bool>
80 </property>
81 </widget>
82 </item>
83 </layout>
84 </widget>
85 </widget>
86 <resources>
87 <include location="../../../resources/qlop.qrc"/>
88 </resources>
89 <connections/>
90 </ui>
Show file before | Show file after | Hide comments
@@ -0,0 +1,25
1 #include "filesystemmodel.h"
2 FileSystemModel::FileSystemModel(QObject *parent):QFileSystemModel(parent)
3 {
4 this->setReadOnly(false);
5 }
6
7 FileSystemModel::~FileSystemModel()
8 {
9 }
10
11 Qt::DropActions FileSystemModel::supportedDropActions() const
12 {
13 return Qt::MoveAction;
14 }
15
16
17 Qt::ItemFlags FileSystemModel::flags(const QModelIndex &index) const
18 {
19 Qt::ItemFlags defaultFlags = QFileSystemModel::flags(index);
20 defaultFlags &= ~Qt::ItemIsEditable;
21 if (index.isValid())
22 return Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled | defaultFlags;
23 else
24 return Qt::ItemIsDropEnabled | defaultFlags;
25 }
Show file before | Show file after | Hide comments
@@ -0,0 +1,16
1 #ifndef FILESYSTEMMODEL_H
2 #define FILESYSTEMMODEL_H
3
4 #include <QObject>
5 #include <QFileSystemModel>
6
7 class FileSystemModel : public QFileSystemModel
8 {
9 public:
10 FileSystemModel(QObject* parent=0);
11 ~FileSystemModel();
12 Qt::DropActions supportedDropActions() const;
13 Qt::ItemFlags flags(const QModelIndex &index) const;
14 };
15
16 #endif // FILESYSTEMMODEL_H
Show file before | Show file after | Hide comments
@@ -50,7 +50,9 SOURCES += src/main.cpp\
50 src/Core/qlopdata.cpp \
50 src/Core/qlopdata.cpp \
51 src/Core/Widgets/PyWdgt/pythonconsole.cpp \
51 src/Core/Widgets/PyWdgt/pythonconsole.cpp \
52 src/Core/Widgets/PyWdgt/pythonqtscriptingconsoledandd.cpp \
52 src/Core/Widgets/PyWdgt/pythonqtscriptingconsoledandd.cpp \
53 src/QCustomPlot/qcpdocumentobject.cpp
53 src/QCustomPlot/qcpdocumentobject.cpp \
54 src/Core/Widgets/filebrowser.cpp \
55 src/Core/Widgets/filesystemmodel.cpp
54
56
55 HEADERS += src/mainwindow.h \
57 HEADERS += src/mainwindow.h \
56 src/SocExplorerPlot.h \
58 src/SocExplorerPlot.h \
@@ -77,7 +79,9 HEADERS += src/mainwindow.h \
77 src/Core/Widgets/PyWdgt/pythonqtscriptingconsoledandd.h \
79 src/Core/Widgets/PyWdgt/pythonqtscriptingconsoledandd.h \
78 src/Core/qlop.h \
80 src/Core/qlop.h \
79 src/Core/pyqlop.h \
81 src/Core/pyqlop.h \
80 src/QCustomPlot/qcpdocumentobject.h
82 src/QCustomPlot/qcpdocumentobject.h \
83 src/Core/Widgets/filebrowser.h \
84 src/Core/Widgets/filesystemmodel.h
81
85
82 FORMS += src/mainwindow.ui \
86 FORMS += src/mainwindow.ui \
83 src/folderview.ui \
87 src/folderview.ui \
@@ -85,7 +89,8 FORMS += src/mainwindow.ui \
85 src/Core/Widgets/downloadhistoryelement.ui \
89 src/Core/Widgets/downloadhistoryelement.ui \
86 src/Cassini/cassinidatadownloader.ui \
90 src/Cassini/cassinidatadownloader.ui \
87 src/Cassini/cassiniindexfileviewer.ui \
91 src/Cassini/cassiniindexfileviewer.ui \
88 src/Cassini/cassinitoolsgui.ui
92 src/Cassini/cassinitoolsgui.ui \
93 src/Core/Widgets/filebrowser.ui
89
94
90 RESOURCES += \
95 RESOURCES += \
91 resources/qlop.qrc
96 resources/qlop.qrc
Show file before | Show file after | Hide comments
@@ -2,5 +2,8
2 <qresource prefix="/img">
2 <qresource prefix="/img">
3 <file>Gnome-view-refresh.svg</file>
3 <file>Gnome-view-refresh.svg</file>
4 <file>Gnome-list-add.svg</file>
4 <file>Gnome-list-add.svg</file>
5 <file>ListView.svg</file>
6 <file>TreeView.svg</file>
7 <file>Gnome-go-up.svg</file>
5 </qresource>
8 </qresource>
6 </RCC>
9 </RCC>
Show file before | Show file after | Hide comments
@@ -1,12 +1,13
1 #include "cassinitools.h"
1 #include "cassinitools.h"
2 #include <qlopplots.h>
2 #include <qlopplots.h>
3 #include <QPen>
3 #include <QPen>
4 #include <QAction>
4
5
5 CassiniTools* CassiniTools::_self=NULL;
6 CassiniTools* CassiniTools::_self=NULL;
6 QDockWidget* CassiniTools::m_gui=NULL;
7 QDockWidget* CassiniTools::m_gui=NULL;
7 CassiniToolsGUI* CassiniTools::m_CassiniToolsGUI=NULL;
8 CassiniToolsGUI* CassiniTools::m_CassiniToolsGUI=NULL;
8 CassiniDataFile* CassiniTools::m_dataFile=NULL;
9 CassiniDataFile* CassiniTools::m_dataFile=NULL;
9
10 int CassiniTools::m_defaultPlot=-1;
10
11
11 Qt::GlobalColor QLopColours[]= {Qt::black,
12 Qt::GlobalColor QLopColours[]= {Qt::black,
12 Qt::red,
13 Qt::red,
@@ -44,6 +45,22 CassiniTools::~CassiniTools()
44 delete m_gui;
45 delete m_gui;
45 }
46 }
46
47
48 void CassiniTools::makePlot()
49 {
50 m_defaultPlot = QLopPlots::addPlot();
51 SocExplorerPlot* plot=QLopPlots::getPlot(m_defaultPlot);
52 if(plot)
53 {
54 plot->setTitle(_self->m_serviceName + " plot");
55 plot->setXaxisTickLabelType(QCPAxis::ltDateTime);
56 plot->setXaxisDateTimeFormat("hh:mm:ss.zzz");
57 plot->setContextMenuPolicy(Qt::ActionsContextMenu);
58 QAction* action=new QAction("export view",_self);
59 plot->addAction(action);
60 QObject::connect(action,SIGNAL(triggered()),_self,SLOT(export_view()));
61 }
62 }
63
47 void CassiniTools::init(bool noGUI, QObject *parent)
64 void CassiniTools::init(bool noGUI, QObject *parent)
48 {
65 {
49 if(Q_UNLIKELY(_self==NULL))
66 if(Q_UNLIKELY(_self==NULL))
@@ -69,13 +86,36 void CassiniTools::plotFile(const QStrin
69 if(!m_dataFile->isRunning())
86 if(!m_dataFile->isRunning())
70 {
87 {
71 m_dataFile->parseFile(File);
88 m_dataFile->parseFile(File);
72 QLopPlots::getPlot()->setTitle(File);
89 // TODO fixme
90 SocExplorerPlot* plot = QLopPlots::getPlot(m_defaultPlot);
91 if(plot==NULL)
92 {
93 makePlot();
94 plot = QLopPlots::getPlot(m_defaultPlot);
95 }
96 if(plot)
97 plot->setTitle(File);
73 }
98 }
74 }
99 }
75
100
76 void CassiniTools::plot_TAB_File(const QString &fileName)
101 void CassiniTools::plot_TAB_File(const QString &fileName)
77 {
102 {
103 //TODO fix: accent not accepted
104 plotFile(fileName);
105 }
78
106
107 void CassiniTools::export_view()
108 {
109 SocExplorerPlot* plot = QLopPlots::getPlot(m_defaultPlot);
110 if(plot==NULL)
111 {
112 makePlot();
113 plot = QLopPlots::getPlot(m_defaultPlot);
114 }
115 if(plot)
116 {
117 QString fileName = QFileDialog::getSaveFileName();
118 }
79 }
119 }
80
120
81 QDockWidget *CassiniTools::getGUI()
121 QDockWidget *CassiniTools::getGUI()
@@ -98,19 +138,28 const QString &CassiniTools::serviceName
98
138
99 void CassiniTools::dataReady(QLopDataList data)
139 void CassiniTools::dataReady(QLopDataList data)
100 {
140 {
101 QLopPlots::getPlot()->removeAllGraphs();
141 SocExplorerPlot* plot = QLopPlots::getPlot(m_defaultPlot);
142 if(plot==NULL)
143 {
144 makePlot();
145 plot = QLopPlots::getPlot(m_defaultPlot);
146 }
147 if(plot)
148 {
149 plot->removeAllGraphs();
102 for(int i=0;i<data.count();i++)
150 for(int i=0;i<data.count();i++)
103 {
151 {
104 QLopPlots::getPlot()->addGraph();
152 plot->addGraph();
105 QLopPlots::getPlot()->setAdaptativeSampling(i,true);
153 plot->setAdaptativeSampling(i,true);
106 QLopPlots::getPlot()->setUseFastVector(i,true);
154 plot->setUseFastVector(i,true);
107 QPen pen = QLopPlots::getPlot()->getGraphPen(i);
155 QPen pen = plot->getGraphPen(i);
108 pen.setColor(QLopColours[i%QLopColoursCount]);
156 pen.setColor(QLopColours[i%QLopColoursCount]);
109 QLopPlots::getPlot()->setGraphPen(i,pen);
157 plot->setGraphPen(i,pen);
110 QLopPlots::getPlot()->setGraphName(i,data.at(i)->name+"("+data.at(i)->unit+")");
158 plot->setGraphName(i,data.at(i)->name+"("+data.at(i)->unit+")");
111 QLopPlots::getPlot()->setGraphData(i,data.at(i)->data,false);
159 plot->setGraphData(i,data.at(i)->data,false);
112 }
160 }
113 QLopPlots::getPlot()->rescaleAxis();
161 plot->rescaleAxis();
114 QLopPlots::getPlot()->replot();
162 plot->replot();
163 }
115 }
164 }
116
165
Show file before | Show file after | Hide comments
@@ -7,6 +7,7
7 #include <cassinitoolsgui.h>
7 #include <cassinitoolsgui.h>
8 #include <cassinidatafile.h>
8 #include <cassinidatafile.h>
9 #include <qlopdata.h>
9 #include <qlopdata.h>
10 #include <SocExplorerPlot.h>
10
11
11 class CassiniTools: public QLopService
12 class CassiniTools: public QLopService
12 {
13 {
@@ -16,8 +17,10 private:
16 static QDockWidget* m_gui;
17 static QDockWidget* m_gui;
17 static CassiniToolsGUI* m_CassiniToolsGUI;
18 static CassiniToolsGUI* m_CassiniToolsGUI;
18 static CassiniDataFile* m_dataFile;
19 static CassiniDataFile* m_dataFile;
20 static int m_defaultPlot;
19 CassiniTools(bool noGUI=false, QObject *parent=0);
21 CassiniTools(bool noGUI=false, QObject *parent=0);
20 ~CassiniTools();
22 ~CassiniTools();
23 static void makePlot();
21 public:
24 public:
22 static void init(bool noGUI=false,QObject *parent = 0);
25 static void init(bool noGUI=false,QObject *parent = 0);
23 static CassiniTools *self();
26 static CassiniTools *self();
@@ -28,8 +31,10 public:
28 static void plotFile(const QString &File);
31 static void plotFile(const QString &File);
29 public slots:
32 public slots:
30 void plot_TAB_File(const QString& fileName);
33 void plot_TAB_File(const QString& fileName);
34 void export_view();
31 private slots:
35 private slots:
32 void dataReady(QLopDataList data);
36 void dataReady(QLopDataList data);
33 };
37 };
34
38
35 #endif // CASSINITOOLS_H
39 #endif // CASSINITOOLS_H
40
Show file before | Show file after | Hide comments
@@ -17,16 +17,17 CassiniToolsGUI::~CassiniToolsGUI()
17
17
18 void CassiniToolsGUI::addFolderView()
18 void CassiniToolsGUI::addFolderView()
19 {
19 {
20 this->folderViews.append(new FolderView());
20 this->fileBrowsers.append(new FileBrowser());
21 this->ui->folderViews->addDockWidget(Qt::TopDockWidgetArea,this->folderViews.last());
21 this->ui->folderViews->addDockWidget(Qt::TopDockWidgetArea,this->fileBrowsers.last());
22 this->folderViews.last()->setWindowTitle( QString("Folder View %1").arg(this->folderViews.length()));
22 this->fileBrowsers.last()->setWindowTitle( QString("Browser %1").arg(this->fileBrowsers.length()));
23 this->folderViews.last()->setAllowedAreas(Qt::AllDockWidgetAreas);
23 this->fileBrowsers.last()->setAllowedAreas(Qt::AllDockWidgetAreas);
24 connect(this->folderViews.last(),SIGNAL(itemActivated(QString)),this,SLOT(plotFile(QString)));
24 this->fileBrowsers.last()->setNameFilters(QStringList()<<"*.TAB");
25 connect(this->fileBrowsers.last(),SIGNAL(fileDoubleClicked(QString)),this,SLOT(plotFile(QString)));
25 }
26 }
26
27
27 void CassiniToolsGUI::plotFile(const QString &File)
28 void CassiniToolsGUI::plotFile(const QString &File)
28 {
29 {
29 CassiniTools::plotFile(File);
30 CassiniTools::plotFile(File);
30 }
31 }
31
32
32 void CassiniToolsGUI::changeEvent(QEvent *e)
33 void CassiniToolsGUI::changeEvent(QEvent *e)
Show file before | Show file after | Hide comments
@@ -3,6 +3,7
3
3
4 #include <QWidget>
4 #include <QWidget>
5 #include <folderview.h>
5 #include <folderview.h>
6 #include <filebrowser.h>
6
7
7 namespace Ui {
8 namespace Ui {
8 class CassiniToolsGUI;
9 class CassiniToolsGUI;
@@ -24,7 +25,7 private slots:
24 void plotFile(const QString &File);
25 void plotFile(const QString &File);
25 private:
26 private:
26 Ui::CassiniToolsGUI *ui;
27 Ui::CassiniToolsGUI *ui;
27 QList<FolderView*> folderViews;
28 QList<FileBrowser*> fileBrowsers;
28 };
29 };
29
30
30 #endif // CASSINITOOLSGUI_H
31 #endif // CASSINITOOLSGUI_H
Show file before | Show file after | Hide comments
@@ -1,8 +1,12
1 #include "qlopplots.h"
1 #include "qlopplots.h"
2 #include <QMainWindow>
2
3
3 QLopPlots* QLopPlots::_self=NULL;
4 QLopPlots* QLopPlots::_self=NULL;
4 SocExplorerPlot* QLopPlots::m_SocExplorerPlot=NULL;
5 SocExplorerPlot* QLopPlots::m_LastPlot=NULL;
5 QDockWidget* QLopPlots::m_gui=NULL;
6 QDockWidget* QLopPlots::m_gui=NULL;
7 QHash<int,SocExplorerPlot*>* QLopPlots::m_plots=NULL;
8 toolBarContainer* QLopPlots::m_DocContainer=NULL;
9
6
10
7 #define _INIT() if(Q_UNLIKELY(_self==NULL)){init();}
11 #define _INIT() if(Q_UNLIKELY(_self==NULL)){init();}
8
12
@@ -11,6 +15,7 QLopPlots::QLopPlots(bool noGUI,QObject
11 {
15 {
12 m_noGui = noGUI;
16 m_noGui = noGUI;
13 m_serviceName = "QLopPlots";
17 m_serviceName = "QLopPlots";
18 m_plots = new QHash<int,SocExplorerPlot*>();
14 }
19 }
15
20
16 QLopPlots::~QLopPlots()
21 QLopPlots::~QLopPlots()
@@ -18,6 +23,19 QLopPlots::~QLopPlots()
18
23
19 }
24 }
20
25
26 int QLopPlots::getPlotID()
27 {
28 _INIT();
29 for(int i=0;i<32768;i++)
30 {
31 if(!m_plots->contains(i))
32 {
33 return i;
34 }
35 }
36 return -1;
37 }
38
21 void QLopPlots::init(bool noGUI, QObject *parent)
39 void QLopPlots::init(bool noGUI, QObject *parent)
22 {
40 {
23 if(Q_UNLIKELY(_self==NULL))
41 if(Q_UNLIKELY(_self==NULL))
@@ -32,17 +50,71 QLopPlots *QLopPlots::self()
32 return _self;
50 return _self;
33 }
51 }
34
52
35 SocExplorerPlot *QLopPlots::getPlot()
53 SocExplorerPlot *QLopPlots::getPlot(int plotID)
36 {
54 {
37 _INIT();
55 _INIT();
38 if(!_self->m_noGui && (m_gui==NULL))
56 if(!_self->m_noGui && (m_gui==NULL))
39 {
57 {
40 m_gui=new QDockWidget("Plots");
58 m_gui=new QDockWidget("Plots");
41 m_SocExplorerPlot = new SocExplorerPlot();
59 m_DocContainer = new toolBarContainer();
42 m_gui->setWidget(m_SocExplorerPlot);
60 // m_SocExplorerPlot = new SocExplorerPlot();
61 m_gui->setWidget(m_DocContainer);
43 m_gui->setFeatures(QDockWidget::DockWidgetMovable|QDockWidget::DockWidgetFloatable);
62 m_gui->setFeatures(QDockWidget::DockWidgetMovable|QDockWidget::DockWidgetFloatable);
44 }
63 }
45 return m_SocExplorerPlot;
64 if(m_plots->contains(plotID))
65 {
66 return m_plots->value(plotID);
67 }
68 if(plotID==-1)
69 {
70 return m_LastPlot;
71 }
72 return NULL;
73 }
74
75 int QLopPlots::addPlot()
76 {
77 _INIT();
78 int pid=getPlotID();
79 if(pid!=-1)
80 {
81 SocExplorerPlot* plot=new SocExplorerPlot();
82 m_plots->insert(pid,plot);
83 QDockWidget* dock = new QDockWidget();
84 dock->setWidget(plot);
85 dock->setAllowedAreas(Qt::AllDockWidgetAreas);
86 m_DocContainer->addDockWidget(Qt::TopDockWidgetArea,dock);
87 m_LastPlot=plot;
88 QObject::connect(plot,SIGNAL(titleChanged(QString)),dock,SLOT(setWindowTitle(QString)));
89 plot->setTitle(QString("Plot %1").arg(pid));
90 }
91 return pid;
92 }
93
94 bool QLopPlots::removePlot(int plotID)
95 {
96 _INIT();
97 if(m_plots->contains(plotID))
98 {
99 SocExplorerPlot* plot=m_plots->value(plotID);
100 m_plots->remove(plotID);
101 QDockWidget* dock=(QDockWidget*)plot->parentWidget();
102 m_DocContainer->removeDockWidget(dock);
103 if(plot==m_LastPlot)
104 {
105 //TODO may cause troubles...
106 m_LastPlot = NULL;
107 }
108 if(dock!=NULL)
109 {
110 delete dock;
111 }
112 if(plot!=NULL)
113 {
114 delete plot;
115 }
116 }
117 return false;
46 }
118 }
47
119
48 QDockWidget *QLopPlots::getGUI()
120 QDockWidget *QLopPlots::getGUI()
@@ -50,8 +122,9 QDockWidget *QLopPlots::getGUI()
50 if(!m_noGui && (m_gui==NULL))
122 if(!m_noGui && (m_gui==NULL))
51 {
123 {
52 m_gui=new QDockWidget("Plots");
124 m_gui=new QDockWidget("Plots");
53 m_SocExplorerPlot = new SocExplorerPlot();
125 m_DocContainer = new toolBarContainer();
54 m_gui->setWidget(m_SocExplorerPlot);
126 // m_SocExplorerPlot = new SocExplorerPlot();
127 m_gui->setWidget(m_DocContainer);
55 m_gui->setFeatures(QDockWidget::DockWidgetMovable|QDockWidget::DockWidgetFloatable);
128 m_gui->setFeatures(QDockWidget::DockWidgetMovable|QDockWidget::DockWidgetFloatable);
56 }
129 }
57 return m_gui;
130 return m_gui;
@@ -62,8 +135,18 const QString &QLopPlots::serviceName()
62 return m_serviceName;
135 return m_serviceName;
63 }
136 }
64
137
65 SocExplorerPlot *QLopPlots::get_plot()
138 SocExplorerPlot *QLopPlots::get_plot(int plotID)
66 {
139 {
67 return getPlot();
140 return getPlot(plotID);
68 }
141 }
69
142
143 int QLopPlots::add_plot()
144 {
145 return addPlot();
146 }
147
148 bool QLopPlots::remove_plot(int plotID)
149 {
150 return removePlot(plotID);
151 }
152
Show file before | Show file after | Hide comments
@@ -5,26 +5,36
5 #include <QWidget>
5 #include <QWidget>
6 #include <qlopservice.h>
6 #include <qlopservice.h>
7 #include <SocExplorerPlot.h>
7 #include <SocExplorerPlot.h>
8 #include <QList>
9 #include <QHash>
10 #include <toolbarcontainer.h>
8
11
9 class QLopPlots: public QLopService
12 class QLopPlots: public QLopService
10 {
13 {
11 Q_OBJECT
14 Q_OBJECT
12 private:
15 private:
13 static QLopPlots* _self;
16 static QLopPlots* _self;
14 static SocExplorerPlot* m_SocExplorerPlot;
17 static SocExplorerPlot* m_LastPlot;
18 static QHash<int,SocExplorerPlot*>* m_plots;
15 static QDockWidget* m_gui;
19 static QDockWidget* m_gui;
20 static toolBarContainer* m_DocContainer;
16 QLopPlots(bool noGUI=false,QObject *parent = 0);
21 QLopPlots(bool noGUI=false,QObject *parent = 0);
17 ~QLopPlots();
22 ~QLopPlots();
23 static int getPlotID();
18
24
19 public:
25 public:
20 static void init(bool noGUI=false,QObject *parent = 0);
26 static void init(bool noGUI=false,QObject *parent = 0);
21 static QLopPlots *self();
27 static QLopPlots *self();
22 static SocExplorerPlot* getPlot();
28 static SocExplorerPlot* getPlot(int plotID=-1);
29 static int addPlot();
30 static bool removePlot(int plotID);
23 // QLopService methodes
31 // QLopService methodes
24 QDockWidget* getGUI();
32 QDockWidget* getGUI();
25 const QString& serviceName();
33 const QString& serviceName();
26 public slots:
34 public slots:
27 SocExplorerPlot* get_plot();
35 SocExplorerPlot* get_plot(int plotID);
36 int add_plot();
37 bool remove_plot(int plotID);
28 public:
38 public:
29 };
39 };
30
40
Show file before | Show file after | Hide comments
@@ -5,6 +5,9
5 #include "qlopservice.h"
5 #include "qlopservice.h"
6 #include "qlopdata.h"
6 #include "qlopdata.h"
7 #include "SocExplorerPlot.h"
7 #include "SocExplorerPlot.h"
8 #include "filebrowser.h"
9 #include "qlopdata.h"
10 #include "qcustomplot.h"
8
11
9 #endif // PYQLOP
12 #endif // PYQLOP
10
13
Show file before | Show file after | Hide comments
This diff has been collapsed as it changes many lines, (9412 lines changed) Show them Hide them
@@ -3,40 +3,9452
3 #include <PythonQtMethodInfo.h>
3 #include <PythonQtMethodInfo.h>
4 #include <PythonQtSignalReceiver.h>
4 #include <PythonQtSignalReceiver.h>
5 #include <QVariant>
5 #include <QVariant>
6 #include <qabstractitemmodel.h>
6 #include <qaction.h>
7 #include <qaction.h>
7 #include <qbackingstore.h>
8 #include <qbackingstore.h>
8 #include <qbitmap.h>
9 #include <qbitmap.h>
10 #include <qbrush.h>
9 #include <qbytearray.h>
11 #include <qbytearray.h>
12 #include <qcolor.h>
10 #include <qcoreevent.h>
13 #include <qcoreevent.h>
11 #include <qcursor.h>
14 #include <qcursor.h>
15 #include <qcustomplot.h>
12 #include <qdockwidget.h>
16 #include <qdockwidget.h>
13 #include <qevent.h>
17 #include <qevent.h>
14 #include <qfont.h>
18 #include <qfont.h>
19 #include <qfontinfo.h>
20 #include <qfontmetrics.h>
21 #include <qglyphrun.h>
15 #include <qgraphicseffect.h>
22 #include <qgraphicseffect.h>
16 #include <qgraphicsproxywidget.h>
23 #include <qgraphicsproxywidget.h>
17 #include <qicon.h>
24 #include <qicon.h>
25 #include <qimage.h>
18 #include <qkeysequence.h>
26 #include <qkeysequence.h>
19 #include <qlayout.h>
27 #include <qlayout.h>
28 #include <qline.h>
20 #include <qlist.h>
29 #include <qlist.h>
21 #include <qlocale.h>
30 #include <qlocale.h>
31 #include <qlopdata.h>
22 #include <qmargins.h>
32 #include <qmargins.h>
33 #include <qmatrix.h>
23 #include <qmetaobject.h>
34 #include <qmetaobject.h>
24 #include <qobject.h>
35 #include <qobject.h>
25 #include <qpaintdevice.h>
36 #include <qpaintdevice.h>
26 #include <qpaintengine.h>
37 #include <qpaintengine.h>
27 #include <qpainter.h>
38 #include <qpainter.h>
39 #include <qpainterpath.h>
28 #include <qpalette.h>
40 #include <qpalette.h>
29 #include <qpen.h>
41 #include <qpen.h>
42 #include <qpicture.h>
30 #include <qpixmap.h>
43 #include <qpixmap.h>
31 #include <qpoint.h>
44 #include <qpoint.h>
45 #include <qpolygon.h>
32 #include <qrect.h>
46 #include <qrect.h>
33 #include <qregion.h>
47 #include <qregion.h>
34 #include <qsize.h>
48 #include <qsize.h>
35 #include <qsizepolicy.h>
49 #include <qsizepolicy.h>
50 #include <qstatictext.h>
51 #include <qstringlist.h>
36 #include <qstyle.h>
52 #include <qstyle.h>
53 #include <qstyleoption.h>
54 #include <qtextoption.h>
55 #include <qtransform.h>
56 #include <qvector.h>
37 #include <qwidget.h>
57 #include <qwidget.h>
38 #include <qwindow.h>
58 #include <qwindow.h>
39
59
60 PythonQtShell_FileBrowser::~PythonQtShell_FileBrowser() {
61 PythonQtPrivate* priv = PythonQt::priv();
62 if (priv) { priv->shellClassDeleted(this); }
63 }
64 void PythonQtShell_FileBrowser::actionEvent(QActionEvent* arg__1)
65 {
66 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
67 static PyObject* name = PyString_FromString("actionEvent");
68 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
69 if (obj) {
70 static const char* argumentList[] ={"" , "QActionEvent*"};
71 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
72 void* args[2] = {NULL, (void*)&arg__1};
73 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
74 if (result) { Py_DECREF(result); }
75 Py_DECREF(obj);
76 return;
77 } else {
78 PyErr_Clear();
79 }
80 }
81 FileBrowser::actionEvent(arg__1);
82 }
83 void PythonQtShell_FileBrowser::changeEvent(QEvent* e0)
84 {
85 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
86 static PyObject* name = PyString_FromString("changeEvent");
87 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
88 if (obj) {
89 static const char* argumentList[] ={"" , "QEvent*"};
90 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
91 void* args[2] = {NULL, (void*)&e0};
92 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
93 if (result) { Py_DECREF(result); }
94 Py_DECREF(obj);
95 return;
96 } else {
97 PyErr_Clear();
98 }
99 }
100 FileBrowser::changeEvent(e0);
101 }
102 void PythonQtShell_FileBrowser::childEvent(QChildEvent* arg__1)
103 {
104 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
105 static PyObject* name = PyString_FromString("childEvent");
106 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
107 if (obj) {
108 static const char* argumentList[] ={"" , "QChildEvent*"};
109 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
110 void* args[2] = {NULL, (void*)&arg__1};
111 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
112 if (result) { Py_DECREF(result); }
113 Py_DECREF(obj);
114 return;
115 } else {
116 PyErr_Clear();
117 }
118 }
119 FileBrowser::childEvent(arg__1);
120 }
121 void PythonQtShell_FileBrowser::closeEvent(QCloseEvent* event0)
122 {
123 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
124 static PyObject* name = PyString_FromString("closeEvent");
125 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
126 if (obj) {
127 static const char* argumentList[] ={"" , "QCloseEvent*"};
128 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
129 void* args[2] = {NULL, (void*)&event0};
130 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
131 if (result) { Py_DECREF(result); }
132 Py_DECREF(obj);
133 return;
134 } else {
135 PyErr_Clear();
136 }
137 }
138 FileBrowser::closeEvent(event0);
139 }
140 void PythonQtShell_FileBrowser::contextMenuEvent(QContextMenuEvent* arg__1)
141 {
142 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
143 static PyObject* name = PyString_FromString("contextMenuEvent");
144 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
145 if (obj) {
146 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
147 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
148 void* args[2] = {NULL, (void*)&arg__1};
149 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
150 if (result) { Py_DECREF(result); }
151 Py_DECREF(obj);
152 return;
153 } else {
154 PyErr_Clear();
155 }
156 }
157 FileBrowser::contextMenuEvent(arg__1);
158 }
159 void PythonQtShell_FileBrowser::customEvent(QEvent* arg__1)
160 {
161 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
162 static PyObject* name = PyString_FromString("customEvent");
163 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
164 if (obj) {
165 static const char* argumentList[] ={"" , "QEvent*"};
166 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
167 void* args[2] = {NULL, (void*)&arg__1};
168 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
169 if (result) { Py_DECREF(result); }
170 Py_DECREF(obj);
171 return;
172 } else {
173 PyErr_Clear();
174 }
175 }
176 FileBrowser::customEvent(arg__1);
177 }
178 int PythonQtShell_FileBrowser::devType() const
179 {
180 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
181 static PyObject* name = PyString_FromString("devType");
182 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
183 if (obj) {
184 static const char* argumentList[] ={"int"};
185 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
186 int returnValue;
187 void* args[1] = {NULL};
188 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
189 if (result) {
190 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
191 if (args[0]!=&returnValue) {
192 if (args[0]==NULL) {
193 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
194 } else {
195 returnValue = *((int*)args[0]);
196 }
197 }
198 }
199 if (result) { Py_DECREF(result); }
200 Py_DECREF(obj);
201 return returnValue;
202 } else {
203 PyErr_Clear();
204 }
205 }
206 return FileBrowser::devType();
207 }
208 void PythonQtShell_FileBrowser::dragEnterEvent(QDragEnterEvent* arg__1)
209 {
210 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
211 static PyObject* name = PyString_FromString("dragEnterEvent");
212 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
213 if (obj) {
214 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
215 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
216 void* args[2] = {NULL, (void*)&arg__1};
217 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
218 if (result) { Py_DECREF(result); }
219 Py_DECREF(obj);
220 return;
221 } else {
222 PyErr_Clear();
223 }
224 }
225 FileBrowser::dragEnterEvent(arg__1);
226 }
227 void PythonQtShell_FileBrowser::dragLeaveEvent(QDragLeaveEvent* arg__1)
228 {
229 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
230 static PyObject* name = PyString_FromString("dragLeaveEvent");
231 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
232 if (obj) {
233 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
234 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
235 void* args[2] = {NULL, (void*)&arg__1};
236 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
237 if (result) { Py_DECREF(result); }
238 Py_DECREF(obj);
239 return;
240 } else {
241 PyErr_Clear();
242 }
243 }
244 FileBrowser::dragLeaveEvent(arg__1);
245 }
246 void PythonQtShell_FileBrowser::dragMoveEvent(QDragMoveEvent* arg__1)
247 {
248 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
249 static PyObject* name = PyString_FromString("dragMoveEvent");
250 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
251 if (obj) {
252 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
253 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
254 void* args[2] = {NULL, (void*)&arg__1};
255 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
256 if (result) { Py_DECREF(result); }
257 Py_DECREF(obj);
258 return;
259 } else {
260 PyErr_Clear();
261 }
262 }
263 FileBrowser::dragMoveEvent(arg__1);
264 }
265 void PythonQtShell_FileBrowser::dropEvent(QDropEvent* arg__1)
266 {
267 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
268 static PyObject* name = PyString_FromString("dropEvent");
269 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
270 if (obj) {
271 static const char* argumentList[] ={"" , "QDropEvent*"};
272 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
273 void* args[2] = {NULL, (void*)&arg__1};
274 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
275 if (result) { Py_DECREF(result); }
276 Py_DECREF(obj);
277 return;
278 } else {
279 PyErr_Clear();
280 }
281 }
282 FileBrowser::dropEvent(arg__1);
283 }
284 void PythonQtShell_FileBrowser::enterEvent(QEvent* arg__1)
285 {
286 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
287 static PyObject* name = PyString_FromString("enterEvent");
288 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
289 if (obj) {
290 static const char* argumentList[] ={"" , "QEvent*"};
291 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
292 void* args[2] = {NULL, (void*)&arg__1};
293 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
294 if (result) { Py_DECREF(result); }
295 Py_DECREF(obj);
296 return;
297 } else {
298 PyErr_Clear();
299 }
300 }
301 FileBrowser::enterEvent(arg__1);
302 }
303 bool PythonQtShell_FileBrowser::event(QEvent* event0)
304 {
305 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
306 static PyObject* name = PyString_FromString("event");
307 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
308 if (obj) {
309 static const char* argumentList[] ={"bool" , "QEvent*"};
310 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
311 bool returnValue;
312 void* args[2] = {NULL, (void*)&event0};
313 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
314 if (result) {
315 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
316 if (args[0]!=&returnValue) {
317 if (args[0]==NULL) {
318 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
319 } else {
320 returnValue = *((bool*)args[0]);
321 }
322 }
323 }
324 if (result) { Py_DECREF(result); }
325 Py_DECREF(obj);
326 return returnValue;
327 } else {
328 PyErr_Clear();
329 }
330 }
331 return FileBrowser::event(event0);
332 }
333 bool PythonQtShell_FileBrowser::eventFilter(QObject* arg__1, QEvent* arg__2)
334 {
335 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
336 static PyObject* name = PyString_FromString("eventFilter");
337 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
338 if (obj) {
339 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
340 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
341 bool returnValue;
342 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
343 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
344 if (result) {
345 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
346 if (args[0]!=&returnValue) {
347 if (args[0]==NULL) {
348 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
349 } else {
350 returnValue = *((bool*)args[0]);
351 }
352 }
353 }
354 if (result) { Py_DECREF(result); }
355 Py_DECREF(obj);
356 return returnValue;
357 } else {
358 PyErr_Clear();
359 }
360 }
361 return FileBrowser::eventFilter(arg__1, arg__2);
362 }
363 void PythonQtShell_FileBrowser::focusInEvent(QFocusEvent* arg__1)
364 {
365 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
366 static PyObject* name = PyString_FromString("focusInEvent");
367 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
368 if (obj) {
369 static const char* argumentList[] ={"" , "QFocusEvent*"};
370 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
371 void* args[2] = {NULL, (void*)&arg__1};
372 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
373 if (result) { Py_DECREF(result); }
374 Py_DECREF(obj);
375 return;
376 } else {
377 PyErr_Clear();
378 }
379 }
380 FileBrowser::focusInEvent(arg__1);
381 }
382 bool PythonQtShell_FileBrowser::focusNextPrevChild(bool next0)
383 {
384 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
385 static PyObject* name = PyString_FromString("focusNextPrevChild");
386 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
387 if (obj) {
388 static const char* argumentList[] ={"bool" , "bool"};
389 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
390 bool returnValue;
391 void* args[2] = {NULL, (void*)&next0};
392 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
393 if (result) {
394 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
395 if (args[0]!=&returnValue) {
396 if (args[0]==NULL) {
397 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
398 } else {
399 returnValue = *((bool*)args[0]);
400 }
401 }
402 }
403 if (result) { Py_DECREF(result); }
404 Py_DECREF(obj);
405 return returnValue;
406 } else {
407 PyErr_Clear();
408 }
409 }
410 return FileBrowser::focusNextPrevChild(next0);
411 }
412 void PythonQtShell_FileBrowser::focusOutEvent(QFocusEvent* arg__1)
413 {
414 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
415 static PyObject* name = PyString_FromString("focusOutEvent");
416 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
417 if (obj) {
418 static const char* argumentList[] ={"" , "QFocusEvent*"};
419 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
420 void* args[2] = {NULL, (void*)&arg__1};
421 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
422 if (result) { Py_DECREF(result); }
423 Py_DECREF(obj);
424 return;
425 } else {
426 PyErr_Clear();
427 }
428 }
429 FileBrowser::focusOutEvent(arg__1);
430 }
431 bool PythonQtShell_FileBrowser::hasHeightForWidth() const
432 {
433 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
434 static PyObject* name = PyString_FromString("hasHeightForWidth");
435 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
436 if (obj) {
437 static const char* argumentList[] ={"bool"};
438 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
439 bool returnValue;
440 void* args[1] = {NULL};
441 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
442 if (result) {
443 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
444 if (args[0]!=&returnValue) {
445 if (args[0]==NULL) {
446 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
447 } else {
448 returnValue = *((bool*)args[0]);
449 }
450 }
451 }
452 if (result) { Py_DECREF(result); }
453 Py_DECREF(obj);
454 return returnValue;
455 } else {
456 PyErr_Clear();
457 }
458 }
459 return FileBrowser::hasHeightForWidth();
460 }
461 int PythonQtShell_FileBrowser::heightForWidth(int arg__1) const
462 {
463 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
464 static PyObject* name = PyString_FromString("heightForWidth");
465 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
466 if (obj) {
467 static const char* argumentList[] ={"int" , "int"};
468 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
469 int returnValue;
470 void* args[2] = {NULL, (void*)&arg__1};
471 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
472 if (result) {
473 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
474 if (args[0]!=&returnValue) {
475 if (args[0]==NULL) {
476 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
477 } else {
478 returnValue = *((int*)args[0]);
479 }
480 }
481 }
482 if (result) { Py_DECREF(result); }
483 Py_DECREF(obj);
484 return returnValue;
485 } else {
486 PyErr_Clear();
487 }
488 }
489 return FileBrowser::heightForWidth(arg__1);
490 }
491 void PythonQtShell_FileBrowser::hideEvent(QHideEvent* arg__1)
492 {
493 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
494 static PyObject* name = PyString_FromString("hideEvent");
495 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
496 if (obj) {
497 static const char* argumentList[] ={"" , "QHideEvent*"};
498 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
499 void* args[2] = {NULL, (void*)&arg__1};
500 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
501 if (result) { Py_DECREF(result); }
502 Py_DECREF(obj);
503 return;
504 } else {
505 PyErr_Clear();
506 }
507 }
508 FileBrowser::hideEvent(arg__1);
509 }
510 void PythonQtShell_FileBrowser::initPainter(QPainter* painter0) const
511 {
512 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
513 static PyObject* name = PyString_FromString("initPainter");
514 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
515 if (obj) {
516 static const char* argumentList[] ={"" , "QPainter*"};
517 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
518 void* args[2] = {NULL, (void*)&painter0};
519 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
520 if (result) { Py_DECREF(result); }
521 Py_DECREF(obj);
522 return;
523 } else {
524 PyErr_Clear();
525 }
526 }
527 FileBrowser::initPainter(painter0);
528 }
529 void PythonQtShell_FileBrowser::inputMethodEvent(QInputMethodEvent* arg__1)
530 {
531 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
532 static PyObject* name = PyString_FromString("inputMethodEvent");
533 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
534 if (obj) {
535 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
536 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
537 void* args[2] = {NULL, (void*)&arg__1};
538 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
539 if (result) { Py_DECREF(result); }
540 Py_DECREF(obj);
541 return;
542 } else {
543 PyErr_Clear();
544 }
545 }
546 FileBrowser::inputMethodEvent(arg__1);
547 }
548 QVariant PythonQtShell_FileBrowser::inputMethodQuery(Qt::InputMethodQuery arg__1) const
549 {
550 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
551 static PyObject* name = PyString_FromString("inputMethodQuery");
552 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
553 if (obj) {
554 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
555 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
556 QVariant returnValue;
557 void* args[2] = {NULL, (void*)&arg__1};
558 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
559 if (result) {
560 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
561 if (args[0]!=&returnValue) {
562 if (args[0]==NULL) {
563 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
564 } else {
565 returnValue = *((QVariant*)args[0]);
566 }
567 }
568 }
569 if (result) { Py_DECREF(result); }
570 Py_DECREF(obj);
571 return returnValue;
572 } else {
573 PyErr_Clear();
574 }
575 }
576 return FileBrowser::inputMethodQuery(arg__1);
577 }
578 void PythonQtShell_FileBrowser::keyPressEvent(QKeyEvent* e0)
579 {
580 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
581 static PyObject* name = PyString_FromString("keyPressEvent");
582 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
583 if (obj) {
584 static const char* argumentList[] ={"" , "QKeyEvent*"};
585 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
586 void* args[2] = {NULL, (void*)&e0};
587 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
588 if (result) { Py_DECREF(result); }
589 Py_DECREF(obj);
590 return;
591 } else {
592 PyErr_Clear();
593 }
594 }
595 FileBrowser::keyPressEvent(e0);
596 }
597 void PythonQtShell_FileBrowser::keyReleaseEvent(QKeyEvent* arg__1)
598 {
599 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
600 static PyObject* name = PyString_FromString("keyReleaseEvent");
601 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
602 if (obj) {
603 static const char* argumentList[] ={"" , "QKeyEvent*"};
604 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
605 void* args[2] = {NULL, (void*)&arg__1};
606 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
607 if (result) { Py_DECREF(result); }
608 Py_DECREF(obj);
609 return;
610 } else {
611 PyErr_Clear();
612 }
613 }
614 FileBrowser::keyReleaseEvent(arg__1);
615 }
616 void PythonQtShell_FileBrowser::leaveEvent(QEvent* arg__1)
617 {
618 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
619 static PyObject* name = PyString_FromString("leaveEvent");
620 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
621 if (obj) {
622 static const char* argumentList[] ={"" , "QEvent*"};
623 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
624 void* args[2] = {NULL, (void*)&arg__1};
625 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
626 if (result) { Py_DECREF(result); }
627 Py_DECREF(obj);
628 return;
629 } else {
630 PyErr_Clear();
631 }
632 }
633 FileBrowser::leaveEvent(arg__1);
634 }
635 int PythonQtShell_FileBrowser::metric(QPaintDevice::PaintDeviceMetric arg__1) const
636 {
637 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
638 static PyObject* name = PyString_FromString("metric");
639 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
640 if (obj) {
641 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
642 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
643 int returnValue;
644 void* args[2] = {NULL, (void*)&arg__1};
645 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
646 if (result) {
647 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
648 if (args[0]!=&returnValue) {
649 if (args[0]==NULL) {
650 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
651 } else {
652 returnValue = *((int*)args[0]);
653 }
654 }
655 }
656 if (result) { Py_DECREF(result); }
657 Py_DECREF(obj);
658 return returnValue;
659 } else {
660 PyErr_Clear();
661 }
662 }
663 return FileBrowser::metric(arg__1);
664 }
665 QSize PythonQtShell_FileBrowser::minimumSizeHint() const
666 {
667 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
668 static PyObject* name = PyString_FromString("getMinimumSizeHint");
669 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
670 if (obj) {
671 static const char* argumentList[] ={"QSize"};
672 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
673 QSize returnValue;
674 void* args[1] = {NULL};
675 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
676 if (result) {
677 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
678 if (args[0]!=&returnValue) {
679 if (args[0]==NULL) {
680 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
681 } else {
682 returnValue = *((QSize*)args[0]);
683 }
684 }
685 }
686 if (result) { Py_DECREF(result); }
687 Py_DECREF(obj);
688 return returnValue;
689 } else {
690 PyErr_Clear();
691 }
692 }
693 return FileBrowser::minimumSizeHint();
694 }
695 void PythonQtShell_FileBrowser::mouseDoubleClickEvent(QMouseEvent* arg__1)
696 {
697 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
698 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
699 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
700 if (obj) {
701 static const char* argumentList[] ={"" , "QMouseEvent*"};
702 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
703 void* args[2] = {NULL, (void*)&arg__1};
704 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
705 if (result) { Py_DECREF(result); }
706 Py_DECREF(obj);
707 return;
708 } else {
709 PyErr_Clear();
710 }
711 }
712 FileBrowser::mouseDoubleClickEvent(arg__1);
713 }
714 void PythonQtShell_FileBrowser::mouseMoveEvent(QMouseEvent* arg__1)
715 {
716 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
717 static PyObject* name = PyString_FromString("mouseMoveEvent");
718 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
719 if (obj) {
720 static const char* argumentList[] ={"" , "QMouseEvent*"};
721 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
722 void* args[2] = {NULL, (void*)&arg__1};
723 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
724 if (result) { Py_DECREF(result); }
725 Py_DECREF(obj);
726 return;
727 } else {
728 PyErr_Clear();
729 }
730 }
731 FileBrowser::mouseMoveEvent(arg__1);
732 }
733 void PythonQtShell_FileBrowser::mousePressEvent(QMouseEvent* arg__1)
734 {
735 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
736 static PyObject* name = PyString_FromString("mousePressEvent");
737 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
738 if (obj) {
739 static const char* argumentList[] ={"" , "QMouseEvent*"};
740 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
741 void* args[2] = {NULL, (void*)&arg__1};
742 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
743 if (result) { Py_DECREF(result); }
744 Py_DECREF(obj);
745 return;
746 } else {
747 PyErr_Clear();
748 }
749 }
750 FileBrowser::mousePressEvent(arg__1);
751 }
752 void PythonQtShell_FileBrowser::mouseReleaseEvent(QMouseEvent* arg__1)
753 {
754 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
755 static PyObject* name = PyString_FromString("mouseReleaseEvent");
756 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
757 if (obj) {
758 static const char* argumentList[] ={"" , "QMouseEvent*"};
759 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
760 void* args[2] = {NULL, (void*)&arg__1};
761 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
762 if (result) { Py_DECREF(result); }
763 Py_DECREF(obj);
764 return;
765 } else {
766 PyErr_Clear();
767 }
768 }
769 FileBrowser::mouseReleaseEvent(arg__1);
770 }
771 void PythonQtShell_FileBrowser::moveEvent(QMoveEvent* arg__1)
772 {
773 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
774 static PyObject* name = PyString_FromString("moveEvent");
775 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
776 if (obj) {
777 static const char* argumentList[] ={"" , "QMoveEvent*"};
778 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
779 void* args[2] = {NULL, (void*)&arg__1};
780 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
781 if (result) { Py_DECREF(result); }
782 Py_DECREF(obj);
783 return;
784 } else {
785 PyErr_Clear();
786 }
787 }
788 FileBrowser::moveEvent(arg__1);
789 }
790 bool PythonQtShell_FileBrowser::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
791 {
792 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
793 static PyObject* name = PyString_FromString("nativeEvent");
794 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
795 if (obj) {
796 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
797 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
798 bool returnValue;
799 void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
800 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
801 if (result) {
802 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
803 if (args[0]!=&returnValue) {
804 if (args[0]==NULL) {
805 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
806 } else {
807 returnValue = *((bool*)args[0]);
808 }
809 }
810 }
811 if (result) { Py_DECREF(result); }
812 Py_DECREF(obj);
813 return returnValue;
814 } else {
815 PyErr_Clear();
816 }
817 }
818 return FileBrowser::nativeEvent(eventType0, message1, result2);
819 }
820 QPaintEngine* PythonQtShell_FileBrowser::paintEngine() const
821 {
822 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
823 static PyObject* name = PyString_FromString("paintEngine");
824 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
825 if (obj) {
826 static const char* argumentList[] ={"QPaintEngine*"};
827 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
828 QPaintEngine* returnValue;
829 void* args[1] = {NULL};
830 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
831 if (result) {
832 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
833 if (args[0]!=&returnValue) {
834 if (args[0]==NULL) {
835 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
836 } else {
837 returnValue = *((QPaintEngine**)args[0]);
838 }
839 }
840 }
841 if (result) { Py_DECREF(result); }
842 Py_DECREF(obj);
843 return returnValue;
844 } else {
845 PyErr_Clear();
846 }
847 }
848 return FileBrowser::paintEngine();
849 }
850 void PythonQtShell_FileBrowser::paintEvent(QPaintEvent* event0)
851 {
852 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
853 static PyObject* name = PyString_FromString("paintEvent");
854 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
855 if (obj) {
856 static const char* argumentList[] ={"" , "QPaintEvent*"};
857 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
858 void* args[2] = {NULL, (void*)&event0};
859 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
860 if (result) { Py_DECREF(result); }
861 Py_DECREF(obj);
862 return;
863 } else {
864 PyErr_Clear();
865 }
866 }
867 FileBrowser::paintEvent(event0);
868 }
869 QPaintDevice* PythonQtShell_FileBrowser::redirected(QPoint* offset0) const
870 {
871 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
872 static PyObject* name = PyString_FromString("redirected");
873 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
874 if (obj) {
875 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
876 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
877 QPaintDevice* returnValue;
878 void* args[2] = {NULL, (void*)&offset0};
879 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
880 if (result) {
881 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
882 if (args[0]!=&returnValue) {
883 if (args[0]==NULL) {
884 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
885 } else {
886 returnValue = *((QPaintDevice**)args[0]);
887 }
888 }
889 }
890 if (result) { Py_DECREF(result); }
891 Py_DECREF(obj);
892 return returnValue;
893 } else {
894 PyErr_Clear();
895 }
896 }
897 return FileBrowser::redirected(offset0);
898 }
899 void PythonQtShell_FileBrowser::resizeEvent(QResizeEvent* arg__1)
900 {
901 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
902 static PyObject* name = PyString_FromString("resizeEvent");
903 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
904 if (obj) {
905 static const char* argumentList[] ={"" , "QResizeEvent*"};
906 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
907 void* args[2] = {NULL, (void*)&arg__1};
908 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
909 if (result) { Py_DECREF(result); }
910 Py_DECREF(obj);
911 return;
912 } else {
913 PyErr_Clear();
914 }
915 }
916 FileBrowser::resizeEvent(arg__1);
917 }
918 QPainter* PythonQtShell_FileBrowser::sharedPainter() const
919 {
920 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
921 static PyObject* name = PyString_FromString("sharedPainter");
922 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
923 if (obj) {
924 static const char* argumentList[] ={"QPainter*"};
925 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
926 QPainter* returnValue;
927 void* args[1] = {NULL};
928 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
929 if (result) {
930 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
931 if (args[0]!=&returnValue) {
932 if (args[0]==NULL) {
933 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
934 } else {
935 returnValue = *((QPainter**)args[0]);
936 }
937 }
938 }
939 if (result) { Py_DECREF(result); }
940 Py_DECREF(obj);
941 return returnValue;
942 } else {
943 PyErr_Clear();
944 }
945 }
946 return FileBrowser::sharedPainter();
947 }
948 void PythonQtShell_FileBrowser::showEvent(QShowEvent* arg__1)
949 {
950 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
951 static PyObject* name = PyString_FromString("showEvent");
952 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
953 if (obj) {
954 static const char* argumentList[] ={"" , "QShowEvent*"};
955 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
956 void* args[2] = {NULL, (void*)&arg__1};
957 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
958 if (result) { Py_DECREF(result); }
959 Py_DECREF(obj);
960 return;
961 } else {
962 PyErr_Clear();
963 }
964 }
965 FileBrowser::showEvent(arg__1);
966 }
967 QSize PythonQtShell_FileBrowser::sizeHint() const
968 {
969 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
970 static PyObject* name = PyString_FromString("getSizeHint");
971 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
972 if (obj) {
973 static const char* argumentList[] ={"QSize"};
974 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
975 QSize returnValue;
976 void* args[1] = {NULL};
977 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
978 if (result) {
979 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
980 if (args[0]!=&returnValue) {
981 if (args[0]==NULL) {
982 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
983 } else {
984 returnValue = *((QSize*)args[0]);
985 }
986 }
987 }
988 if (result) { Py_DECREF(result); }
989 Py_DECREF(obj);
990 return returnValue;
991 } else {
992 PyErr_Clear();
993 }
994 }
995 return FileBrowser::sizeHint();
996 }
997 void PythonQtShell_FileBrowser::tabletEvent(QTabletEvent* arg__1)
998 {
999 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1000 static PyObject* name = PyString_FromString("tabletEvent");
1001 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1002 if (obj) {
1003 static const char* argumentList[] ={"" , "QTabletEvent*"};
1004 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1005 void* args[2] = {NULL, (void*)&arg__1};
1006 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1007 if (result) { Py_DECREF(result); }
1008 Py_DECREF(obj);
1009 return;
1010 } else {
1011 PyErr_Clear();
1012 }
1013 }
1014 FileBrowser::tabletEvent(arg__1);
1015 }
1016 void PythonQtShell_FileBrowser::timerEvent(QTimerEvent* arg__1)
1017 {
1018 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1019 static PyObject* name = PyString_FromString("timerEvent");
1020 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1021 if (obj) {
1022 static const char* argumentList[] ={"" , "QTimerEvent*"};
1023 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1024 void* args[2] = {NULL, (void*)&arg__1};
1025 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1026 if (result) { Py_DECREF(result); }
1027 Py_DECREF(obj);
1028 return;
1029 } else {
1030 PyErr_Clear();
1031 }
1032 }
1033 FileBrowser::timerEvent(arg__1);
1034 }
1035 void PythonQtShell_FileBrowser::wheelEvent(QWheelEvent* arg__1)
1036 {
1037 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1038 static PyObject* name = PyString_FromString("wheelEvent");
1039 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1040 if (obj) {
1041 static const char* argumentList[] ={"" , "QWheelEvent*"};
1042 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1043 void* args[2] = {NULL, (void*)&arg__1};
1044 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1045 if (result) { Py_DECREF(result); }
1046 Py_DECREF(obj);
1047 return;
1048 } else {
1049 PyErr_Clear();
1050 }
1051 }
1052 FileBrowser::wheelEvent(arg__1);
1053 }
1054 FileBrowser* PythonQtWrapper_FileBrowser::new_FileBrowser(QWidget* parent)
1055 {
1056 return new PythonQtShell_FileBrowser(parent); }
1057
1058 void PythonQtWrapper_FileBrowser::changeEvent(FileBrowser* theWrappedObject, QEvent* e)
1059 {
1060 ( ((PythonQtPublicPromoter_FileBrowser*)theWrappedObject)->promoted_changeEvent(e));
1061 }
1062
1063 void PythonQtWrapper_FileBrowser::keyPressEvent(FileBrowser* theWrappedObject, QKeyEvent* e)
1064 {
1065 ( ((PythonQtPublicPromoter_FileBrowser*)theWrappedObject)->promoted_keyPressEvent(e));
1066 }
1067
1068 void PythonQtWrapper_FileBrowser::setNameFilters(FileBrowser* theWrappedObject, const QStringList& filters, bool disables)
1069 {
1070 ( theWrappedObject->setNameFilters(filters, disables));
1071 }
1072
1073
1074
1075 PythonQtShell_QCPAbstractItem::~PythonQtShell_QCPAbstractItem() {
1076 PythonQtPrivate* priv = PythonQt::priv();
1077 if (priv) { priv->shellClassDeleted(this); }
1078 }
1079 QPointF PythonQtShell_QCPAbstractItem::anchorPixelPoint(int anchorId0) const
1080 {
1081 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1082 static PyObject* name = PyString_FromString("anchorPixelPoint");
1083 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1084 if (obj) {
1085 static const char* argumentList[] ={"QPointF" , "int"};
1086 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1087 QPointF returnValue;
1088 void* args[2] = {NULL, (void*)&anchorId0};
1089 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1090 if (result) {
1091 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1092 if (args[0]!=&returnValue) {
1093 if (args[0]==NULL) {
1094 PythonQt::priv()->handleVirtualOverloadReturnError("anchorPixelPoint", methodInfo, result);
1095 } else {
1096 returnValue = *((QPointF*)args[0]);
1097 }
1098 }
1099 }
1100 if (result) { Py_DECREF(result); }
1101 Py_DECREF(obj);
1102 return returnValue;
1103 } else {
1104 PyErr_Clear();
1105 }
1106 }
1107 return QCPAbstractItem::anchorPixelPoint(anchorId0);
1108 }
1109 void PythonQtShell_QCPAbstractItem::applyDefaultAntialiasingHint(QCPPainter* painter0) const
1110 {
1111 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1112 static PyObject* name = PyString_FromString("applyDefaultAntialiasingHint");
1113 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1114 if (obj) {
1115 static const char* argumentList[] ={"" , "QCPPainter*"};
1116 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1117 void* args[2] = {NULL, (void*)&painter0};
1118 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1119 if (result) { Py_DECREF(result); }
1120 Py_DECREF(obj);
1121 return;
1122 } else {
1123 PyErr_Clear();
1124 }
1125 }
1126 QCPAbstractItem::applyDefaultAntialiasingHint(painter0);
1127 }
1128 void PythonQtShell_QCPAbstractItem::childEvent(QChildEvent* arg__1)
1129 {
1130 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1131 static PyObject* name = PyString_FromString("childEvent");
1132 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1133 if (obj) {
1134 static const char* argumentList[] ={"" , "QChildEvent*"};
1135 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1136 void* args[2] = {NULL, (void*)&arg__1};
1137 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1138 if (result) { Py_DECREF(result); }
1139 Py_DECREF(obj);
1140 return;
1141 } else {
1142 PyErr_Clear();
1143 }
1144 }
1145 QCPAbstractItem::childEvent(arg__1);
1146 }
1147 QRect PythonQtShell_QCPAbstractItem::clipRect() const
1148 {
1149 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1150 static PyObject* name = PyString_FromString("clipRect");
1151 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1152 if (obj) {
1153 static const char* argumentList[] ={"QRect"};
1154 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1155 QRect returnValue;
1156 void* args[1] = {NULL};
1157 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1158 if (result) {
1159 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1160 if (args[0]!=&returnValue) {
1161 if (args[0]==NULL) {
1162 PythonQt::priv()->handleVirtualOverloadReturnError("clipRect", methodInfo, result);
1163 } else {
1164 returnValue = *((QRect*)args[0]);
1165 }
1166 }
1167 }
1168 if (result) { Py_DECREF(result); }
1169 Py_DECREF(obj);
1170 return returnValue;
1171 } else {
1172 PyErr_Clear();
1173 }
1174 }
1175 return QCPAbstractItem::clipRect();
1176 }
1177 void PythonQtShell_QCPAbstractItem::customEvent(QEvent* arg__1)
1178 {
1179 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1180 static PyObject* name = PyString_FromString("customEvent");
1181 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1182 if (obj) {
1183 static const char* argumentList[] ={"" , "QEvent*"};
1184 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1185 void* args[2] = {NULL, (void*)&arg__1};
1186 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1187 if (result) { Py_DECREF(result); }
1188 Py_DECREF(obj);
1189 return;
1190 } else {
1191 PyErr_Clear();
1192 }
1193 }
1194 QCPAbstractItem::customEvent(arg__1);
1195 }
1196 void PythonQtShell_QCPAbstractItem::deselectEvent(bool* selectionStateChanged0)
1197 {
1198 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1199 static PyObject* name = PyString_FromString("deselectEvent");
1200 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1201 if (obj) {
1202 static const char* argumentList[] ={"" , "bool*"};
1203 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1204 void* args[2] = {NULL, (void*)&selectionStateChanged0};
1205 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1206 if (result) { Py_DECREF(result); }
1207 Py_DECREF(obj);
1208 return;
1209 } else {
1210 PyErr_Clear();
1211 }
1212 }
1213 QCPAbstractItem::deselectEvent(selectionStateChanged0);
1214 }
1215 void PythonQtShell_QCPAbstractItem::draw(QCPPainter* painter0)
1216 {
1217 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1218 static PyObject* name = PyString_FromString("draw");
1219 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1220 if (obj) {
1221 static const char* argumentList[] ={"" , "QCPPainter*"};
1222 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1223 void* args[2] = {NULL, (void*)&painter0};
1224 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1225 if (result) { Py_DECREF(result); }
1226 Py_DECREF(obj);
1227 return;
1228 } else {
1229 PyErr_Clear();
1230 }
1231 }
1232
1233 }
1234 bool PythonQtShell_QCPAbstractItem::event(QEvent* arg__1)
1235 {
1236 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1237 static PyObject* name = PyString_FromString("event");
1238 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1239 if (obj) {
1240 static const char* argumentList[] ={"bool" , "QEvent*"};
1241 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1242 bool returnValue;
1243 void* args[2] = {NULL, (void*)&arg__1};
1244 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1245 if (result) {
1246 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1247 if (args[0]!=&returnValue) {
1248 if (args[0]==NULL) {
1249 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
1250 } else {
1251 returnValue = *((bool*)args[0]);
1252 }
1253 }
1254 }
1255 if (result) { Py_DECREF(result); }
1256 Py_DECREF(obj);
1257 return returnValue;
1258 } else {
1259 PyErr_Clear();
1260 }
1261 }
1262 return QCPAbstractItem::event(arg__1);
1263 }
1264 bool PythonQtShell_QCPAbstractItem::eventFilter(QObject* arg__1, QEvent* arg__2)
1265 {
1266 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1267 static PyObject* name = PyString_FromString("eventFilter");
1268 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1269 if (obj) {
1270 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
1271 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
1272 bool returnValue;
1273 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
1274 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1275 if (result) {
1276 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1277 if (args[0]!=&returnValue) {
1278 if (args[0]==NULL) {
1279 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
1280 } else {
1281 returnValue = *((bool*)args[0]);
1282 }
1283 }
1284 }
1285 if (result) { Py_DECREF(result); }
1286 Py_DECREF(obj);
1287 return returnValue;
1288 } else {
1289 PyErr_Clear();
1290 }
1291 }
1292 return QCPAbstractItem::eventFilter(arg__1, arg__2);
1293 }
1294 void PythonQtShell_QCPAbstractItem::parentPlotInitialized(QCustomPlot* parentPlot0)
1295 {
1296 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1297 static PyObject* name = PyString_FromString("parentPlotInitialized");
1298 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1299 if (obj) {
1300 static const char* argumentList[] ={"" , "QCustomPlot*"};
1301 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1302 void* args[2] = {NULL, (void*)&parentPlot0};
1303 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1304 if (result) { Py_DECREF(result); }
1305 Py_DECREF(obj);
1306 return;
1307 } else {
1308 PyErr_Clear();
1309 }
1310 }
1311 QCPAbstractItem::parentPlotInitialized(parentPlot0);
1312 }
1313 void PythonQtShell_QCPAbstractItem::selectEvent(QMouseEvent* event0, bool additive1, const QVariant& details2, bool* selectionStateChanged3)
1314 {
1315 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1316 static PyObject* name = PyString_FromString("selectEvent");
1317 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1318 if (obj) {
1319 static const char* argumentList[] ={"" , "QMouseEvent*" , "bool" , "const QVariant&" , "bool*"};
1320 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList);
1321 void* args[5] = {NULL, (void*)&event0, (void*)&additive1, (void*)&details2, (void*)&selectionStateChanged3};
1322 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1323 if (result) { Py_DECREF(result); }
1324 Py_DECREF(obj);
1325 return;
1326 } else {
1327 PyErr_Clear();
1328 }
1329 }
1330 QCPAbstractItem::selectEvent(event0, additive1, details2, selectionStateChanged3);
1331 }
1332 double PythonQtShell_QCPAbstractItem::selectTest(const QPointF& pos0, bool onlySelectable1, QVariant* details2) const
1333 {
1334 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1335 static PyObject* name = PyString_FromString("selectTest");
1336 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1337 if (obj) {
1338 static const char* argumentList[] ={"double" , "const QPointF&" , "bool" , "QVariant*"};
1339 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
1340 double returnValue;
1341 void* args[4] = {NULL, (void*)&pos0, (void*)&onlySelectable1, (void*)&details2};
1342 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1343 if (result) {
1344 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1345 if (args[0]!=&returnValue) {
1346 if (args[0]==NULL) {
1347 PythonQt::priv()->handleVirtualOverloadReturnError("selectTest", methodInfo, result);
1348 } else {
1349 returnValue = *((double*)args[0]);
1350 }
1351 }
1352 }
1353 if (result) { Py_DECREF(result); }
1354 Py_DECREF(obj);
1355 return returnValue;
1356 } else {
1357 PyErr_Clear();
1358 }
1359 }
1360 return double();
1361 }
1362 void PythonQtShell_QCPAbstractItem::timerEvent(QTimerEvent* arg__1)
1363 {
1364 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1365 static PyObject* name = PyString_FromString("timerEvent");
1366 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1367 if (obj) {
1368 static const char* argumentList[] ={"" , "QTimerEvent*"};
1369 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1370 void* args[2] = {NULL, (void*)&arg__1};
1371 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1372 if (result) { Py_DECREF(result); }
1373 Py_DECREF(obj);
1374 return;
1375 } else {
1376 PyErr_Clear();
1377 }
1378 }
1379 QCPAbstractItem::timerEvent(arg__1);
1380 }
1381 QCPAbstractItem* PythonQtWrapper_QCPAbstractItem::new_QCPAbstractItem(QCustomPlot* parentPlot)
1382 {
1383 return new PythonQtShell_QCPAbstractItem(parentPlot); }
1384
1385 QPointF PythonQtWrapper_QCPAbstractItem::anchorPixelPoint(QCPAbstractItem* theWrappedObject, int anchorId) const
1386 {
1387 return ( ((PythonQtPublicPromoter_QCPAbstractItem*)theWrappedObject)->promoted_anchorPixelPoint(anchorId));
1388 }
1389
1390 void PythonQtWrapper_QCPAbstractItem::applyDefaultAntialiasingHint(QCPAbstractItem* theWrappedObject, QCPPainter* painter) const
1391 {
1392 ( ((PythonQtPublicPromoter_QCPAbstractItem*)theWrappedObject)->promoted_applyDefaultAntialiasingHint(painter));
1393 }
1394
1395 QCPAxisRect* PythonQtWrapper_QCPAbstractItem::clipAxisRect(QCPAbstractItem* theWrappedObject) const
1396 {
1397 return ( theWrappedObject->clipAxisRect());
1398 }
1399
1400 QRect PythonQtWrapper_QCPAbstractItem::clipRect(QCPAbstractItem* theWrappedObject) const
1401 {
1402 return ( ((PythonQtPublicPromoter_QCPAbstractItem*)theWrappedObject)->promoted_clipRect());
1403 }
1404
1405 bool PythonQtWrapper_QCPAbstractItem::clipToAxisRect(QCPAbstractItem* theWrappedObject) const
1406 {
1407 return ( theWrappedObject->clipToAxisRect());
1408 }
1409
1410 QCPItemPosition* PythonQtWrapper_QCPAbstractItem::createPosition(QCPAbstractItem* theWrappedObject, const QString& name)
1411 {
1412 return ( ((PythonQtPublicPromoter_QCPAbstractItem*)theWrappedObject)->promoted_createPosition(name));
1413 }
1414
1415 void PythonQtWrapper_QCPAbstractItem::deselectEvent(QCPAbstractItem* theWrappedObject, bool* selectionStateChanged)
1416 {
1417 ( ((PythonQtPublicPromoter_QCPAbstractItem*)theWrappedObject)->promoted_deselectEvent(selectionStateChanged));
1418 }
1419
1420 double PythonQtWrapper_QCPAbstractItem::distSqrToLine(QCPAbstractItem* theWrappedObject, const QPointF& start, const QPointF& end, const QPointF& point) const
1421 {
1422 return ( ((PythonQtPublicPromoter_QCPAbstractItem*)theWrappedObject)->promoted_distSqrToLine(start, end, point));
1423 }
1424
1425 void PythonQtWrapper_QCPAbstractItem::draw(QCPAbstractItem* theWrappedObject, QCPPainter* painter)
1426 {
1427 ( ((PythonQtPublicPromoter_QCPAbstractItem*)theWrappedObject)->promoted_draw(painter));
1428 }
1429
1430 bool PythonQtWrapper_QCPAbstractItem::hasAnchor(QCPAbstractItem* theWrappedObject, const QString& name) const
1431 {
1432 return ( theWrappedObject->hasAnchor(name));
1433 }
1434
1435 QCPItemPosition* PythonQtWrapper_QCPAbstractItem::position(QCPAbstractItem* theWrappedObject, const QString& name) const
1436 {
1437 return ( theWrappedObject->position(name));
1438 }
1439
1440 QList<QCPItemPosition* > PythonQtWrapper_QCPAbstractItem::positions(QCPAbstractItem* theWrappedObject) const
1441 {
1442 return ( theWrappedObject->positions());
1443 }
1444
1445 double PythonQtWrapper_QCPAbstractItem::rectSelectTest(QCPAbstractItem* theWrappedObject, const QRectF& rect, const QPointF& pos, bool filledRect) const
1446 {
1447 return ( ((PythonQtPublicPromoter_QCPAbstractItem*)theWrappedObject)->promoted_rectSelectTest(rect, pos, filledRect));
1448 }
1449
1450 void PythonQtWrapper_QCPAbstractItem::selectEvent(QCPAbstractItem* theWrappedObject, QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged)
1451 {
1452 ( ((PythonQtPublicPromoter_QCPAbstractItem*)theWrappedObject)->promoted_selectEvent(event, additive, details, selectionStateChanged));
1453 }
1454
1455 double PythonQtWrapper_QCPAbstractItem::selectTest(QCPAbstractItem* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details) const
1456 {
1457 return ( ((PythonQtPublicPromoter_QCPAbstractItem*)theWrappedObject)->promoted_selectTest(pos, onlySelectable, details));
1458 }
1459
1460 bool PythonQtWrapper_QCPAbstractItem::selectable(QCPAbstractItem* theWrappedObject) const
1461 {
1462 return ( theWrappedObject->selectable());
1463 }
1464
1465 bool PythonQtWrapper_QCPAbstractItem::selected(QCPAbstractItem* theWrappedObject) const
1466 {
1467 return ( theWrappedObject->selected());
1468 }
1469
1470 void PythonQtWrapper_QCPAbstractItem::setClipAxisRect(QCPAbstractItem* theWrappedObject, QCPAxisRect* rect)
1471 {
1472 ( theWrappedObject->setClipAxisRect(rect));
1473 }
1474
1475 void PythonQtWrapper_QCPAbstractItem::setClipToAxisRect(QCPAbstractItem* theWrappedObject, bool clip)
1476 {
1477 ( theWrappedObject->setClipToAxisRect(clip));
1478 }
1479
1480 void PythonQtWrapper_QCPAbstractItem::setSelectable(QCPAbstractItem* theWrappedObject, bool selectable)
1481 {
1482 ( theWrappedObject->setSelectable(selectable));
1483 }
1484
1485 void PythonQtWrapper_QCPAbstractItem::setSelected(QCPAbstractItem* theWrappedObject, bool selected)
1486 {
1487 ( theWrappedObject->setSelected(selected));
1488 }
1489
1490
1491
1492 PythonQtShell_QCPAbstractLegendItem::~PythonQtShell_QCPAbstractLegendItem() {
1493 PythonQtPrivate* priv = PythonQt::priv();
1494 if (priv) { priv->shellClassDeleted(this); }
1495 }
1496 void PythonQtShell_QCPAbstractLegendItem::applyDefaultAntialiasingHint(QCPPainter* painter0) const
1497 {
1498 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1499 static PyObject* name = PyString_FromString("applyDefaultAntialiasingHint");
1500 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1501 if (obj) {
1502 static const char* argumentList[] ={"" , "QCPPainter*"};
1503 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1504 void* args[2] = {NULL, (void*)&painter0};
1505 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1506 if (result) { Py_DECREF(result); }
1507 Py_DECREF(obj);
1508 return;
1509 } else {
1510 PyErr_Clear();
1511 }
1512 }
1513 QCPAbstractLegendItem::applyDefaultAntialiasingHint(painter0);
1514 }
1515 void PythonQtShell_QCPAbstractLegendItem::childEvent(QChildEvent* arg__1)
1516 {
1517 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1518 static PyObject* name = PyString_FromString("childEvent");
1519 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1520 if (obj) {
1521 static const char* argumentList[] ={"" , "QChildEvent*"};
1522 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1523 void* args[2] = {NULL, (void*)&arg__1};
1524 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1525 if (result) { Py_DECREF(result); }
1526 Py_DECREF(obj);
1527 return;
1528 } else {
1529 PyErr_Clear();
1530 }
1531 }
1532 QCPAbstractLegendItem::childEvent(arg__1);
1533 }
1534 QRect PythonQtShell_QCPAbstractLegendItem::clipRect() const
1535 {
1536 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1537 static PyObject* name = PyString_FromString("clipRect");
1538 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1539 if (obj) {
1540 static const char* argumentList[] ={"QRect"};
1541 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1542 QRect returnValue;
1543 void* args[1] = {NULL};
1544 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1545 if (result) {
1546 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1547 if (args[0]!=&returnValue) {
1548 if (args[0]==NULL) {
1549 PythonQt::priv()->handleVirtualOverloadReturnError("clipRect", methodInfo, result);
1550 } else {
1551 returnValue = *((QRect*)args[0]);
1552 }
1553 }
1554 }
1555 if (result) { Py_DECREF(result); }
1556 Py_DECREF(obj);
1557 return returnValue;
1558 } else {
1559 PyErr_Clear();
1560 }
1561 }
1562 return QCPAbstractLegendItem::clipRect();
1563 }
1564 void PythonQtShell_QCPAbstractLegendItem::customEvent(QEvent* arg__1)
1565 {
1566 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1567 static PyObject* name = PyString_FromString("customEvent");
1568 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1569 if (obj) {
1570 static const char* argumentList[] ={"" , "QEvent*"};
1571 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1572 void* args[2] = {NULL, (void*)&arg__1};
1573 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1574 if (result) { Py_DECREF(result); }
1575 Py_DECREF(obj);
1576 return;
1577 } else {
1578 PyErr_Clear();
1579 }
1580 }
1581 QCPAbstractLegendItem::customEvent(arg__1);
1582 }
1583 void PythonQtShell_QCPAbstractLegendItem::deselectEvent(bool* selectionStateChanged0)
1584 {
1585 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1586 static PyObject* name = PyString_FromString("deselectEvent");
1587 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1588 if (obj) {
1589 static const char* argumentList[] ={"" , "bool*"};
1590 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1591 void* args[2] = {NULL, (void*)&selectionStateChanged0};
1592 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1593 if (result) { Py_DECREF(result); }
1594 Py_DECREF(obj);
1595 return;
1596 } else {
1597 PyErr_Clear();
1598 }
1599 }
1600 QCPAbstractLegendItem::deselectEvent(selectionStateChanged0);
1601 }
1602 void PythonQtShell_QCPAbstractLegendItem::draw(QCPPainter* painter0)
1603 {
1604 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1605 static PyObject* name = PyString_FromString("draw");
1606 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1607 if (obj) {
1608 static const char* argumentList[] ={"" , "QCPPainter*"};
1609 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1610 void* args[2] = {NULL, (void*)&painter0};
1611 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1612 if (result) { Py_DECREF(result); }
1613 Py_DECREF(obj);
1614 return;
1615 } else {
1616 PyErr_Clear();
1617 }
1618 }
1619
1620 }
1621 QList<QCPLayoutElement* > PythonQtShell_QCPAbstractLegendItem::elements(bool recursive0) const
1622 {
1623 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1624 static PyObject* name = PyString_FromString("elements");
1625 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1626 if (obj) {
1627 static const char* argumentList[] ={"QList<QCPLayoutElement* >" , "bool"};
1628 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1629 QList<QCPLayoutElement* > returnValue;
1630 void* args[2] = {NULL, (void*)&recursive0};
1631 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1632 if (result) {
1633 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1634 if (args[0]!=&returnValue) {
1635 if (args[0]==NULL) {
1636 PythonQt::priv()->handleVirtualOverloadReturnError("elements", methodInfo, result);
1637 } else {
1638 returnValue = *((QList<QCPLayoutElement* >*)args[0]);
1639 }
1640 }
1641 }
1642 if (result) { Py_DECREF(result); }
1643 Py_DECREF(obj);
1644 return returnValue;
1645 } else {
1646 PyErr_Clear();
1647 }
1648 }
1649 return QCPAbstractLegendItem::elements(recursive0);
1650 }
1651 bool PythonQtShell_QCPAbstractLegendItem::event(QEvent* arg__1)
1652 {
1653 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1654 static PyObject* name = PyString_FromString("event");
1655 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1656 if (obj) {
1657 static const char* argumentList[] ={"bool" , "QEvent*"};
1658 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1659 bool returnValue;
1660 void* args[2] = {NULL, (void*)&arg__1};
1661 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1662 if (result) {
1663 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1664 if (args[0]!=&returnValue) {
1665 if (args[0]==NULL) {
1666 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
1667 } else {
1668 returnValue = *((bool*)args[0]);
1669 }
1670 }
1671 }
1672 if (result) { Py_DECREF(result); }
1673 Py_DECREF(obj);
1674 return returnValue;
1675 } else {
1676 PyErr_Clear();
1677 }
1678 }
1679 return QCPAbstractLegendItem::event(arg__1);
1680 }
1681 bool PythonQtShell_QCPAbstractLegendItem::eventFilter(QObject* arg__1, QEvent* arg__2)
1682 {
1683 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1684 static PyObject* name = PyString_FromString("eventFilter");
1685 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1686 if (obj) {
1687 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
1688 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
1689 bool returnValue;
1690 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
1691 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1692 if (result) {
1693 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1694 if (args[0]!=&returnValue) {
1695 if (args[0]==NULL) {
1696 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
1697 } else {
1698 returnValue = *((bool*)args[0]);
1699 }
1700 }
1701 }
1702 if (result) { Py_DECREF(result); }
1703 Py_DECREF(obj);
1704 return returnValue;
1705 } else {
1706 PyErr_Clear();
1707 }
1708 }
1709 return QCPAbstractLegendItem::eventFilter(arg__1, arg__2);
1710 }
1711 QSize PythonQtShell_QCPAbstractLegendItem::maximumSizeHint() const
1712 {
1713 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1714 static PyObject* name = PyString_FromString("maximumSizeHint");
1715 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1716 if (obj) {
1717 static const char* argumentList[] ={"QSize"};
1718 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1719 QSize returnValue;
1720 void* args[1] = {NULL};
1721 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1722 if (result) {
1723 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1724 if (args[0]!=&returnValue) {
1725 if (args[0]==NULL) {
1726 PythonQt::priv()->handleVirtualOverloadReturnError("maximumSizeHint", methodInfo, result);
1727 } else {
1728 returnValue = *((QSize*)args[0]);
1729 }
1730 }
1731 }
1732 if (result) { Py_DECREF(result); }
1733 Py_DECREF(obj);
1734 return returnValue;
1735 } else {
1736 PyErr_Clear();
1737 }
1738 }
1739 return QCPAbstractLegendItem::maximumSizeHint();
1740 }
1741 QSize PythonQtShell_QCPAbstractLegendItem::minimumSizeHint() const
1742 {
1743 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1744 static PyObject* name = PyString_FromString("minimumSizeHint");
1745 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1746 if (obj) {
1747 static const char* argumentList[] ={"QSize"};
1748 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1749 QSize returnValue;
1750 void* args[1] = {NULL};
1751 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1752 if (result) {
1753 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1754 if (args[0]!=&returnValue) {
1755 if (args[0]==NULL) {
1756 PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result);
1757 } else {
1758 returnValue = *((QSize*)args[0]);
1759 }
1760 }
1761 }
1762 if (result) { Py_DECREF(result); }
1763 Py_DECREF(obj);
1764 return returnValue;
1765 } else {
1766 PyErr_Clear();
1767 }
1768 }
1769 return QCPAbstractLegendItem::minimumSizeHint();
1770 }
1771 void PythonQtShell_QCPAbstractLegendItem::mouseDoubleClickEvent(QMouseEvent* event0)
1772 {
1773 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1774 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
1775 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1776 if (obj) {
1777 static const char* argumentList[] ={"" , "QMouseEvent*"};
1778 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1779 void* args[2] = {NULL, (void*)&event0};
1780 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1781 if (result) { Py_DECREF(result); }
1782 Py_DECREF(obj);
1783 return;
1784 } else {
1785 PyErr_Clear();
1786 }
1787 }
1788 QCPAbstractLegendItem::mouseDoubleClickEvent(event0);
1789 }
1790 void PythonQtShell_QCPAbstractLegendItem::mouseMoveEvent(QMouseEvent* event0)
1791 {
1792 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1793 static PyObject* name = PyString_FromString("mouseMoveEvent");
1794 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1795 if (obj) {
1796 static const char* argumentList[] ={"" , "QMouseEvent*"};
1797 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1798 void* args[2] = {NULL, (void*)&event0};
1799 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1800 if (result) { Py_DECREF(result); }
1801 Py_DECREF(obj);
1802 return;
1803 } else {
1804 PyErr_Clear();
1805 }
1806 }
1807 QCPAbstractLegendItem::mouseMoveEvent(event0);
1808 }
1809 void PythonQtShell_QCPAbstractLegendItem::mousePressEvent(QMouseEvent* event0)
1810 {
1811 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1812 static PyObject* name = PyString_FromString("mousePressEvent");
1813 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1814 if (obj) {
1815 static const char* argumentList[] ={"" , "QMouseEvent*"};
1816 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1817 void* args[2] = {NULL, (void*)&event0};
1818 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1819 if (result) { Py_DECREF(result); }
1820 Py_DECREF(obj);
1821 return;
1822 } else {
1823 PyErr_Clear();
1824 }
1825 }
1826 QCPAbstractLegendItem::mousePressEvent(event0);
1827 }
1828 void PythonQtShell_QCPAbstractLegendItem::mouseReleaseEvent(QMouseEvent* event0)
1829 {
1830 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1831 static PyObject* name = PyString_FromString("mouseReleaseEvent");
1832 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1833 if (obj) {
1834 static const char* argumentList[] ={"" , "QMouseEvent*"};
1835 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1836 void* args[2] = {NULL, (void*)&event0};
1837 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1838 if (result) { Py_DECREF(result); }
1839 Py_DECREF(obj);
1840 return;
1841 } else {
1842 PyErr_Clear();
1843 }
1844 }
1845 QCPAbstractLegendItem::mouseReleaseEvent(event0);
1846 }
1847 void PythonQtShell_QCPAbstractLegendItem::parentPlotInitialized(QCustomPlot* parentPlot0)
1848 {
1849 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1850 static PyObject* name = PyString_FromString("parentPlotInitialized");
1851 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1852 if (obj) {
1853 static const char* argumentList[] ={"" , "QCustomPlot*"};
1854 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1855 void* args[2] = {NULL, (void*)&parentPlot0};
1856 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1857 if (result) { Py_DECREF(result); }
1858 Py_DECREF(obj);
1859 return;
1860 } else {
1861 PyErr_Clear();
1862 }
1863 }
1864 QCPAbstractLegendItem::parentPlotInitialized(parentPlot0);
1865 }
1866 void PythonQtShell_QCPAbstractLegendItem::selectEvent(QMouseEvent* event0, bool additive1, const QVariant& details2, bool* selectionStateChanged3)
1867 {
1868 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1869 static PyObject* name = PyString_FromString("selectEvent");
1870 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1871 if (obj) {
1872 static const char* argumentList[] ={"" , "QMouseEvent*" , "bool" , "const QVariant&" , "bool*"};
1873 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList);
1874 void* args[5] = {NULL, (void*)&event0, (void*)&additive1, (void*)&details2, (void*)&selectionStateChanged3};
1875 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1876 if (result) { Py_DECREF(result); }
1877 Py_DECREF(obj);
1878 return;
1879 } else {
1880 PyErr_Clear();
1881 }
1882 }
1883 QCPAbstractLegendItem::selectEvent(event0, additive1, details2, selectionStateChanged3);
1884 }
1885 double PythonQtShell_QCPAbstractLegendItem::selectTest(const QPointF& pos0, bool onlySelectable1, QVariant* details2) const
1886 {
1887 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1888 static PyObject* name = PyString_FromString("selectTest");
1889 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1890 if (obj) {
1891 static const char* argumentList[] ={"double" , "const QPointF&" , "bool" , "QVariant*"};
1892 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
1893 double returnValue;
1894 void* args[4] = {NULL, (void*)&pos0, (void*)&onlySelectable1, (void*)&details2};
1895 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1896 if (result) {
1897 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1898 if (args[0]!=&returnValue) {
1899 if (args[0]==NULL) {
1900 PythonQt::priv()->handleVirtualOverloadReturnError("selectTest", methodInfo, result);
1901 } else {
1902 returnValue = *((double*)args[0]);
1903 }
1904 }
1905 }
1906 if (result) { Py_DECREF(result); }
1907 Py_DECREF(obj);
1908 return returnValue;
1909 } else {
1910 PyErr_Clear();
1911 }
1912 }
1913 return QCPAbstractLegendItem::selectTest(pos0, onlySelectable1, details2);
1914 }
1915 void PythonQtShell_QCPAbstractLegendItem::timerEvent(QTimerEvent* arg__1)
1916 {
1917 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1918 static PyObject* name = PyString_FromString("timerEvent");
1919 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1920 if (obj) {
1921 static const char* argumentList[] ={"" , "QTimerEvent*"};
1922 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1923 void* args[2] = {NULL, (void*)&arg__1};
1924 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1925 if (result) { Py_DECREF(result); }
1926 Py_DECREF(obj);
1927 return;
1928 } else {
1929 PyErr_Clear();
1930 }
1931 }
1932 QCPAbstractLegendItem::timerEvent(arg__1);
1933 }
1934 void PythonQtShell_QCPAbstractLegendItem::wheelEvent(QWheelEvent* event0)
1935 {
1936 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1937 static PyObject* name = PyString_FromString("wheelEvent");
1938 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1939 if (obj) {
1940 static const char* argumentList[] ={"" , "QWheelEvent*"};
1941 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1942 void* args[2] = {NULL, (void*)&event0};
1943 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1944 if (result) { Py_DECREF(result); }
1945 Py_DECREF(obj);
1946 return;
1947 } else {
1948 PyErr_Clear();
1949 }
1950 }
1951 QCPAbstractLegendItem::wheelEvent(event0);
1952 }
1953 QCPAbstractLegendItem* PythonQtWrapper_QCPAbstractLegendItem::new_QCPAbstractLegendItem(QCPLegend* parent)
1954 {
1955 return new PythonQtShell_QCPAbstractLegendItem(parent); }
1956
1957 void PythonQtWrapper_QCPAbstractLegendItem::applyDefaultAntialiasingHint(QCPAbstractLegendItem* theWrappedObject, QCPPainter* painter) const
1958 {
1959 ( ((PythonQtPublicPromoter_QCPAbstractLegendItem*)theWrappedObject)->promoted_applyDefaultAntialiasingHint(painter));
1960 }
1961
1962 QRect PythonQtWrapper_QCPAbstractLegendItem::clipRect(QCPAbstractLegendItem* theWrappedObject) const
1963 {
1964 return ( ((PythonQtPublicPromoter_QCPAbstractLegendItem*)theWrappedObject)->promoted_clipRect());
1965 }
1966
1967 void PythonQtWrapper_QCPAbstractLegendItem::deselectEvent(QCPAbstractLegendItem* theWrappedObject, bool* selectionStateChanged)
1968 {
1969 ( ((PythonQtPublicPromoter_QCPAbstractLegendItem*)theWrappedObject)->promoted_deselectEvent(selectionStateChanged));
1970 }
1971
1972 void PythonQtWrapper_QCPAbstractLegendItem::draw(QCPAbstractLegendItem* theWrappedObject, QCPPainter* painter)
1973 {
1974 ( ((PythonQtPublicPromoter_QCPAbstractLegendItem*)theWrappedObject)->promoted_draw(painter));
1975 }
1976
1977 QFont PythonQtWrapper_QCPAbstractLegendItem::font(QCPAbstractLegendItem* theWrappedObject) const
1978 {
1979 return ( theWrappedObject->font());
1980 }
1981
1982 QCPLegend* PythonQtWrapper_QCPAbstractLegendItem::parentLegend(QCPAbstractLegendItem* theWrappedObject) const
1983 {
1984 return ( theWrappedObject->parentLegend());
1985 }
1986
1987 void PythonQtWrapper_QCPAbstractLegendItem::selectEvent(QCPAbstractLegendItem* theWrappedObject, QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged)
1988 {
1989 ( ((PythonQtPublicPromoter_QCPAbstractLegendItem*)theWrappedObject)->promoted_selectEvent(event, additive, details, selectionStateChanged));
1990 }
1991
1992 double PythonQtWrapper_QCPAbstractLegendItem::selectTest(QCPAbstractLegendItem* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details) const
1993 {
1994 return ( ((PythonQtPublicPromoter_QCPAbstractLegendItem*)theWrappedObject)->promoted_selectTest(pos, onlySelectable, details));
1995 }
1996
1997 bool PythonQtWrapper_QCPAbstractLegendItem::selectable(QCPAbstractLegendItem* theWrappedObject) const
1998 {
1999 return ( theWrappedObject->selectable());
2000 }
2001
2002 bool PythonQtWrapper_QCPAbstractLegendItem::selected(QCPAbstractLegendItem* theWrappedObject) const
2003 {
2004 return ( theWrappedObject->selected());
2005 }
2006
2007 QFont PythonQtWrapper_QCPAbstractLegendItem::selectedFont(QCPAbstractLegendItem* theWrappedObject) const
2008 {
2009 return ( theWrappedObject->selectedFont());
2010 }
2011
2012 QColor PythonQtWrapper_QCPAbstractLegendItem::selectedTextColor(QCPAbstractLegendItem* theWrappedObject) const
2013 {
2014 return ( theWrappedObject->selectedTextColor());
2015 }
2016
2017 void PythonQtWrapper_QCPAbstractLegendItem::setFont(QCPAbstractLegendItem* theWrappedObject, const QFont& font)
2018 {
2019 ( theWrappedObject->setFont(font));
2020 }
2021
2022 void PythonQtWrapper_QCPAbstractLegendItem::setSelectable(QCPAbstractLegendItem* theWrappedObject, bool selectable)
2023 {
2024 ( theWrappedObject->setSelectable(selectable));
2025 }
2026
2027 void PythonQtWrapper_QCPAbstractLegendItem::setSelected(QCPAbstractLegendItem* theWrappedObject, bool selected)
2028 {
2029 ( theWrappedObject->setSelected(selected));
2030 }
2031
2032 void PythonQtWrapper_QCPAbstractLegendItem::setSelectedFont(QCPAbstractLegendItem* theWrappedObject, const QFont& font)
2033 {
2034 ( theWrappedObject->setSelectedFont(font));
2035 }
2036
2037 void PythonQtWrapper_QCPAbstractLegendItem::setSelectedTextColor(QCPAbstractLegendItem* theWrappedObject, const QColor& color)
2038 {
2039 ( theWrappedObject->setSelectedTextColor(color));
2040 }
2041
2042 void PythonQtWrapper_QCPAbstractLegendItem::setTextColor(QCPAbstractLegendItem* theWrappedObject, const QColor& color)
2043 {
2044 ( theWrappedObject->setTextColor(color));
2045 }
2046
2047 QColor PythonQtWrapper_QCPAbstractLegendItem::textColor(QCPAbstractLegendItem* theWrappedObject) const
2048 {
2049 return ( theWrappedObject->textColor());
2050 }
2051
2052
2053
2054 void PythonQtWrapper_QCPAxis::applyDefaultAntialiasingHint(QCPAxis* theWrappedObject, QCPPainter* painter) const
2055 {
2056 ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_applyDefaultAntialiasingHint(painter));
2057 }
2058
2059 bool PythonQtWrapper_QCPAxis::autoSubTicks(QCPAxis* theWrappedObject) const
2060 {
2061 return ( theWrappedObject->autoSubTicks());
2062 }
2063
2064 int PythonQtWrapper_QCPAxis::autoTickCount(QCPAxis* theWrappedObject) const
2065 {
2066 return ( theWrappedObject->autoTickCount());
2067 }
2068
2069 bool PythonQtWrapper_QCPAxis::autoTickLabels(QCPAxis* theWrappedObject) const
2070 {
2071 return ( theWrappedObject->autoTickLabels());
2072 }
2073
2074 bool PythonQtWrapper_QCPAxis::autoTickStep(QCPAxis* theWrappedObject) const
2075 {
2076 return ( theWrappedObject->autoTickStep());
2077 }
2078
2079 bool PythonQtWrapper_QCPAxis::autoTicks(QCPAxis* theWrappedObject) const
2080 {
2081 return ( theWrappedObject->autoTicks());
2082 }
2083
2084 QCPAxisRect* PythonQtWrapper_QCPAxis::axisRect(QCPAxis* theWrappedObject) const
2085 {
2086 return ( theWrappedObject->axisRect());
2087 }
2088
2089 double PythonQtWrapper_QCPAxis::baseLog(QCPAxis* theWrappedObject, double value) const
2090 {
2091 return ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_baseLog(value));
2092 }
2093
2094 QPen PythonQtWrapper_QCPAxis::basePen(QCPAxis* theWrappedObject) const
2095 {
2096 return ( theWrappedObject->basePen());
2097 }
2098
2099 double PythonQtWrapper_QCPAxis::basePow(QCPAxis* theWrappedObject, double value) const
2100 {
2101 return ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_basePow(value));
2102 }
2103
2104 int PythonQtWrapper_QCPAxis::calculateAutoSubTickCount(QCPAxis* theWrappedObject, double tickStep) const
2105 {
2106 return ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_calculateAutoSubTickCount(tickStep));
2107 }
2108
2109 int PythonQtWrapper_QCPAxis::calculateMargin(QCPAxis* theWrappedObject)
2110 {
2111 return ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_calculateMargin());
2112 }
2113
2114 double PythonQtWrapper_QCPAxis::coordToPixel(QCPAxis* theWrappedObject, double value) const
2115 {
2116 return ( theWrappedObject->coordToPixel(value));
2117 }
2118
2119 QString PythonQtWrapper_QCPAxis::dateTimeFormat(QCPAxis* theWrappedObject) const
2120 {
2121 return ( theWrappedObject->dateTimeFormat());
2122 }
2123
2124 Qt::TimeSpec PythonQtWrapper_QCPAxis::dateTimeSpec(QCPAxis* theWrappedObject) const
2125 {
2126 return ( theWrappedObject->dateTimeSpec());
2127 }
2128
2129 void PythonQtWrapper_QCPAxis::deselectEvent(QCPAxis* theWrappedObject, bool* selectionStateChanged)
2130 {
2131 ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_deselectEvent(selectionStateChanged));
2132 }
2133
2134 void PythonQtWrapper_QCPAxis::draw(QCPAxis* theWrappedObject, QCPPainter* painter)
2135 {
2136 ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_draw(painter));
2137 }
2138
2139 void PythonQtWrapper_QCPAxis::generateAutoTicks(QCPAxis* theWrappedObject)
2140 {
2141 ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_generateAutoTicks());
2142 }
2143
2144 QPen PythonQtWrapper_QCPAxis::getBasePen(QCPAxis* theWrappedObject) const
2145 {
2146 return ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_getBasePen());
2147 }
2148
2149 QColor PythonQtWrapper_QCPAxis::getLabelColor(QCPAxis* theWrappedObject) const
2150 {
2151 return ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_getLabelColor());
2152 }
2153
2154 QFont PythonQtWrapper_QCPAxis::getLabelFont(QCPAxis* theWrappedObject) const
2155 {
2156 return ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_getLabelFont());
2157 }
2158
2159 QPen PythonQtWrapper_QCPAxis::getSubTickPen(QCPAxis* theWrappedObject) const
2160 {
2161 return ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_getSubTickPen());
2162 }
2163
2164 QColor PythonQtWrapper_QCPAxis::getTickLabelColor(QCPAxis* theWrappedObject) const
2165 {
2166 return ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_getTickLabelColor());
2167 }
2168
2169 QFont PythonQtWrapper_QCPAxis::getTickLabelFont(QCPAxis* theWrappedObject) const
2170 {
2171 return ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_getTickLabelFont());
2172 }
2173
2174 QPen PythonQtWrapper_QCPAxis::getTickPen(QCPAxis* theWrappedObject) const
2175 {
2176 return ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_getTickPen());
2177 }
2178
2179 QList<QCPGraph* > PythonQtWrapper_QCPAxis::graphs(QCPAxis* theWrappedObject) const
2180 {
2181 return ( theWrappedObject->graphs());
2182 }
2183
2184 QList<QCPAbstractItem* > PythonQtWrapper_QCPAxis::items(QCPAxis* theWrappedObject) const
2185 {
2186 return ( theWrappedObject->items());
2187 }
2188
2189 QString PythonQtWrapper_QCPAxis::label(QCPAxis* theWrappedObject) const
2190 {
2191 return ( theWrappedObject->label());
2192 }
2193
2194 QColor PythonQtWrapper_QCPAxis::labelColor(QCPAxis* theWrappedObject) const
2195 {
2196 return ( theWrappedObject->labelColor());
2197 }
2198
2199 QFont PythonQtWrapper_QCPAxis::labelFont(QCPAxis* theWrappedObject) const
2200 {
2201 return ( theWrappedObject->labelFont());
2202 }
2203
2204 int PythonQtWrapper_QCPAxis::labelPadding(QCPAxis* theWrappedObject) const
2205 {
2206 return ( theWrappedObject->labelPadding());
2207 }
2208
2209 void PythonQtWrapper_QCPAxis::moveRange(QCPAxis* theWrappedObject, double diff)
2210 {
2211 ( theWrappedObject->moveRange(diff));
2212 }
2213
2214 QString PythonQtWrapper_QCPAxis::numberFormat(QCPAxis* theWrappedObject) const
2215 {
2216 return ( theWrappedObject->numberFormat());
2217 }
2218
2219 int PythonQtWrapper_QCPAxis::numberPrecision(QCPAxis* theWrappedObject) const
2220 {
2221 return ( theWrappedObject->numberPrecision());
2222 }
2223
2224 int PythonQtWrapper_QCPAxis::offset(QCPAxis* theWrappedObject) const
2225 {
2226 return ( theWrappedObject->offset());
2227 }
2228
2229 Qt::Orientation PythonQtWrapper_QCPAxis::orientation(QCPAxis* theWrappedObject) const
2230 {
2231 return ( theWrappedObject->orientation());
2232 }
2233
2234 int PythonQtWrapper_QCPAxis::padding(QCPAxis* theWrappedObject) const
2235 {
2236 return ( theWrappedObject->padding());
2237 }
2238
2239 double PythonQtWrapper_QCPAxis::pixelToCoord(QCPAxis* theWrappedObject, double value) const
2240 {
2241 return ( theWrappedObject->pixelToCoord(value));
2242 }
2243
2244 bool PythonQtWrapper_QCPAxis::rangeReversed(QCPAxis* theWrappedObject) const
2245 {
2246 return ( theWrappedObject->rangeReversed());
2247 }
2248
2249 void PythonQtWrapper_QCPAxis::rescale(QCPAxis* theWrappedObject, bool onlyVisiblePlottables)
2250 {
2251 ( theWrappedObject->rescale(onlyVisiblePlottables));
2252 }
2253
2254 double PythonQtWrapper_QCPAxis::scaleLogBase(QCPAxis* theWrappedObject) const
2255 {
2256 return ( theWrappedObject->scaleLogBase());
2257 }
2258
2259 void PythonQtWrapper_QCPAxis::scaleRange(QCPAxis* theWrappedObject, double factor, double center)
2260 {
2261 ( theWrappedObject->scaleRange(factor, center));
2262 }
2263
2264 void PythonQtWrapper_QCPAxis::selectEvent(QCPAxis* theWrappedObject, QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged)
2265 {
2266 ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_selectEvent(event, additive, details, selectionStateChanged));
2267 }
2268
2269 double PythonQtWrapper_QCPAxis::selectTest(QCPAxis* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details) const
2270 {
2271 return ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_selectTest(pos, onlySelectable, details));
2272 }
2273
2274 QPen PythonQtWrapper_QCPAxis::selectedBasePen(QCPAxis* theWrappedObject) const
2275 {
2276 return ( theWrappedObject->selectedBasePen());
2277 }
2278
2279 QColor PythonQtWrapper_QCPAxis::selectedLabelColor(QCPAxis* theWrappedObject) const
2280 {
2281 return ( theWrappedObject->selectedLabelColor());
2282 }
2283
2284 QFont PythonQtWrapper_QCPAxis::selectedLabelFont(QCPAxis* theWrappedObject) const
2285 {
2286 return ( theWrappedObject->selectedLabelFont());
2287 }
2288
2289 QPen PythonQtWrapper_QCPAxis::selectedSubTickPen(QCPAxis* theWrappedObject) const
2290 {
2291 return ( theWrappedObject->selectedSubTickPen());
2292 }
2293
2294 QColor PythonQtWrapper_QCPAxis::selectedTickLabelColor(QCPAxis* theWrappedObject) const
2295 {
2296 return ( theWrappedObject->selectedTickLabelColor());
2297 }
2298
2299 QFont PythonQtWrapper_QCPAxis::selectedTickLabelFont(QCPAxis* theWrappedObject) const
2300 {
2301 return ( theWrappedObject->selectedTickLabelFont());
2302 }
2303
2304 QPen PythonQtWrapper_QCPAxis::selectedTickPen(QCPAxis* theWrappedObject) const
2305 {
2306 return ( theWrappedObject->selectedTickPen());
2307 }
2308
2309 void PythonQtWrapper_QCPAxis::setAutoSubTicks(QCPAxis* theWrappedObject, bool on)
2310 {
2311 ( theWrappedObject->setAutoSubTicks(on));
2312 }
2313
2314 void PythonQtWrapper_QCPAxis::setAutoTickCount(QCPAxis* theWrappedObject, int approximateCount)
2315 {
2316 ( theWrappedObject->setAutoTickCount(approximateCount));
2317 }
2318
2319 void PythonQtWrapper_QCPAxis::setAutoTickLabels(QCPAxis* theWrappedObject, bool on)
2320 {
2321 ( theWrappedObject->setAutoTickLabels(on));
2322 }
2323
2324 void PythonQtWrapper_QCPAxis::setAutoTickStep(QCPAxis* theWrappedObject, bool on)
2325 {
2326 ( theWrappedObject->setAutoTickStep(on));
2327 }
2328
2329 void PythonQtWrapper_QCPAxis::setAutoTicks(QCPAxis* theWrappedObject, bool on)
2330 {
2331 ( theWrappedObject->setAutoTicks(on));
2332 }
2333
2334 void PythonQtWrapper_QCPAxis::setBasePen(QCPAxis* theWrappedObject, const QPen& pen)
2335 {
2336 ( theWrappedObject->setBasePen(pen));
2337 }
2338
2339 void PythonQtWrapper_QCPAxis::setDateTimeFormat(QCPAxis* theWrappedObject, const QString& format)
2340 {
2341 ( theWrappedObject->setDateTimeFormat(format));
2342 }
2343
2344 void PythonQtWrapper_QCPAxis::setDateTimeSpec(QCPAxis* theWrappedObject, const Qt::TimeSpec& timeSpec)
2345 {
2346 ( theWrappedObject->setDateTimeSpec(timeSpec));
2347 }
2348
2349 void PythonQtWrapper_QCPAxis::setLabel(QCPAxis* theWrappedObject, const QString& str)
2350 {
2351 ( theWrappedObject->setLabel(str));
2352 }
2353
2354 void PythonQtWrapper_QCPAxis::setLabelColor(QCPAxis* theWrappedObject, const QColor& color)
2355 {
2356 ( theWrappedObject->setLabelColor(color));
2357 }
2358
2359 void PythonQtWrapper_QCPAxis::setLabelFont(QCPAxis* theWrappedObject, const QFont& font)
2360 {
2361 ( theWrappedObject->setLabelFont(font));
2362 }
2363
2364 void PythonQtWrapper_QCPAxis::setLabelPadding(QCPAxis* theWrappedObject, int padding)
2365 {
2366 ( theWrappedObject->setLabelPadding(padding));
2367 }
2368
2369 void PythonQtWrapper_QCPAxis::setNumberFormat(QCPAxis* theWrappedObject, const QString& formatCode)
2370 {
2371 ( theWrappedObject->setNumberFormat(formatCode));
2372 }
2373
2374 void PythonQtWrapper_QCPAxis::setNumberPrecision(QCPAxis* theWrappedObject, int precision)
2375 {
2376 ( theWrappedObject->setNumberPrecision(precision));
2377 }
2378
2379 void PythonQtWrapper_QCPAxis::setOffset(QCPAxis* theWrappedObject, int offset)
2380 {
2381 ( theWrappedObject->setOffset(offset));
2382 }
2383
2384 void PythonQtWrapper_QCPAxis::setPadding(QCPAxis* theWrappedObject, int padding)
2385 {
2386 ( theWrappedObject->setPadding(padding));
2387 }
2388
2389 void PythonQtWrapper_QCPAxis::setRange(QCPAxis* theWrappedObject, double lower, double upper)
2390 {
2391 ( theWrappedObject->setRange(lower, upper));
2392 }
2393
2394 void PythonQtWrapper_QCPAxis::setRange(QCPAxis* theWrappedObject, double position, double size, Qt::AlignmentFlag alignment)
2395 {
2396 ( theWrappedObject->setRange(position, size, alignment));
2397 }
2398
2399 void PythonQtWrapper_QCPAxis::setRangeLower(QCPAxis* theWrappedObject, double lower)
2400 {
2401 ( theWrappedObject->setRangeLower(lower));
2402 }
2403
2404 void PythonQtWrapper_QCPAxis::setRangeReversed(QCPAxis* theWrappedObject, bool reversed)
2405 {
2406 ( theWrappedObject->setRangeReversed(reversed));
2407 }
2408
2409 void PythonQtWrapper_QCPAxis::setRangeUpper(QCPAxis* theWrappedObject, double upper)
2410 {
2411 ( theWrappedObject->setRangeUpper(upper));
2412 }
2413
2414 void PythonQtWrapper_QCPAxis::setScaleLogBase(QCPAxis* theWrappedObject, double base)
2415 {
2416 ( theWrappedObject->setScaleLogBase(base));
2417 }
2418
2419 void PythonQtWrapper_QCPAxis::setScaleRatio(QCPAxis* theWrappedObject, const QCPAxis* otherAxis, double ratio)
2420 {
2421 ( theWrappedObject->setScaleRatio(otherAxis, ratio));
2422 }
2423
2424 void PythonQtWrapper_QCPAxis::setSelectedBasePen(QCPAxis* theWrappedObject, const QPen& pen)
2425 {
2426 ( theWrappedObject->setSelectedBasePen(pen));
2427 }
2428
2429 void PythonQtWrapper_QCPAxis::setSelectedLabelColor(QCPAxis* theWrappedObject, const QColor& color)
2430 {
2431 ( theWrappedObject->setSelectedLabelColor(color));
2432 }
2433
2434 void PythonQtWrapper_QCPAxis::setSelectedLabelFont(QCPAxis* theWrappedObject, const QFont& font)
2435 {
2436 ( theWrappedObject->setSelectedLabelFont(font));
2437 }
2438
2439 void PythonQtWrapper_QCPAxis::setSelectedSubTickPen(QCPAxis* theWrappedObject, const QPen& pen)
2440 {
2441 ( theWrappedObject->setSelectedSubTickPen(pen));
2442 }
2443
2444 void PythonQtWrapper_QCPAxis::setSelectedTickLabelColor(QCPAxis* theWrappedObject, const QColor& color)
2445 {
2446 ( theWrappedObject->setSelectedTickLabelColor(color));
2447 }
2448
2449 void PythonQtWrapper_QCPAxis::setSelectedTickLabelFont(QCPAxis* theWrappedObject, const QFont& font)
2450 {
2451 ( theWrappedObject->setSelectedTickLabelFont(font));
2452 }
2453
2454 void PythonQtWrapper_QCPAxis::setSelectedTickPen(QCPAxis* theWrappedObject, const QPen& pen)
2455 {
2456 ( theWrappedObject->setSelectedTickPen(pen));
2457 }
2458
2459 void PythonQtWrapper_QCPAxis::setSubTickCount(QCPAxis* theWrappedObject, int count)
2460 {
2461 ( theWrappedObject->setSubTickCount(count));
2462 }
2463
2464 void PythonQtWrapper_QCPAxis::setSubTickLength(QCPAxis* theWrappedObject, int inside, int outside)
2465 {
2466 ( theWrappedObject->setSubTickLength(inside, outside));
2467 }
2468
2469 void PythonQtWrapper_QCPAxis::setSubTickLengthIn(QCPAxis* theWrappedObject, int inside)
2470 {
2471 ( theWrappedObject->setSubTickLengthIn(inside));
2472 }
2473
2474 void PythonQtWrapper_QCPAxis::setSubTickLengthOut(QCPAxis* theWrappedObject, int outside)
2475 {
2476 ( theWrappedObject->setSubTickLengthOut(outside));
2477 }
2478
2479 void PythonQtWrapper_QCPAxis::setSubTickPen(QCPAxis* theWrappedObject, const QPen& pen)
2480 {
2481 ( theWrappedObject->setSubTickPen(pen));
2482 }
2483
2484 void PythonQtWrapper_QCPAxis::setTickLabelColor(QCPAxis* theWrappedObject, const QColor& color)
2485 {
2486 ( theWrappedObject->setTickLabelColor(color));
2487 }
2488
2489 void PythonQtWrapper_QCPAxis::setTickLabelFont(QCPAxis* theWrappedObject, const QFont& font)
2490 {
2491 ( theWrappedObject->setTickLabelFont(font));
2492 }
2493
2494 void PythonQtWrapper_QCPAxis::setTickLabelPadding(QCPAxis* theWrappedObject, int padding)
2495 {
2496 ( theWrappedObject->setTickLabelPadding(padding));
2497 }
2498
2499 void PythonQtWrapper_QCPAxis::setTickLabelRotation(QCPAxis* theWrappedObject, double degrees)
2500 {
2501 ( theWrappedObject->setTickLabelRotation(degrees));
2502 }
2503
2504 void PythonQtWrapper_QCPAxis::setTickLabels(QCPAxis* theWrappedObject, bool show)
2505 {
2506 ( theWrappedObject->setTickLabels(show));
2507 }
2508
2509 void PythonQtWrapper_QCPAxis::setTickLength(QCPAxis* theWrappedObject, int inside, int outside)
2510 {
2511 ( theWrappedObject->setTickLength(inside, outside));
2512 }
2513
2514 void PythonQtWrapper_QCPAxis::setTickLengthIn(QCPAxis* theWrappedObject, int inside)
2515 {
2516 ( theWrappedObject->setTickLengthIn(inside));
2517 }
2518
2519 void PythonQtWrapper_QCPAxis::setTickLengthOut(QCPAxis* theWrappedObject, int outside)
2520 {
2521 ( theWrappedObject->setTickLengthOut(outside));
2522 }
2523
2524 void PythonQtWrapper_QCPAxis::setTickPen(QCPAxis* theWrappedObject, const QPen& pen)
2525 {
2526 ( theWrappedObject->setTickPen(pen));
2527 }
2528
2529 void PythonQtWrapper_QCPAxis::setTickStep(QCPAxis* theWrappedObject, double step)
2530 {
2531 ( theWrappedObject->setTickStep(step));
2532 }
2533
2534 void PythonQtWrapper_QCPAxis::setTickVector(QCPAxis* theWrappedObject, const QVector<double >& vec)
2535 {
2536 ( theWrappedObject->setTickVector(vec));
2537 }
2538
2539 void PythonQtWrapper_QCPAxis::setTickVectorLabels(QCPAxis* theWrappedObject, const QVector<QString >& vec)
2540 {
2541 ( theWrappedObject->setTickVectorLabels(vec));
2542 }
2543
2544 void PythonQtWrapper_QCPAxis::setTicks(QCPAxis* theWrappedObject, bool show)
2545 {
2546 ( theWrappedObject->setTicks(show));
2547 }
2548
2549 void PythonQtWrapper_QCPAxis::setupTickVectors(QCPAxis* theWrappedObject)
2550 {
2551 ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_setupTickVectors());
2552 }
2553
2554 int PythonQtWrapper_QCPAxis::subTickCount(QCPAxis* theWrappedObject) const
2555 {
2556 return ( theWrappedObject->subTickCount());
2557 }
2558
2559 int PythonQtWrapper_QCPAxis::subTickLengthIn(QCPAxis* theWrappedObject) const
2560 {
2561 return ( theWrappedObject->subTickLengthIn());
2562 }
2563
2564 int PythonQtWrapper_QCPAxis::subTickLengthOut(QCPAxis* theWrappedObject) const
2565 {
2566 return ( theWrappedObject->subTickLengthOut());
2567 }
2568
2569 QPen PythonQtWrapper_QCPAxis::subTickPen(QCPAxis* theWrappedObject) const
2570 {
2571 return ( theWrappedObject->subTickPen());
2572 }
2573
2574 QColor PythonQtWrapper_QCPAxis::tickLabelColor(QCPAxis* theWrappedObject) const
2575 {
2576 return ( theWrappedObject->tickLabelColor());
2577 }
2578
2579 QFont PythonQtWrapper_QCPAxis::tickLabelFont(QCPAxis* theWrappedObject) const
2580 {
2581 return ( theWrappedObject->tickLabelFont());
2582 }
2583
2584 int PythonQtWrapper_QCPAxis::tickLabelPadding(QCPAxis* theWrappedObject) const
2585 {
2586 return ( theWrappedObject->tickLabelPadding());
2587 }
2588
2589 double PythonQtWrapper_QCPAxis::tickLabelRotation(QCPAxis* theWrappedObject) const
2590 {
2591 return ( theWrappedObject->tickLabelRotation());
2592 }
2593
2594 bool PythonQtWrapper_QCPAxis::tickLabels(QCPAxis* theWrappedObject) const
2595 {
2596 return ( theWrappedObject->tickLabels());
2597 }
2598
2599 int PythonQtWrapper_QCPAxis::tickLengthIn(QCPAxis* theWrappedObject) const
2600 {
2601 return ( theWrappedObject->tickLengthIn());
2602 }
2603
2604 int PythonQtWrapper_QCPAxis::tickLengthOut(QCPAxis* theWrappedObject) const
2605 {
2606 return ( theWrappedObject->tickLengthOut());
2607 }
2608
2609 QPen PythonQtWrapper_QCPAxis::tickPen(QCPAxis* theWrappedObject) const
2610 {
2611 return ( theWrappedObject->tickPen());
2612 }
2613
2614 double PythonQtWrapper_QCPAxis::tickStep(QCPAxis* theWrappedObject) const
2615 {
2616 return ( theWrappedObject->tickStep());
2617 }
2618
2619 QVector<double > PythonQtWrapper_QCPAxis::tickVector(QCPAxis* theWrappedObject) const
2620 {
2621 return ( theWrappedObject->tickVector());
2622 }
2623
2624 QVector<QString > PythonQtWrapper_QCPAxis::tickVectorLabels(QCPAxis* theWrappedObject) const
2625 {
2626 return ( theWrappedObject->tickVectorLabels());
2627 }
2628
2629 bool PythonQtWrapper_QCPAxis::ticks(QCPAxis* theWrappedObject) const
2630 {
2631 return ( theWrappedObject->ticks());
2632 }
2633
2634 void PythonQtWrapper_QCPAxis::visibleTickBounds(QCPAxis* theWrappedObject, int& lowIndex, int& highIndex) const
2635 {
2636 ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_visibleTickBounds(lowIndex, highIndex));
2637 }
2638
2639
2640
2641 PythonQtShell_QCPAxisRect::~PythonQtShell_QCPAxisRect() {
2642 PythonQtPrivate* priv = PythonQt::priv();
2643 if (priv) { priv->shellClassDeleted(this); }
2644 }
2645 void PythonQtShell_QCPAxisRect::applyDefaultAntialiasingHint(QCPPainter* painter0) const
2646 {
2647 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2648 static PyObject* name = PyString_FromString("applyDefaultAntialiasingHint");
2649 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2650 if (obj) {
2651 static const char* argumentList[] ={"" , "QCPPainter*"};
2652 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2653 void* args[2] = {NULL, (void*)&painter0};
2654 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2655 if (result) { Py_DECREF(result); }
2656 Py_DECREF(obj);
2657 return;
2658 } else {
2659 PyErr_Clear();
2660 }
2661 }
2662 QCPAxisRect::applyDefaultAntialiasingHint(painter0);
2663 }
2664 void PythonQtShell_QCPAxisRect::childEvent(QChildEvent* arg__1)
2665 {
2666 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2667 static PyObject* name = PyString_FromString("childEvent");
2668 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2669 if (obj) {
2670 static const char* argumentList[] ={"" , "QChildEvent*"};
2671 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2672 void* args[2] = {NULL, (void*)&arg__1};
2673 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2674 if (result) { Py_DECREF(result); }
2675 Py_DECREF(obj);
2676 return;
2677 } else {
2678 PyErr_Clear();
2679 }
2680 }
2681 QCPAxisRect::childEvent(arg__1);
2682 }
2683 QRect PythonQtShell_QCPAxisRect::clipRect() const
2684 {
2685 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2686 static PyObject* name = PyString_FromString("clipRect");
2687 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2688 if (obj) {
2689 static const char* argumentList[] ={"QRect"};
2690 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2691 QRect returnValue;
2692 void* args[1] = {NULL};
2693 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2694 if (result) {
2695 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2696 if (args[0]!=&returnValue) {
2697 if (args[0]==NULL) {
2698 PythonQt::priv()->handleVirtualOverloadReturnError("clipRect", methodInfo, result);
2699 } else {
2700 returnValue = *((QRect*)args[0]);
2701 }
2702 }
2703 }
2704 if (result) { Py_DECREF(result); }
2705 Py_DECREF(obj);
2706 return returnValue;
2707 } else {
2708 PyErr_Clear();
2709 }
2710 }
2711 return QCPAxisRect::clipRect();
2712 }
2713 void PythonQtShell_QCPAxisRect::customEvent(QEvent* arg__1)
2714 {
2715 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2716 static PyObject* name = PyString_FromString("customEvent");
2717 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2718 if (obj) {
2719 static const char* argumentList[] ={"" , "QEvent*"};
2720 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2721 void* args[2] = {NULL, (void*)&arg__1};
2722 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2723 if (result) { Py_DECREF(result); }
2724 Py_DECREF(obj);
2725 return;
2726 } else {
2727 PyErr_Clear();
2728 }
2729 }
2730 QCPAxisRect::customEvent(arg__1);
2731 }
2732 void PythonQtShell_QCPAxisRect::deselectEvent(bool* selectionStateChanged0)
2733 {
2734 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2735 static PyObject* name = PyString_FromString("deselectEvent");
2736 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2737 if (obj) {
2738 static const char* argumentList[] ={"" , "bool*"};
2739 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2740 void* args[2] = {NULL, (void*)&selectionStateChanged0};
2741 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2742 if (result) { Py_DECREF(result); }
2743 Py_DECREF(obj);
2744 return;
2745 } else {
2746 PyErr_Clear();
2747 }
2748 }
2749 QCPAxisRect::deselectEvent(selectionStateChanged0);
2750 }
2751 void PythonQtShell_QCPAxisRect::draw(QCPPainter* painter0)
2752 {
2753 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2754 static PyObject* name = PyString_FromString("draw");
2755 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2756 if (obj) {
2757 static const char* argumentList[] ={"" , "QCPPainter*"};
2758 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2759 void* args[2] = {NULL, (void*)&painter0};
2760 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2761 if (result) { Py_DECREF(result); }
2762 Py_DECREF(obj);
2763 return;
2764 } else {
2765 PyErr_Clear();
2766 }
2767 }
2768 QCPAxisRect::draw(painter0);
2769 }
2770 QList<QCPLayoutElement* > PythonQtShell_QCPAxisRect::elements(bool recursive0) const
2771 {
2772 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2773 static PyObject* name = PyString_FromString("elements");
2774 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2775 if (obj) {
2776 static const char* argumentList[] ={"QList<QCPLayoutElement* >" , "bool"};
2777 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2778 QList<QCPLayoutElement* > returnValue;
2779 void* args[2] = {NULL, (void*)&recursive0};
2780 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2781 if (result) {
2782 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2783 if (args[0]!=&returnValue) {
2784 if (args[0]==NULL) {
2785 PythonQt::priv()->handleVirtualOverloadReturnError("elements", methodInfo, result);
2786 } else {
2787 returnValue = *((QList<QCPLayoutElement* >*)args[0]);
2788 }
2789 }
2790 }
2791 if (result) { Py_DECREF(result); }
2792 Py_DECREF(obj);
2793 return returnValue;
2794 } else {
2795 PyErr_Clear();
2796 }
2797 }
2798 return QCPAxisRect::elements(recursive0);
2799 }
2800 bool PythonQtShell_QCPAxisRect::event(QEvent* arg__1)
2801 {
2802 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2803 static PyObject* name = PyString_FromString("event");
2804 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2805 if (obj) {
2806 static const char* argumentList[] ={"bool" , "QEvent*"};
2807 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2808 bool returnValue;
2809 void* args[2] = {NULL, (void*)&arg__1};
2810 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2811 if (result) {
2812 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2813 if (args[0]!=&returnValue) {
2814 if (args[0]==NULL) {
2815 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
2816 } else {
2817 returnValue = *((bool*)args[0]);
2818 }
2819 }
2820 }
2821 if (result) { Py_DECREF(result); }
2822 Py_DECREF(obj);
2823 return returnValue;
2824 } else {
2825 PyErr_Clear();
2826 }
2827 }
2828 return QCPAxisRect::event(arg__1);
2829 }
2830 bool PythonQtShell_QCPAxisRect::eventFilter(QObject* arg__1, QEvent* arg__2)
2831 {
2832 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2833 static PyObject* name = PyString_FromString("eventFilter");
2834 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2835 if (obj) {
2836 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
2837 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
2838 bool returnValue;
2839 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
2840 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2841 if (result) {
2842 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2843 if (args[0]!=&returnValue) {
2844 if (args[0]==NULL) {
2845 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
2846 } else {
2847 returnValue = *((bool*)args[0]);
2848 }
2849 }
2850 }
2851 if (result) { Py_DECREF(result); }
2852 Py_DECREF(obj);
2853 return returnValue;
2854 } else {
2855 PyErr_Clear();
2856 }
2857 }
2858 return QCPAxisRect::eventFilter(arg__1, arg__2);
2859 }
2860 QSize PythonQtShell_QCPAxisRect::maximumSizeHint() const
2861 {
2862 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2863 static PyObject* name = PyString_FromString("maximumSizeHint");
2864 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2865 if (obj) {
2866 static const char* argumentList[] ={"QSize"};
2867 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2868 QSize returnValue;
2869 void* args[1] = {NULL};
2870 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2871 if (result) {
2872 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2873 if (args[0]!=&returnValue) {
2874 if (args[0]==NULL) {
2875 PythonQt::priv()->handleVirtualOverloadReturnError("maximumSizeHint", methodInfo, result);
2876 } else {
2877 returnValue = *((QSize*)args[0]);
2878 }
2879 }
2880 }
2881 if (result) { Py_DECREF(result); }
2882 Py_DECREF(obj);
2883 return returnValue;
2884 } else {
2885 PyErr_Clear();
2886 }
2887 }
2888 return QCPAxisRect::maximumSizeHint();
2889 }
2890 QSize PythonQtShell_QCPAxisRect::minimumSizeHint() const
2891 {
2892 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2893 static PyObject* name = PyString_FromString("minimumSizeHint");
2894 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2895 if (obj) {
2896 static const char* argumentList[] ={"QSize"};
2897 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2898 QSize returnValue;
2899 void* args[1] = {NULL};
2900 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2901 if (result) {
2902 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2903 if (args[0]!=&returnValue) {
2904 if (args[0]==NULL) {
2905 PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result);
2906 } else {
2907 returnValue = *((QSize*)args[0]);
2908 }
2909 }
2910 }
2911 if (result) { Py_DECREF(result); }
2912 Py_DECREF(obj);
2913 return returnValue;
2914 } else {
2915 PyErr_Clear();
2916 }
2917 }
2918 return QCPAxisRect::minimumSizeHint();
2919 }
2920 void PythonQtShell_QCPAxisRect::mouseDoubleClickEvent(QMouseEvent* event0)
2921 {
2922 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2923 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
2924 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2925 if (obj) {
2926 static const char* argumentList[] ={"" , "QMouseEvent*"};
2927 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2928 void* args[2] = {NULL, (void*)&event0};
2929 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2930 if (result) { Py_DECREF(result); }
2931 Py_DECREF(obj);
2932 return;
2933 } else {
2934 PyErr_Clear();
2935 }
2936 }
2937 QCPAxisRect::mouseDoubleClickEvent(event0);
2938 }
2939 void PythonQtShell_QCPAxisRect::mouseMoveEvent(QMouseEvent* event0)
2940 {
2941 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2942 static PyObject* name = PyString_FromString("mouseMoveEvent");
2943 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2944 if (obj) {
2945 static const char* argumentList[] ={"" , "QMouseEvent*"};
2946 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2947 void* args[2] = {NULL, (void*)&event0};
2948 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2949 if (result) { Py_DECREF(result); }
2950 Py_DECREF(obj);
2951 return;
2952 } else {
2953 PyErr_Clear();
2954 }
2955 }
2956 QCPAxisRect::mouseMoveEvent(event0);
2957 }
2958 void PythonQtShell_QCPAxisRect::mousePressEvent(QMouseEvent* event0)
2959 {
2960 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2961 static PyObject* name = PyString_FromString("mousePressEvent");
2962 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2963 if (obj) {
2964 static const char* argumentList[] ={"" , "QMouseEvent*"};
2965 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2966 void* args[2] = {NULL, (void*)&event0};
2967 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2968 if (result) { Py_DECREF(result); }
2969 Py_DECREF(obj);
2970 return;
2971 } else {
2972 PyErr_Clear();
2973 }
2974 }
2975 QCPAxisRect::mousePressEvent(event0);
2976 }
2977 void PythonQtShell_QCPAxisRect::mouseReleaseEvent(QMouseEvent* event0)
2978 {
2979 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2980 static PyObject* name = PyString_FromString("mouseReleaseEvent");
2981 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2982 if (obj) {
2983 static const char* argumentList[] ={"" , "QMouseEvent*"};
2984 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2985 void* args[2] = {NULL, (void*)&event0};
2986 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2987 if (result) { Py_DECREF(result); }
2988 Py_DECREF(obj);
2989 return;
2990 } else {
2991 PyErr_Clear();
2992 }
2993 }
2994 QCPAxisRect::mouseReleaseEvent(event0);
2995 }
2996 void PythonQtShell_QCPAxisRect::parentPlotInitialized(QCustomPlot* parentPlot0)
2997 {
2998 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2999 static PyObject* name = PyString_FromString("parentPlotInitialized");
3000 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3001 if (obj) {
3002 static const char* argumentList[] ={"" , "QCustomPlot*"};
3003 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3004 void* args[2] = {NULL, (void*)&parentPlot0};
3005 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3006 if (result) { Py_DECREF(result); }
3007 Py_DECREF(obj);
3008 return;
3009 } else {
3010 PyErr_Clear();
3011 }
3012 }
3013 QCPAxisRect::parentPlotInitialized(parentPlot0);
3014 }
3015 void PythonQtShell_QCPAxisRect::selectEvent(QMouseEvent* event0, bool additive1, const QVariant& details2, bool* selectionStateChanged3)
3016 {
3017 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3018 static PyObject* name = PyString_FromString("selectEvent");
3019 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3020 if (obj) {
3021 static const char* argumentList[] ={"" , "QMouseEvent*" , "bool" , "const QVariant&" , "bool*"};
3022 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList);
3023 void* args[5] = {NULL, (void*)&event0, (void*)&additive1, (void*)&details2, (void*)&selectionStateChanged3};
3024 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3025 if (result) { Py_DECREF(result); }
3026 Py_DECREF(obj);
3027 return;
3028 } else {
3029 PyErr_Clear();
3030 }
3031 }
3032 QCPAxisRect::selectEvent(event0, additive1, details2, selectionStateChanged3);
3033 }
3034 double PythonQtShell_QCPAxisRect::selectTest(const QPointF& pos0, bool onlySelectable1, QVariant* details2) const
3035 {
3036 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3037 static PyObject* name = PyString_FromString("selectTest");
3038 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3039 if (obj) {
3040 static const char* argumentList[] ={"double" , "const QPointF&" , "bool" , "QVariant*"};
3041 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
3042 double returnValue;
3043 void* args[4] = {NULL, (void*)&pos0, (void*)&onlySelectable1, (void*)&details2};
3044 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3045 if (result) {
3046 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3047 if (args[0]!=&returnValue) {
3048 if (args[0]==NULL) {
3049 PythonQt::priv()->handleVirtualOverloadReturnError("selectTest", methodInfo, result);
3050 } else {
3051 returnValue = *((double*)args[0]);
3052 }
3053 }
3054 }
3055 if (result) { Py_DECREF(result); }
3056 Py_DECREF(obj);
3057 return returnValue;
3058 } else {
3059 PyErr_Clear();
3060 }
3061 }
3062 return QCPAxisRect::selectTest(pos0, onlySelectable1, details2);
3063 }
3064 void PythonQtShell_QCPAxisRect::timerEvent(QTimerEvent* arg__1)
3065 {
3066 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3067 static PyObject* name = PyString_FromString("timerEvent");
3068 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3069 if (obj) {
3070 static const char* argumentList[] ={"" , "QTimerEvent*"};
3071 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3072 void* args[2] = {NULL, (void*)&arg__1};
3073 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3074 if (result) { Py_DECREF(result); }
3075 Py_DECREF(obj);
3076 return;
3077 } else {
3078 PyErr_Clear();
3079 }
3080 }
3081 QCPAxisRect::timerEvent(arg__1);
3082 }
3083 void PythonQtShell_QCPAxisRect::wheelEvent(QWheelEvent* event0)
3084 {
3085 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3086 static PyObject* name = PyString_FromString("wheelEvent");
3087 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3088 if (obj) {
3089 static const char* argumentList[] ={"" , "QWheelEvent*"};
3090 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3091 void* args[2] = {NULL, (void*)&event0};
3092 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3093 if (result) { Py_DECREF(result); }
3094 Py_DECREF(obj);
3095 return;
3096 } else {
3097 PyErr_Clear();
3098 }
3099 }
3100 QCPAxisRect::wheelEvent(event0);
3101 }
3102 QCPAxisRect* PythonQtWrapper_QCPAxisRect::new_QCPAxisRect(QCustomPlot* parentPlot, bool setupDefaultAxes)
3103 {
3104 return new PythonQtShell_QCPAxisRect(parentPlot, setupDefaultAxes); }
3105
3106 void PythonQtWrapper_QCPAxisRect::applyDefaultAntialiasingHint(QCPAxisRect* theWrappedObject, QCPPainter* painter) const
3107 {
3108 ( ((PythonQtPublicPromoter_QCPAxisRect*)theWrappedObject)->promoted_applyDefaultAntialiasingHint(painter));
3109 }
3110
3111 QList<QCPAxis* > PythonQtWrapper_QCPAxisRect::axes(QCPAxisRect* theWrappedObject) const
3112 {
3113 return ( theWrappedObject->axes());
3114 }
3115
3116 QPixmap PythonQtWrapper_QCPAxisRect::background(QCPAxisRect* theWrappedObject) const
3117 {
3118 return ( theWrappedObject->background());
3119 }
3120
3121 bool PythonQtWrapper_QCPAxisRect::backgroundScaled(QCPAxisRect* theWrappedObject) const
3122 {
3123 return ( theWrappedObject->backgroundScaled());
3124 }
3125
3126 Qt::AspectRatioMode PythonQtWrapper_QCPAxisRect::backgroundScaledMode(QCPAxisRect* theWrappedObject) const
3127 {
3128 return ( theWrappedObject->backgroundScaledMode());
3129 }
3130
3131 int PythonQtWrapper_QCPAxisRect::bottom(QCPAxisRect* theWrappedObject) const
3132 {
3133 return ( theWrappedObject->bottom());
3134 }
3135
3136 QPoint PythonQtWrapper_QCPAxisRect::bottomLeft(QCPAxisRect* theWrappedObject) const
3137 {
3138 return ( theWrappedObject->bottomLeft());
3139 }
3140
3141 QPoint PythonQtWrapper_QCPAxisRect::bottomRight(QCPAxisRect* theWrappedObject) const
3142 {
3143 return ( theWrappedObject->bottomRight());
3144 }
3145
3146 QPoint PythonQtWrapper_QCPAxisRect::center(QCPAxisRect* theWrappedObject) const
3147 {
3148 return ( theWrappedObject->center());
3149 }
3150
3151 void PythonQtWrapper_QCPAxisRect::draw(QCPAxisRect* theWrappedObject, QCPPainter* painter)
3152 {
3153 ( ((PythonQtPublicPromoter_QCPAxisRect*)theWrappedObject)->promoted_draw(painter));
3154 }
3155
3156 void PythonQtWrapper_QCPAxisRect::drawBackground(QCPAxisRect* theWrappedObject, QCPPainter* painter)
3157 {
3158 ( ((PythonQtPublicPromoter_QCPAxisRect*)theWrappedObject)->promoted_drawBackground(painter));
3159 }
3160
3161 QList<QCPLayoutElement* > PythonQtWrapper_QCPAxisRect::elements(QCPAxisRect* theWrappedObject, bool recursive) const
3162 {
3163 return ( ((PythonQtPublicPromoter_QCPAxisRect*)theWrappedObject)->promoted_elements(recursive));
3164 }
3165
3166 QList<QCPGraph* > PythonQtWrapper_QCPAxisRect::graphs(QCPAxisRect* theWrappedObject) const
3167 {
3168 return ( theWrappedObject->graphs());
3169 }
3170
3171 int PythonQtWrapper_QCPAxisRect::height(QCPAxisRect* theWrappedObject) const
3172 {
3173 return ( theWrappedObject->height());
3174 }
3175
3176 QList<QCPAbstractItem* > PythonQtWrapper_QCPAxisRect::items(QCPAxisRect* theWrappedObject) const
3177 {
3178 return ( theWrappedObject->items());
3179 }
3180
3181 int PythonQtWrapper_QCPAxisRect::left(QCPAxisRect* theWrappedObject) const
3182 {
3183 return ( theWrappedObject->left());
3184 }
3185
3186 void PythonQtWrapper_QCPAxisRect::mouseMoveEvent(QCPAxisRect* theWrappedObject, QMouseEvent* event)
3187 {
3188 ( ((PythonQtPublicPromoter_QCPAxisRect*)theWrappedObject)->promoted_mouseMoveEvent(event));
3189 }
3190
3191 void PythonQtWrapper_QCPAxisRect::mousePressEvent(QCPAxisRect* theWrappedObject, QMouseEvent* event)
3192 {
3193 ( ((PythonQtPublicPromoter_QCPAxisRect*)theWrappedObject)->promoted_mousePressEvent(event));
3194 }
3195
3196 void PythonQtWrapper_QCPAxisRect::mouseReleaseEvent(QCPAxisRect* theWrappedObject, QMouseEvent* event)
3197 {
3198 ( ((PythonQtPublicPromoter_QCPAxisRect*)theWrappedObject)->promoted_mouseReleaseEvent(event));
3199 }
3200
3201 Qt::Orientations PythonQtWrapper_QCPAxisRect::rangeDrag(QCPAxisRect* theWrappedObject) const
3202 {
3203 return ( theWrappedObject->rangeDrag());
3204 }
3205
3206 QCPAxis* PythonQtWrapper_QCPAxisRect::rangeDragAxis(QCPAxisRect* theWrappedObject, Qt::Orientation orientation)
3207 {
3208 return ( theWrappedObject->rangeDragAxis(orientation));
3209 }
3210
3211 Qt::Orientations PythonQtWrapper_QCPAxisRect::rangeZoom(QCPAxisRect* theWrappedObject) const
3212 {
3213 return ( theWrappedObject->rangeZoom());
3214 }
3215
3216 QCPAxis* PythonQtWrapper_QCPAxisRect::rangeZoomAxis(QCPAxisRect* theWrappedObject, Qt::Orientation orientation)
3217 {
3218 return ( theWrappedObject->rangeZoomAxis(orientation));
3219 }
3220
3221 double PythonQtWrapper_QCPAxisRect::rangeZoomFactor(QCPAxisRect* theWrappedObject, Qt::Orientation orientation)
3222 {
3223 return ( theWrappedObject->rangeZoomFactor(orientation));
3224 }
3225
3226 bool PythonQtWrapper_QCPAxisRect::removeAxis(QCPAxisRect* theWrappedObject, QCPAxis* axis)
3227 {
3228 return ( theWrappedObject->removeAxis(axis));
3229 }
3230
3231 int PythonQtWrapper_QCPAxisRect::right(QCPAxisRect* theWrappedObject) const
3232 {
3233 return ( theWrappedObject->right());
3234 }
3235
3236 void PythonQtWrapper_QCPAxisRect::setBackground(QCPAxisRect* theWrappedObject, const QBrush& brush)
3237 {
3238 ( theWrappedObject->setBackground(brush));
3239 }
3240
3241 void PythonQtWrapper_QCPAxisRect::setBackground(QCPAxisRect* theWrappedObject, const QPixmap& pm)
3242 {
3243 ( theWrappedObject->setBackground(pm));
3244 }
3245
3246 void PythonQtWrapper_QCPAxisRect::setBackground(QCPAxisRect* theWrappedObject, const QPixmap& pm, bool scaled, Qt::AspectRatioMode mode)
3247 {
3248 ( theWrappedObject->setBackground(pm, scaled, mode));
3249 }
3250
3251 void PythonQtWrapper_QCPAxisRect::setBackgroundScaled(QCPAxisRect* theWrappedObject, bool scaled)
3252 {
3253 ( theWrappedObject->setBackgroundScaled(scaled));
3254 }
3255
3256 void PythonQtWrapper_QCPAxisRect::setBackgroundScaledMode(QCPAxisRect* theWrappedObject, Qt::AspectRatioMode mode)
3257 {
3258 ( theWrappedObject->setBackgroundScaledMode(mode));
3259 }
3260
3261 void PythonQtWrapper_QCPAxisRect::setRangeDrag(QCPAxisRect* theWrappedObject, Qt::Orientations orientations)
3262 {
3263 ( theWrappedObject->setRangeDrag(orientations));
3264 }
3265
3266 void PythonQtWrapper_QCPAxisRect::setRangeDragAxes(QCPAxisRect* theWrappedObject, QCPAxis* horizontal, QCPAxis* vertical)
3267 {
3268 ( theWrappedObject->setRangeDragAxes(horizontal, vertical));
3269 }
3270
3271 void PythonQtWrapper_QCPAxisRect::setRangeZoom(QCPAxisRect* theWrappedObject, Qt::Orientations orientations)
3272 {
3273 ( theWrappedObject->setRangeZoom(orientations));
3274 }
3275
3276 void PythonQtWrapper_QCPAxisRect::setRangeZoomAxes(QCPAxisRect* theWrappedObject, QCPAxis* horizontal, QCPAxis* vertical)
3277 {
3278 ( theWrappedObject->setRangeZoomAxes(horizontal, vertical));
3279 }
3280
3281 void PythonQtWrapper_QCPAxisRect::setRangeZoomFactor(QCPAxisRect* theWrappedObject, double factor)
3282 {
3283 ( theWrappedObject->setRangeZoomFactor(factor));
3284 }
3285
3286 void PythonQtWrapper_QCPAxisRect::setRangeZoomFactor(QCPAxisRect* theWrappedObject, double horizontalFactor, double verticalFactor)
3287 {
3288 ( theWrappedObject->setRangeZoomFactor(horizontalFactor, verticalFactor));
3289 }
3290
3291 void PythonQtWrapper_QCPAxisRect::setupFullAxesBox(QCPAxisRect* theWrappedObject, bool connectRanges)
3292 {
3293 ( theWrappedObject->setupFullAxesBox(connectRanges));
3294 }
3295
3296 QSize PythonQtWrapper_QCPAxisRect::size(QCPAxisRect* theWrappedObject) const
3297 {
3298 return ( theWrappedObject->size());
3299 }
3300
3301 int PythonQtWrapper_QCPAxisRect::top(QCPAxisRect* theWrappedObject) const
3302 {
3303 return ( theWrappedObject->top());
3304 }
3305
3306 QPoint PythonQtWrapper_QCPAxisRect::topLeft(QCPAxisRect* theWrappedObject) const
3307 {
3308 return ( theWrappedObject->topLeft());
3309 }
3310
3311 QPoint PythonQtWrapper_QCPAxisRect::topRight(QCPAxisRect* theWrappedObject) const
3312 {
3313 return ( theWrappedObject->topRight());
3314 }
3315
3316 void PythonQtWrapper_QCPAxisRect::wheelEvent(QCPAxisRect* theWrappedObject, QWheelEvent* event)
3317 {
3318 ( ((PythonQtPublicPromoter_QCPAxisRect*)theWrappedObject)->promoted_wheelEvent(event));
3319 }
3320
3321 int PythonQtWrapper_QCPAxisRect::width(QCPAxisRect* theWrappedObject) const
3322 {
3323 return ( theWrappedObject->width());
3324 }
3325
3326
3327
3328 PythonQtShell_QCPBars::~PythonQtShell_QCPBars() {
3329 PythonQtPrivate* priv = PythonQt::priv();
3330 if (priv) { priv->shellClassDeleted(this); }
3331 }
3332 void PythonQtShell_QCPBars::clearData()
3333 {
3334 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3335 static PyObject* name = PyString_FromString("clearData");
3336 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3337 if (obj) {
3338 static const char* argumentList[] ={""};
3339 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3340 void* args[1] = {NULL};
3341 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3342 if (result) { Py_DECREF(result); }
3343 Py_DECREF(obj);
3344 return;
3345 } else {
3346 PyErr_Clear();
3347 }
3348 }
3349 QCPBars::clearData();
3350 }
3351 void PythonQtShell_QCPBars::draw(QCPPainter* painter0)
3352 {
3353 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3354 static PyObject* name = PyString_FromString("draw");
3355 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3356 if (obj) {
3357 static const char* argumentList[] ={"" , "QCPPainter*"};
3358 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3359 void* args[2] = {NULL, (void*)&painter0};
3360 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3361 if (result) { Py_DECREF(result); }
3362 Py_DECREF(obj);
3363 return;
3364 } else {
3365 PyErr_Clear();
3366 }
3367 }
3368 QCPBars::draw(painter0);
3369 }
3370 void PythonQtShell_QCPBars::drawLegendIcon(QCPPainter* painter0, const QRectF& rect1) const
3371 {
3372 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3373 static PyObject* name = PyString_FromString("drawLegendIcon");
3374 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3375 if (obj) {
3376 static const char* argumentList[] ={"" , "QCPPainter*" , "const QRectF&"};
3377 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
3378 void* args[3] = {NULL, (void*)&painter0, (void*)&rect1};
3379 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3380 if (result) { Py_DECREF(result); }
3381 Py_DECREF(obj);
3382 return;
3383 } else {
3384 PyErr_Clear();
3385 }
3386 }
3387 QCPBars::drawLegendIcon(painter0, rect1);
3388 }
3389 double PythonQtShell_QCPBars::selectTest(const QPointF& pos0, bool onlySelectable1, QVariant* details2) const
3390 {
3391 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3392 static PyObject* name = PyString_FromString("selectTest");
3393 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3394 if (obj) {
3395 static const char* argumentList[] ={"double" , "const QPointF&" , "bool" , "QVariant*"};
3396 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
3397 double returnValue;
3398 void* args[4] = {NULL, (void*)&pos0, (void*)&onlySelectable1, (void*)&details2};
3399 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3400 if (result) {
3401 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3402 if (args[0]!=&returnValue) {
3403 if (args[0]==NULL) {
3404 PythonQt::priv()->handleVirtualOverloadReturnError("selectTest", methodInfo, result);
3405 } else {
3406 returnValue = *((double*)args[0]);
3407 }
3408 }
3409 }
3410 if (result) { Py_DECREF(result); }
3411 Py_DECREF(obj);
3412 return returnValue;
3413 } else {
3414 PyErr_Clear();
3415 }
3416 }
3417 return QCPBars::selectTest(pos0, onlySelectable1, details2);
3418 }
3419 QCPBars* PythonQtWrapper_QCPBars::new_QCPBars(QCPAxis* keyAxis, QCPAxis* valueAxis)
3420 {
3421 return new PythonQtShell_QCPBars(keyAxis, valueAxis); }
3422
3423 void PythonQtWrapper_QCPBars::addData(QCPBars* theWrappedObject, const QVector<double >& keys, const QVector<double >& values)
3424 {
3425 ( theWrappedObject->addData(keys, values));
3426 }
3427
3428 void PythonQtWrapper_QCPBars::addData(QCPBars* theWrappedObject, double key, double value)
3429 {
3430 ( theWrappedObject->addData(key, value));
3431 }
3432
3433 QCPBars* PythonQtWrapper_QCPBars::barAbove(QCPBars* theWrappedObject) const
3434 {
3435 return ( theWrappedObject->barAbove());
3436 }
3437
3438 QCPBars* PythonQtWrapper_QCPBars::barBelow(QCPBars* theWrappedObject) const
3439 {
3440 return ( theWrappedObject->barBelow());
3441 }
3442
3443 double PythonQtWrapper_QCPBars::baseValue(QCPBars* theWrappedObject) const
3444 {
3445 return ( theWrappedObject->baseValue());
3446 }
3447
3448 void PythonQtWrapper_QCPBars::clearData(QCPBars* theWrappedObject)
3449 {
3450 ( ((PythonQtPublicPromoter_QCPBars*)theWrappedObject)->promoted_clearData());
3451 }
3452
3453 void PythonQtWrapper_QCPBars::static_QCPBars_connectBars(QCPBars* lower, QCPBars* upper)
3454 {
3455 (PythonQtPublicPromoter_QCPBars::promoted_connectBars(lower, upper));
3456 }
3457
3458 void PythonQtWrapper_QCPBars::draw(QCPBars* theWrappedObject, QCPPainter* painter)
3459 {
3460 ( ((PythonQtPublicPromoter_QCPBars*)theWrappedObject)->promoted_draw(painter));
3461 }
3462
3463 void PythonQtWrapper_QCPBars::drawLegendIcon(QCPBars* theWrappedObject, QCPPainter* painter, const QRectF& rect) const
3464 {
3465 ( ((PythonQtPublicPromoter_QCPBars*)theWrappedObject)->promoted_drawLegendIcon(painter, rect));
3466 }
3467
3468 QPolygonF PythonQtWrapper_QCPBars::getBarPolygon(QCPBars* theWrappedObject, double key, double value) const
3469 {
3470 return ( ((PythonQtPublicPromoter_QCPBars*)theWrappedObject)->promoted_getBarPolygon(key, value));
3471 }
3472
3473 void PythonQtWrapper_QCPBars::getPixelWidth(QCPBars* theWrappedObject, double key, double& lower, double& upper) const
3474 {
3475 ( ((PythonQtPublicPromoter_QCPBars*)theWrappedObject)->promoted_getPixelWidth(key, lower, upper));
3476 }
3477
3478 double PythonQtWrapper_QCPBars::getStackedBaseValue(QCPBars* theWrappedObject, double key, bool positive) const
3479 {
3480 return ( ((PythonQtPublicPromoter_QCPBars*)theWrappedObject)->promoted_getStackedBaseValue(key, positive));
3481 }
3482
3483 void PythonQtWrapper_QCPBars::moveAbove(QCPBars* theWrappedObject, QCPBars* bars)
3484 {
3485 ( theWrappedObject->moveAbove(bars));
3486 }
3487
3488 void PythonQtWrapper_QCPBars::moveBelow(QCPBars* theWrappedObject, QCPBars* bars)
3489 {
3490 ( theWrappedObject->moveBelow(bars));
3491 }
3492
3493 void PythonQtWrapper_QCPBars::removeData(QCPBars* theWrappedObject, double fromKey, double toKey)
3494 {
3495 ( theWrappedObject->removeData(fromKey, toKey));
3496 }
3497
3498 void PythonQtWrapper_QCPBars::removeData(QCPBars* theWrappedObject, double key)
3499 {
3500 ( theWrappedObject->removeData(key));
3501 }
3502
3503 void PythonQtWrapper_QCPBars::removeDataAfter(QCPBars* theWrappedObject, double key)
3504 {
3505 ( theWrappedObject->removeDataAfter(key));
3506 }
3507
3508 void PythonQtWrapper_QCPBars::removeDataBefore(QCPBars* theWrappedObject, double key)
3509 {
3510 ( theWrappedObject->removeDataBefore(key));
3511 }
3512
3513 double PythonQtWrapper_QCPBars::selectTest(QCPBars* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details) const
3514 {
3515 return ( ((PythonQtPublicPromoter_QCPBars*)theWrappedObject)->promoted_selectTest(pos, onlySelectable, details));
3516 }
3517
3518 void PythonQtWrapper_QCPBars::setBaseValue(QCPBars* theWrappedObject, double baseValue)
3519 {
3520 ( theWrappedObject->setBaseValue(baseValue));
3521 }
3522
3523 void PythonQtWrapper_QCPBars::setData(QCPBars* theWrappedObject, const QVector<double >& key, const QVector<double >& value)
3524 {
3525 ( theWrappedObject->setData(key, value));
3526 }
3527
3528 void PythonQtWrapper_QCPBars::setWidth(QCPBars* theWrappedObject, double width)
3529 {
3530 ( theWrappedObject->setWidth(width));
3531 }
3532
3533 double PythonQtWrapper_QCPBars::width(QCPBars* theWrappedObject) const
3534 {
3535 return ( theWrappedObject->width());
3536 }
3537
3538
3539
3540 PythonQtShell_QCPColorMap::~PythonQtShell_QCPColorMap() {
3541 PythonQtPrivate* priv = PythonQt::priv();
3542 if (priv) { priv->shellClassDeleted(this); }
3543 }
3544 void PythonQtShell_QCPColorMap::clearData()
3545 {
3546 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3547 static PyObject* name = PyString_FromString("clearData");
3548 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3549 if (obj) {
3550 static const char* argumentList[] ={""};
3551 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3552 void* args[1] = {NULL};
3553 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3554 if (result) { Py_DECREF(result); }
3555 Py_DECREF(obj);
3556 return;
3557 } else {
3558 PyErr_Clear();
3559 }
3560 }
3561 QCPColorMap::clearData();
3562 }
3563 void PythonQtShell_QCPColorMap::draw(QCPPainter* painter0)
3564 {
3565 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3566 static PyObject* name = PyString_FromString("draw");
3567 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3568 if (obj) {
3569 static const char* argumentList[] ={"" , "QCPPainter*"};
3570 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3571 void* args[2] = {NULL, (void*)&painter0};
3572 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3573 if (result) { Py_DECREF(result); }
3574 Py_DECREF(obj);
3575 return;
3576 } else {
3577 PyErr_Clear();
3578 }
3579 }
3580 QCPColorMap::draw(painter0);
3581 }
3582 void PythonQtShell_QCPColorMap::drawLegendIcon(QCPPainter* painter0, const QRectF& rect1) const
3583 {
3584 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3585 static PyObject* name = PyString_FromString("drawLegendIcon");
3586 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3587 if (obj) {
3588 static const char* argumentList[] ={"" , "QCPPainter*" , "const QRectF&"};
3589 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
3590 void* args[3] = {NULL, (void*)&painter0, (void*)&rect1};
3591 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3592 if (result) { Py_DECREF(result); }
3593 Py_DECREF(obj);
3594 return;
3595 } else {
3596 PyErr_Clear();
3597 }
3598 }
3599 QCPColorMap::drawLegendIcon(painter0, rect1);
3600 }
3601 double PythonQtShell_QCPColorMap::selectTest(const QPointF& pos0, bool onlySelectable1, QVariant* details2) const
3602 {
3603 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3604 static PyObject* name = PyString_FromString("selectTest");
3605 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3606 if (obj) {
3607 static const char* argumentList[] ={"double" , "const QPointF&" , "bool" , "QVariant*"};
3608 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
3609 double returnValue;
3610 void* args[4] = {NULL, (void*)&pos0, (void*)&onlySelectable1, (void*)&details2};
3611 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3612 if (result) {
3613 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3614 if (args[0]!=&returnValue) {
3615 if (args[0]==NULL) {
3616 PythonQt::priv()->handleVirtualOverloadReturnError("selectTest", methodInfo, result);
3617 } else {
3618 returnValue = *((double*)args[0]);
3619 }
3620 }
3621 }
3622 if (result) { Py_DECREF(result); }
3623 Py_DECREF(obj);
3624 return returnValue;
3625 } else {
3626 PyErr_Clear();
3627 }
3628 }
3629 return QCPColorMap::selectTest(pos0, onlySelectable1, details2);
3630 }
3631 void PythonQtShell_QCPColorMap::updateMapImage()
3632 {
3633 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3634 static PyObject* name = PyString_FromString("updateMapImage");
3635 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3636 if (obj) {
3637 static const char* argumentList[] ={""};
3638 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3639 void* args[1] = {NULL};
3640 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3641 if (result) { Py_DECREF(result); }
3642 Py_DECREF(obj);
3643 return;
3644 } else {
3645 PyErr_Clear();
3646 }
3647 }
3648 QCPColorMap::updateMapImage();
3649 }
3650 QCPColorMap* PythonQtWrapper_QCPColorMap::new_QCPColorMap(QCPAxis* keyAxis, QCPAxis* valueAxis)
3651 {
3652 return new PythonQtShell_QCPColorMap(keyAxis, valueAxis); }
3653
3654 void PythonQtWrapper_QCPColorMap::clearData(QCPColorMap* theWrappedObject)
3655 {
3656 ( ((PythonQtPublicPromoter_QCPColorMap*)theWrappedObject)->promoted_clearData());
3657 }
3658
3659 QCPColorScale* PythonQtWrapper_QCPColorMap::colorScale(QCPColorMap* theWrappedObject) const
3660 {
3661 return ( theWrappedObject->colorScale());
3662 }
3663
3664 void PythonQtWrapper_QCPColorMap::draw(QCPColorMap* theWrappedObject, QCPPainter* painter)
3665 {
3666 ( ((PythonQtPublicPromoter_QCPColorMap*)theWrappedObject)->promoted_draw(painter));
3667 }
3668
3669 void PythonQtWrapper_QCPColorMap::drawLegendIcon(QCPColorMap* theWrappedObject, QCPPainter* painter, const QRectF& rect) const
3670 {
3671 ( ((PythonQtPublicPromoter_QCPColorMap*)theWrappedObject)->promoted_drawLegendIcon(painter, rect));
3672 }
3673
3674 bool PythonQtWrapper_QCPColorMap::interpolate(QCPColorMap* theWrappedObject) const
3675 {
3676 return ( theWrappedObject->interpolate());
3677 }
3678
3679 void PythonQtWrapper_QCPColorMap::rescaleDataRange(QCPColorMap* theWrappedObject, bool recalculateDataBounds)
3680 {
3681 ( theWrappedObject->rescaleDataRange(recalculateDataBounds));
3682 }
3683
3684 double PythonQtWrapper_QCPColorMap::selectTest(QCPColorMap* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details) const
3685 {
3686 return ( ((PythonQtPublicPromoter_QCPColorMap*)theWrappedObject)->promoted_selectTest(pos, onlySelectable, details));
3687 }
3688
3689 void PythonQtWrapper_QCPColorMap::setColorScale(QCPColorMap* theWrappedObject, QCPColorScale* colorScale)
3690 {
3691 ( theWrappedObject->setColorScale(colorScale));
3692 }
3693
3694 void PythonQtWrapper_QCPColorMap::setInterpolate(QCPColorMap* theWrappedObject, bool enabled)
3695 {
3696 ( theWrappedObject->setInterpolate(enabled));
3697 }
3698
3699 void PythonQtWrapper_QCPColorMap::setTightBoundary(QCPColorMap* theWrappedObject, bool enabled)
3700 {
3701 ( theWrappedObject->setTightBoundary(enabled));
3702 }
3703
3704 bool PythonQtWrapper_QCPColorMap::tightBoundary(QCPColorMap* theWrappedObject) const
3705 {
3706 return ( theWrappedObject->tightBoundary());
3707 }
3708
3709 void PythonQtWrapper_QCPColorMap::updateLegendIcon(QCPColorMap* theWrappedObject, Qt::TransformationMode transformMode, const QSize& thumbSize)
3710 {
3711 ( theWrappedObject->updateLegendIcon(transformMode, thumbSize));
3712 }
3713
3714 void PythonQtWrapper_QCPColorMap::updateMapImage(QCPColorMap* theWrappedObject)
3715 {
3716 ( ((PythonQtPublicPromoter_QCPColorMap*)theWrappedObject)->promoted_updateMapImage());
3717 }
3718
3719
3720
3721 PythonQtShell_QCPColorScale::~PythonQtShell_QCPColorScale() {
3722 PythonQtPrivate* priv = PythonQt::priv();
3723 if (priv) { priv->shellClassDeleted(this); }
3724 }
3725 void PythonQtShell_QCPColorScale::applyDefaultAntialiasingHint(QCPPainter* painter0) const
3726 {
3727 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3728 static PyObject* name = PyString_FromString("applyDefaultAntialiasingHint");
3729 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3730 if (obj) {
3731 static const char* argumentList[] ={"" , "QCPPainter*"};
3732 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3733 void* args[2] = {NULL, (void*)&painter0};
3734 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3735 if (result) { Py_DECREF(result); }
3736 Py_DECREF(obj);
3737 return;
3738 } else {
3739 PyErr_Clear();
3740 }
3741 }
3742 QCPColorScale::applyDefaultAntialiasingHint(painter0);
3743 }
3744 void PythonQtShell_QCPColorScale::childEvent(QChildEvent* arg__1)
3745 {
3746 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3747 static PyObject* name = PyString_FromString("childEvent");
3748 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3749 if (obj) {
3750 static const char* argumentList[] ={"" , "QChildEvent*"};
3751 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3752 void* args[2] = {NULL, (void*)&arg__1};
3753 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3754 if (result) { Py_DECREF(result); }
3755 Py_DECREF(obj);
3756 return;
3757 } else {
3758 PyErr_Clear();
3759 }
3760 }
3761 QCPColorScale::childEvent(arg__1);
3762 }
3763 QRect PythonQtShell_QCPColorScale::clipRect() const
3764 {
3765 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3766 static PyObject* name = PyString_FromString("clipRect");
3767 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3768 if (obj) {
3769 static const char* argumentList[] ={"QRect"};
3770 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3771 QRect returnValue;
3772 void* args[1] = {NULL};
3773 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3774 if (result) {
3775 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3776 if (args[0]!=&returnValue) {
3777 if (args[0]==NULL) {
3778 PythonQt::priv()->handleVirtualOverloadReturnError("clipRect", methodInfo, result);
3779 } else {
3780 returnValue = *((QRect*)args[0]);
3781 }
3782 }
3783 }
3784 if (result) { Py_DECREF(result); }
3785 Py_DECREF(obj);
3786 return returnValue;
3787 } else {
3788 PyErr_Clear();
3789 }
3790 }
3791 return QCPColorScale::clipRect();
3792 }
3793 void PythonQtShell_QCPColorScale::customEvent(QEvent* arg__1)
3794 {
3795 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3796 static PyObject* name = PyString_FromString("customEvent");
3797 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3798 if (obj) {
3799 static const char* argumentList[] ={"" , "QEvent*"};
3800 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3801 void* args[2] = {NULL, (void*)&arg__1};
3802 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3803 if (result) { Py_DECREF(result); }
3804 Py_DECREF(obj);
3805 return;
3806 } else {
3807 PyErr_Clear();
3808 }
3809 }
3810 QCPColorScale::customEvent(arg__1);
3811 }
3812 void PythonQtShell_QCPColorScale::deselectEvent(bool* selectionStateChanged0)
3813 {
3814 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3815 static PyObject* name = PyString_FromString("deselectEvent");
3816 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3817 if (obj) {
3818 static const char* argumentList[] ={"" , "bool*"};
3819 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3820 void* args[2] = {NULL, (void*)&selectionStateChanged0};
3821 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3822 if (result) { Py_DECREF(result); }
3823 Py_DECREF(obj);
3824 return;
3825 } else {
3826 PyErr_Clear();
3827 }
3828 }
3829 QCPColorScale::deselectEvent(selectionStateChanged0);
3830 }
3831 void PythonQtShell_QCPColorScale::draw(QCPPainter* painter0)
3832 {
3833 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3834 static PyObject* name = PyString_FromString("draw");
3835 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3836 if (obj) {
3837 static const char* argumentList[] ={"" , "QCPPainter*"};
3838 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3839 void* args[2] = {NULL, (void*)&painter0};
3840 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3841 if (result) { Py_DECREF(result); }
3842 Py_DECREF(obj);
3843 return;
3844 } else {
3845 PyErr_Clear();
3846 }
3847 }
3848 QCPColorScale::draw(painter0);
3849 }
3850 QList<QCPLayoutElement* > PythonQtShell_QCPColorScale::elements(bool recursive0) const
3851 {
3852 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3853 static PyObject* name = PyString_FromString("elements");
3854 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3855 if (obj) {
3856 static const char* argumentList[] ={"QList<QCPLayoutElement* >" , "bool"};
3857 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3858 QList<QCPLayoutElement* > returnValue;
3859 void* args[2] = {NULL, (void*)&recursive0};
3860 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3861 if (result) {
3862 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3863 if (args[0]!=&returnValue) {
3864 if (args[0]==NULL) {
3865 PythonQt::priv()->handleVirtualOverloadReturnError("elements", methodInfo, result);
3866 } else {
3867 returnValue = *((QList<QCPLayoutElement* >*)args[0]);
3868 }
3869 }
3870 }
3871 if (result) { Py_DECREF(result); }
3872 Py_DECREF(obj);
3873 return returnValue;
3874 } else {
3875 PyErr_Clear();
3876 }
3877 }
3878 return QCPColorScale::elements(recursive0);
3879 }
3880 bool PythonQtShell_QCPColorScale::event(QEvent* arg__1)
3881 {
3882 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3883 static PyObject* name = PyString_FromString("event");
3884 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3885 if (obj) {
3886 static const char* argumentList[] ={"bool" , "QEvent*"};
3887 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3888 bool returnValue;
3889 void* args[2] = {NULL, (void*)&arg__1};
3890 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3891 if (result) {
3892 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3893 if (args[0]!=&returnValue) {
3894 if (args[0]==NULL) {
3895 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
3896 } else {
3897 returnValue = *((bool*)args[0]);
3898 }
3899 }
3900 }
3901 if (result) { Py_DECREF(result); }
3902 Py_DECREF(obj);
3903 return returnValue;
3904 } else {
3905 PyErr_Clear();
3906 }
3907 }
3908 return QCPColorScale::event(arg__1);
3909 }
3910 bool PythonQtShell_QCPColorScale::eventFilter(QObject* arg__1, QEvent* arg__2)
3911 {
3912 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3913 static PyObject* name = PyString_FromString("eventFilter");
3914 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3915 if (obj) {
3916 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
3917 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
3918 bool returnValue;
3919 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
3920 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3921 if (result) {
3922 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3923 if (args[0]!=&returnValue) {
3924 if (args[0]==NULL) {
3925 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
3926 } else {
3927 returnValue = *((bool*)args[0]);
3928 }
3929 }
3930 }
3931 if (result) { Py_DECREF(result); }
3932 Py_DECREF(obj);
3933 return returnValue;
3934 } else {
3935 PyErr_Clear();
3936 }
3937 }
3938 return QCPColorScale::eventFilter(arg__1, arg__2);
3939 }
3940 QSize PythonQtShell_QCPColorScale::maximumSizeHint() const
3941 {
3942 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3943 static PyObject* name = PyString_FromString("maximumSizeHint");
3944 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3945 if (obj) {
3946 static const char* argumentList[] ={"QSize"};
3947 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3948 QSize returnValue;
3949 void* args[1] = {NULL};
3950 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3951 if (result) {
3952 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3953 if (args[0]!=&returnValue) {
3954 if (args[0]==NULL) {
3955 PythonQt::priv()->handleVirtualOverloadReturnError("maximumSizeHint", methodInfo, result);
3956 } else {
3957 returnValue = *((QSize*)args[0]);
3958 }
3959 }
3960 }
3961 if (result) { Py_DECREF(result); }
3962 Py_DECREF(obj);
3963 return returnValue;
3964 } else {
3965 PyErr_Clear();
3966 }
3967 }
3968 return QCPColorScale::maximumSizeHint();
3969 }
3970 QSize PythonQtShell_QCPColorScale::minimumSizeHint() const
3971 {
3972 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3973 static PyObject* name = PyString_FromString("minimumSizeHint");
3974 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3975 if (obj) {
3976 static const char* argumentList[] ={"QSize"};
3977 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3978 QSize returnValue;
3979 void* args[1] = {NULL};
3980 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3981 if (result) {
3982 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3983 if (args[0]!=&returnValue) {
3984 if (args[0]==NULL) {
3985 PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result);
3986 } else {
3987 returnValue = *((QSize*)args[0]);
3988 }
3989 }
3990 }
3991 if (result) { Py_DECREF(result); }
3992 Py_DECREF(obj);
3993 return returnValue;
3994 } else {
3995 PyErr_Clear();
3996 }
3997 }
3998 return QCPColorScale::minimumSizeHint();
3999 }
4000 void PythonQtShell_QCPColorScale::mouseDoubleClickEvent(QMouseEvent* event0)
4001 {
4002 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4003 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
4004 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4005 if (obj) {
4006 static const char* argumentList[] ={"" , "QMouseEvent*"};
4007 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4008 void* args[2] = {NULL, (void*)&event0};
4009 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4010 if (result) { Py_DECREF(result); }
4011 Py_DECREF(obj);
4012 return;
4013 } else {
4014 PyErr_Clear();
4015 }
4016 }
4017 QCPColorScale::mouseDoubleClickEvent(event0);
4018 }
4019 void PythonQtShell_QCPColorScale::mouseMoveEvent(QMouseEvent* event0)
4020 {
4021 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4022 static PyObject* name = PyString_FromString("mouseMoveEvent");
4023 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4024 if (obj) {
4025 static const char* argumentList[] ={"" , "QMouseEvent*"};
4026 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4027 void* args[2] = {NULL, (void*)&event0};
4028 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4029 if (result) { Py_DECREF(result); }
4030 Py_DECREF(obj);
4031 return;
4032 } else {
4033 PyErr_Clear();
4034 }
4035 }
4036 QCPColorScale::mouseMoveEvent(event0);
4037 }
4038 void PythonQtShell_QCPColorScale::mousePressEvent(QMouseEvent* event0)
4039 {
4040 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4041 static PyObject* name = PyString_FromString("mousePressEvent");
4042 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4043 if (obj) {
4044 static const char* argumentList[] ={"" , "QMouseEvent*"};
4045 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4046 void* args[2] = {NULL, (void*)&event0};
4047 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4048 if (result) { Py_DECREF(result); }
4049 Py_DECREF(obj);
4050 return;
4051 } else {
4052 PyErr_Clear();
4053 }
4054 }
4055 QCPColorScale::mousePressEvent(event0);
4056 }
4057 void PythonQtShell_QCPColorScale::mouseReleaseEvent(QMouseEvent* event0)
4058 {
4059 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4060 static PyObject* name = PyString_FromString("mouseReleaseEvent");
4061 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4062 if (obj) {
4063 static const char* argumentList[] ={"" , "QMouseEvent*"};
4064 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4065 void* args[2] = {NULL, (void*)&event0};
4066 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4067 if (result) { Py_DECREF(result); }
4068 Py_DECREF(obj);
4069 return;
4070 } else {
4071 PyErr_Clear();
4072 }
4073 }
4074 QCPColorScale::mouseReleaseEvent(event0);
4075 }
4076 void PythonQtShell_QCPColorScale::parentPlotInitialized(QCustomPlot* parentPlot0)
4077 {
4078 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4079 static PyObject* name = PyString_FromString("parentPlotInitialized");
4080 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4081 if (obj) {
4082 static const char* argumentList[] ={"" , "QCustomPlot*"};
4083 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4084 void* args[2] = {NULL, (void*)&parentPlot0};
4085 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4086 if (result) { Py_DECREF(result); }
4087 Py_DECREF(obj);
4088 return;
4089 } else {
4090 PyErr_Clear();
4091 }
4092 }
4093 QCPColorScale::parentPlotInitialized(parentPlot0);
4094 }
4095 void PythonQtShell_QCPColorScale::selectEvent(QMouseEvent* event0, bool additive1, const QVariant& details2, bool* selectionStateChanged3)
4096 {
4097 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4098 static PyObject* name = PyString_FromString("selectEvent");
4099 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4100 if (obj) {
4101 static const char* argumentList[] ={"" , "QMouseEvent*" , "bool" , "const QVariant&" , "bool*"};
4102 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList);
4103 void* args[5] = {NULL, (void*)&event0, (void*)&additive1, (void*)&details2, (void*)&selectionStateChanged3};
4104 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4105 if (result) { Py_DECREF(result); }
4106 Py_DECREF(obj);
4107 return;
4108 } else {
4109 PyErr_Clear();
4110 }
4111 }
4112 QCPColorScale::selectEvent(event0, additive1, details2, selectionStateChanged3);
4113 }
4114 double PythonQtShell_QCPColorScale::selectTest(const QPointF& pos0, bool onlySelectable1, QVariant* details2) const
4115 {
4116 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4117 static PyObject* name = PyString_FromString("selectTest");
4118 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4119 if (obj) {
4120 static const char* argumentList[] ={"double" , "const QPointF&" , "bool" , "QVariant*"};
4121 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
4122 double returnValue;
4123 void* args[4] = {NULL, (void*)&pos0, (void*)&onlySelectable1, (void*)&details2};
4124 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4125 if (result) {
4126 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4127 if (args[0]!=&returnValue) {
4128 if (args[0]==NULL) {
4129 PythonQt::priv()->handleVirtualOverloadReturnError("selectTest", methodInfo, result);
4130 } else {
4131 returnValue = *((double*)args[0]);
4132 }
4133 }
4134 }
4135 if (result) { Py_DECREF(result); }
4136 Py_DECREF(obj);
4137 return returnValue;
4138 } else {
4139 PyErr_Clear();
4140 }
4141 }
4142 return QCPColorScale::selectTest(pos0, onlySelectable1, details2);
4143 }
4144 void PythonQtShell_QCPColorScale::timerEvent(QTimerEvent* arg__1)
4145 {
4146 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4147 static PyObject* name = PyString_FromString("timerEvent");
4148 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4149 if (obj) {
4150 static const char* argumentList[] ={"" , "QTimerEvent*"};
4151 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4152 void* args[2] = {NULL, (void*)&arg__1};
4153 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4154 if (result) { Py_DECREF(result); }
4155 Py_DECREF(obj);
4156 return;
4157 } else {
4158 PyErr_Clear();
4159 }
4160 }
4161 QCPColorScale::timerEvent(arg__1);
4162 }
4163 void PythonQtShell_QCPColorScale::wheelEvent(QWheelEvent* event0)
4164 {
4165 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4166 static PyObject* name = PyString_FromString("wheelEvent");
4167 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4168 if (obj) {
4169 static const char* argumentList[] ={"" , "QWheelEvent*"};
4170 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4171 void* args[2] = {NULL, (void*)&event0};
4172 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4173 if (result) { Py_DECREF(result); }
4174 Py_DECREF(obj);
4175 return;
4176 } else {
4177 PyErr_Clear();
4178 }
4179 }
4180 QCPColorScale::wheelEvent(event0);
4181 }
4182 QCPColorScale* PythonQtWrapper_QCPColorScale::new_QCPColorScale(QCustomPlot* parentPlot)
4183 {
4184 return new PythonQtShell_QCPColorScale(parentPlot); }
4185
4186 void PythonQtWrapper_QCPColorScale::applyDefaultAntialiasingHint(QCPColorScale* theWrappedObject, QCPPainter* painter) const
4187 {
4188 ( ((PythonQtPublicPromoter_QCPColorScale*)theWrappedObject)->promoted_applyDefaultAntialiasingHint(painter));
4189 }
4190
4191 QCPAxis* PythonQtWrapper_QCPColorScale::axis(QCPColorScale* theWrappedObject) const
4192 {
4193 return ( theWrappedObject->axis());
4194 }
4195
4196 int PythonQtWrapper_QCPColorScale::barWidth(QCPColorScale* theWrappedObject) const
4197 {
4198 return ( theWrappedObject->barWidth());
4199 }
4200
4201 QList<QCPColorMap* > PythonQtWrapper_QCPColorScale::colorMaps(QCPColorScale* theWrappedObject) const
4202 {
4203 return ( theWrappedObject->colorMaps());
4204 }
4205
4206 QString PythonQtWrapper_QCPColorScale::label(QCPColorScale* theWrappedObject) const
4207 {
4208 return ( theWrappedObject->label());
4209 }
4210
4211 void PythonQtWrapper_QCPColorScale::mouseMoveEvent(QCPColorScale* theWrappedObject, QMouseEvent* event)
4212 {
4213 ( ((PythonQtPublicPromoter_QCPColorScale*)theWrappedObject)->promoted_mouseMoveEvent(event));
4214 }
4215
4216 void PythonQtWrapper_QCPColorScale::mousePressEvent(QCPColorScale* theWrappedObject, QMouseEvent* event)
4217 {
4218 ( ((PythonQtPublicPromoter_QCPColorScale*)theWrappedObject)->promoted_mousePressEvent(event));
4219 }
4220
4221 void PythonQtWrapper_QCPColorScale::mouseReleaseEvent(QCPColorScale* theWrappedObject, QMouseEvent* event)
4222 {
4223 ( ((PythonQtPublicPromoter_QCPColorScale*)theWrappedObject)->promoted_mouseReleaseEvent(event));
4224 }
4225
4226 bool PythonQtWrapper_QCPColorScale::rangeDrag(QCPColorScale* theWrappedObject) const
4227 {
4228 return ( theWrappedObject->rangeDrag());
4229 }
4230
4231 bool PythonQtWrapper_QCPColorScale::rangeZoom(QCPColorScale* theWrappedObject) const
4232 {
4233 return ( theWrappedObject->rangeZoom());
4234 }
4235
4236 void PythonQtWrapper_QCPColorScale::rescaleDataRange(QCPColorScale* theWrappedObject, bool onlyVisibleMaps)
4237 {
4238 ( theWrappedObject->rescaleDataRange(onlyVisibleMaps));
4239 }
4240
4241 void PythonQtWrapper_QCPColorScale::setBarWidth(QCPColorScale* theWrappedObject, int width)
4242 {
4243 ( theWrappedObject->setBarWidth(width));
4244 }
4245
4246 void PythonQtWrapper_QCPColorScale::setLabel(QCPColorScale* theWrappedObject, const QString& str)
4247 {
4248 ( theWrappedObject->setLabel(str));
4249 }
4250
4251 void PythonQtWrapper_QCPColorScale::setRangeDrag(QCPColorScale* theWrappedObject, bool enabled)
4252 {
4253 ( theWrappedObject->setRangeDrag(enabled));
4254 }
4255
4256 void PythonQtWrapper_QCPColorScale::setRangeZoom(QCPColorScale* theWrappedObject, bool enabled)
4257 {
4258 ( theWrappedObject->setRangeZoom(enabled));
4259 }
4260
4261 void PythonQtWrapper_QCPColorScale::wheelEvent(QCPColorScale* theWrappedObject, QWheelEvent* event)
4262 {
4263 ( ((PythonQtPublicPromoter_QCPColorScale*)theWrappedObject)->promoted_wheelEvent(event));
4264 }
4265
4266
4267
4268 PythonQtShell_QCPGraph::~PythonQtShell_QCPGraph() {
4269 PythonQtPrivate* priv = PythonQt::priv();
4270 if (priv) { priv->shellClassDeleted(this); }
4271 }
4272 void PythonQtShell_QCPGraph::clearData()
4273 {
4274 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4275 static PyObject* name = PyString_FromString("clearData");
4276 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4277 if (obj) {
4278 static const char* argumentList[] ={""};
4279 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4280 void* args[1] = {NULL};
4281 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4282 if (result) { Py_DECREF(result); }
4283 Py_DECREF(obj);
4284 return;
4285 } else {
4286 PyErr_Clear();
4287 }
4288 }
4289 QCPGraph::clearData();
4290 }
4291 void PythonQtShell_QCPGraph::draw(QCPPainter* painter0)
4292 {
4293 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4294 static PyObject* name = PyString_FromString("draw");
4295 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4296 if (obj) {
4297 static const char* argumentList[] ={"" , "QCPPainter*"};
4298 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4299 void* args[2] = {NULL, (void*)&painter0};
4300 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4301 if (result) { Py_DECREF(result); }
4302 Py_DECREF(obj);
4303 return;
4304 } else {
4305 PyErr_Clear();
4306 }
4307 }
4308 QCPGraph::draw(painter0);
4309 }
4310 void PythonQtShell_QCPGraph::drawFill(QCPPainter* painter0, QVector<QPointF >* lineData1) const
4311 {
4312 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4313 static PyObject* name = PyString_FromString("drawFill");
4314 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4315 if (obj) {
4316 static const char* argumentList[] ={"" , "QCPPainter*" , "QVector<QPointF >*"};
4317 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
4318 void* args[3] = {NULL, (void*)&painter0, (void*)&lineData1};
4319 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4320 if (result) { Py_DECREF(result); }
4321 Py_DECREF(obj);
4322 return;
4323 } else {
4324 PyErr_Clear();
4325 }
4326 }
4327 QCPGraph::drawFill(painter0, lineData1);
4328 }
4329 void PythonQtShell_QCPGraph::drawImpulsePlot(QCPPainter* painter0, QVector<QPointF >* lineData1) const
4330 {
4331 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4332 static PyObject* name = PyString_FromString("drawImpulsePlot");
4333 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4334 if (obj) {
4335 static const char* argumentList[] ={"" , "QCPPainter*" , "QVector<QPointF >*"};
4336 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
4337 void* args[3] = {NULL, (void*)&painter0, (void*)&lineData1};
4338 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4339 if (result) { Py_DECREF(result); }
4340 Py_DECREF(obj);
4341 return;
4342 } else {
4343 PyErr_Clear();
4344 }
4345 }
4346 QCPGraph::drawImpulsePlot(painter0, lineData1);
4347 }
4348 void PythonQtShell_QCPGraph::drawLegendIcon(QCPPainter* painter0, const QRectF& rect1) const
4349 {
4350 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4351 static PyObject* name = PyString_FromString("drawLegendIcon");
4352 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4353 if (obj) {
4354 static const char* argumentList[] ={"" , "QCPPainter*" , "const QRectF&"};
4355 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
4356 void* args[3] = {NULL, (void*)&painter0, (void*)&rect1};
4357 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4358 if (result) { Py_DECREF(result); }
4359 Py_DECREF(obj);
4360 return;
4361 } else {
4362 PyErr_Clear();
4363 }
4364 }
4365 QCPGraph::drawLegendIcon(painter0, rect1);
4366 }
4367 void PythonQtShell_QCPGraph::drawLinePlot(QCPPainter* painter0, QVector<QPointF >* lineData1) const
4368 {
4369 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4370 static PyObject* name = PyString_FromString("drawLinePlot");
4371 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4372 if (obj) {
4373 static const char* argumentList[] ={"" , "QCPPainter*" , "QVector<QPointF >*"};
4374 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
4375 void* args[3] = {NULL, (void*)&painter0, (void*)&lineData1};
4376 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4377 if (result) { Py_DECREF(result); }
4378 Py_DECREF(obj);
4379 return;
4380 } else {
4381 PyErr_Clear();
4382 }
4383 }
4384 QCPGraph::drawLinePlot(painter0, lineData1);
4385 }
4386 double PythonQtShell_QCPGraph::selectTest(const QPointF& pos0, bool onlySelectable1, QVariant* details2) const
4387 {
4388 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4389 static PyObject* name = PyString_FromString("selectTest");
4390 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4391 if (obj) {
4392 static const char* argumentList[] ={"double" , "const QPointF&" , "bool" , "QVariant*"};
4393 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
4394 double returnValue;
4395 void* args[4] = {NULL, (void*)&pos0, (void*)&onlySelectable1, (void*)&details2};
4396 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4397 if (result) {
4398 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4399 if (args[0]!=&returnValue) {
4400 if (args[0]==NULL) {
4401 PythonQt::priv()->handleVirtualOverloadReturnError("selectTest", methodInfo, result);
4402 } else {
4403 returnValue = *((double*)args[0]);
4404 }
4405 }
4406 }
4407 if (result) { Py_DECREF(result); }
4408 Py_DECREF(obj);
4409 return returnValue;
4410 } else {
4411 PyErr_Clear();
4412 }
4413 }
4414 return QCPGraph::selectTest(pos0, onlySelectable1, details2);
4415 }
4416 QCPGraph* PythonQtWrapper_QCPGraph::new_QCPGraph(QCPAxis* keyAxis, QCPAxis* valueAxis)
4417 {
4418 return new PythonQtShell_QCPGraph(keyAxis, valueAxis); }
4419
4420 bool PythonQtWrapper_QCPGraph::adaptiveSampling(QCPGraph* theWrappedObject) const
4421 {
4422 return ( theWrappedObject->adaptiveSampling());
4423 }
4424
4425 void PythonQtWrapper_QCPGraph::addData(QCPGraph* theWrappedObject, const QVector<double >& keys, const QVector<double >& values)
4426 {
4427 ( theWrappedObject->addData(keys, values));
4428 }
4429
4430 void PythonQtWrapper_QCPGraph::addData(QCPGraph* theWrappedObject, double key, double value)
4431 {
4432 ( theWrappedObject->addData(key, value));
4433 }
4434
4435 void PythonQtWrapper_QCPGraph::addFillBasePoints(QCPGraph* theWrappedObject, QVector<QPointF >* lineData) const
4436 {
4437 ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_addFillBasePoints(lineData));
4438 }
4439
4440 QCPGraph* PythonQtWrapper_QCPGraph::channelFillGraph(QCPGraph* theWrappedObject) const
4441 {
4442 return ( theWrappedObject->channelFillGraph());
4443 }
4444
4445 void PythonQtWrapper_QCPGraph::clearData(QCPGraph* theWrappedObject)
4446 {
4447 ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_clearData());
4448 }
4449
4450 void PythonQtWrapper_QCPGraph::draw(QCPGraph* theWrappedObject, QCPPainter* painter)
4451 {
4452 ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_draw(painter));
4453 }
4454
4455 void PythonQtWrapper_QCPGraph::drawFill(QCPGraph* theWrappedObject, QCPPainter* painter, QVector<QPointF >* lineData) const
4456 {
4457 ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_drawFill(painter, lineData));
4458 }
4459
4460 void PythonQtWrapper_QCPGraph::drawImpulsePlot(QCPGraph* theWrappedObject, QCPPainter* painter, QVector<QPointF >* lineData) const
4461 {
4462 ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_drawImpulsePlot(painter, lineData));
4463 }
4464
4465 void PythonQtWrapper_QCPGraph::drawLegendIcon(QCPGraph* theWrappedObject, QCPPainter* painter, const QRectF& rect) const
4466 {
4467 ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_drawLegendIcon(painter, rect));
4468 }
4469
4470 void PythonQtWrapper_QCPGraph::drawLinePlot(QCPGraph* theWrappedObject, QCPPainter* painter, QVector<QPointF >* lineData) const
4471 {
4472 ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_drawLinePlot(painter, lineData));
4473 }
4474
4475 double PythonQtWrapper_QCPGraph::errorBarSize(QCPGraph* theWrappedObject) const
4476 {
4477 return ( theWrappedObject->errorBarSize());
4478 }
4479
4480 bool PythonQtWrapper_QCPGraph::errorBarSkipSymbol(QCPGraph* theWrappedObject) const
4481 {
4482 return ( theWrappedObject->errorBarSkipSymbol());
4483 }
4484
4485 QPen PythonQtWrapper_QCPGraph::errorPen(QCPGraph* theWrappedObject) const
4486 {
4487 return ( theWrappedObject->errorPen());
4488 }
4489
4490 int PythonQtWrapper_QCPGraph::findIndexAboveX(QCPGraph* theWrappedObject, const QVector<QPointF >* data, double x) const
4491 {
4492 return ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_findIndexAboveX(data, x));
4493 }
4494
4495 int PythonQtWrapper_QCPGraph::findIndexAboveY(QCPGraph* theWrappedObject, const QVector<QPointF >* data, double y) const
4496 {
4497 return ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_findIndexAboveY(data, y));
4498 }
4499
4500 int PythonQtWrapper_QCPGraph::findIndexBelowX(QCPGraph* theWrappedObject, const QVector<QPointF >* data, double x) const
4501 {
4502 return ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_findIndexBelowX(data, x));
4503 }
4504
4505 int PythonQtWrapper_QCPGraph::findIndexBelowY(QCPGraph* theWrappedObject, const QVector<QPointF >* data, double y) const
4506 {
4507 return ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_findIndexBelowY(data, y));
4508 }
4509
4510 const QPolygonF PythonQtWrapper_QCPGraph::getChannelFillPolygon(QCPGraph* theWrappedObject, const QVector<QPointF >* lineData) const
4511 {
4512 return ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_getChannelFillPolygon(lineData));
4513 }
4514
4515 QPointF PythonQtWrapper_QCPGraph::lowerFillBasePoint(QCPGraph* theWrappedObject, double lowerKey) const
4516 {
4517 return ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_lowerFillBasePoint(lowerKey));
4518 }
4519
4520 double PythonQtWrapper_QCPGraph::pointDistance(QCPGraph* theWrappedObject, const QPointF& pixelPoint) const
4521 {
4522 return ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_pointDistance(pixelPoint));
4523 }
4524
4525 void PythonQtWrapper_QCPGraph::removeData(QCPGraph* theWrappedObject, double fromKey, double toKey)
4526 {
4527 ( theWrappedObject->removeData(fromKey, toKey));
4528 }
4529
4530 void PythonQtWrapper_QCPGraph::removeData(QCPGraph* theWrappedObject, double key)
4531 {
4532 ( theWrappedObject->removeData(key));
4533 }
4534
4535 void PythonQtWrapper_QCPGraph::removeDataAfter(QCPGraph* theWrappedObject, double key)
4536 {
4537 ( theWrappedObject->removeDataAfter(key));
4538 }
4539
4540 void PythonQtWrapper_QCPGraph::removeDataBefore(QCPGraph* theWrappedObject, double key)
4541 {
4542 ( theWrappedObject->removeDataBefore(key));
4543 }
4544
4545 void PythonQtWrapper_QCPGraph::removeFillBasePoints(QCPGraph* theWrappedObject, QVector<QPointF >* lineData) const
4546 {
4547 ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_removeFillBasePoints(lineData));
4548 }
4549
4550 void PythonQtWrapper_QCPGraph::rescaleAxes(QCPGraph* theWrappedObject, bool onlyEnlarge, bool includeErrorBars) const
4551 {
4552 ( theWrappedObject->rescaleAxes(onlyEnlarge, includeErrorBars));
4553 }
4554
4555 void PythonQtWrapper_QCPGraph::rescaleKeyAxis(QCPGraph* theWrappedObject, bool onlyEnlarge, bool includeErrorBars) const
4556 {
4557 ( theWrappedObject->rescaleKeyAxis(onlyEnlarge, includeErrorBars));
4558 }
4559
4560 void PythonQtWrapper_QCPGraph::rescaleValueAxis(QCPGraph* theWrappedObject, bool onlyEnlarge, bool includeErrorBars) const
4561 {
4562 ( theWrappedObject->rescaleValueAxis(onlyEnlarge, includeErrorBars));
4563 }
4564
4565 double PythonQtWrapper_QCPGraph::selectTest(QCPGraph* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details) const
4566 {
4567 return ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_selectTest(pos, onlySelectable, details));
4568 }
4569
4570 void PythonQtWrapper_QCPGraph::setAdaptiveSampling(QCPGraph* theWrappedObject, bool enabled)
4571 {
4572 ( theWrappedObject->setAdaptiveSampling(enabled));
4573 }
4574
4575 void PythonQtWrapper_QCPGraph::setChannelFillGraph(QCPGraph* theWrappedObject, QCPGraph* targetGraph)
4576 {
4577 ( theWrappedObject->setChannelFillGraph(targetGraph));
4578 }
4579
4580 void PythonQtWrapper_QCPGraph::setData(QCPGraph* theWrappedObject, const QVector<double >& key, const QVector<double >& value)
4581 {
4582 ( theWrappedObject->setData(key, value));
4583 }
4584
4585 void PythonQtWrapper_QCPGraph::setDataBothError(QCPGraph* theWrappedObject, const QVector<double >& key, const QVector<double >& value, const QVector<double >& keyError, const QVector<double >& valueError)
4586 {
4587 ( theWrappedObject->setDataBothError(key, value, keyError, valueError));
4588 }
4589
4590 void PythonQtWrapper_QCPGraph::setDataBothError(QCPGraph* theWrappedObject, const QVector<double >& key, const QVector<double >& value, const QVector<double >& keyErrorMinus, const QVector<double >& keyErrorPlus, const QVector<double >& valueErrorMinus, const QVector<double >& valueErrorPlus)
4591 {
4592 ( theWrappedObject->setDataBothError(key, value, keyErrorMinus, keyErrorPlus, valueErrorMinus, valueErrorPlus));
4593 }
4594
4595 void PythonQtWrapper_QCPGraph::setDataKeyError(QCPGraph* theWrappedObject, const QVector<double >& key, const QVector<double >& value, const QVector<double >& keyError)
4596 {
4597 ( theWrappedObject->setDataKeyError(key, value, keyError));
4598 }
4599
4600 void PythonQtWrapper_QCPGraph::setDataKeyError(QCPGraph* theWrappedObject, const QVector<double >& key, const QVector<double >& value, const QVector<double >& keyErrorMinus, const QVector<double >& keyErrorPlus)
4601 {
4602 ( theWrappedObject->setDataKeyError(key, value, keyErrorMinus, keyErrorPlus));
4603 }
4604
4605 void PythonQtWrapper_QCPGraph::setDataValueError(QCPGraph* theWrappedObject, const QVector<double >& key, const QVector<double >& value, const QVector<double >& valueError)
4606 {
4607 ( theWrappedObject->setDataValueError(key, value, valueError));
4608 }
4609
4610 void PythonQtWrapper_QCPGraph::setDataValueError(QCPGraph* theWrappedObject, const QVector<double >& key, const QVector<double >& value, const QVector<double >& valueErrorMinus, const QVector<double >& valueErrorPlus)
4611 {
4612 ( theWrappedObject->setDataValueError(key, value, valueErrorMinus, valueErrorPlus));
4613 }
4614
4615 void PythonQtWrapper_QCPGraph::setErrorBarSize(QCPGraph* theWrappedObject, double size)
4616 {
4617 ( theWrappedObject->setErrorBarSize(size));
4618 }
4619
4620 void PythonQtWrapper_QCPGraph::setErrorBarSkipSymbol(QCPGraph* theWrappedObject, bool enabled)
4621 {
4622 ( theWrappedObject->setErrorBarSkipSymbol(enabled));
4623 }
4624
4625 void PythonQtWrapper_QCPGraph::setErrorPen(QCPGraph* theWrappedObject, const QPen& pen)
4626 {
4627 ( theWrappedObject->setErrorPen(pen));
4628 }
4629
4630 void PythonQtWrapper_QCPGraph::setUseFastVectors(QCPGraph* theWrappedObject, bool useFastVectors)
4631 {
4632 ( theWrappedObject->setUseFastVectors(useFastVectors));
4633 }
4634
4635 QPointF PythonQtWrapper_QCPGraph::upperFillBasePoint(QCPGraph* theWrappedObject, double upperKey) const
4636 {
4637 return ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_upperFillBasePoint(upperKey));
4638 }
4639
4640 bool PythonQtWrapper_QCPGraph::useFastVectors(QCPGraph* theWrappedObject) const
4641 {
4642 return ( theWrappedObject->useFastVectors());
4643 }
4644
4645
4646
4647 PythonQtShell_QCPItemPosition::~PythonQtShell_QCPItemPosition() {
4648 PythonQtPrivate* priv = PythonQt::priv();
4649 if (priv) { priv->shellClassDeleted(this); }
4650 }
4651 QPointF PythonQtShell_QCPItemPosition::pixelPoint() const
4652 {
4653 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4654 static PyObject* name = PyString_FromString("pixelPoint");
4655 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4656 if (obj) {
4657 static const char* argumentList[] ={"QPointF"};
4658 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4659 QPointF returnValue;
4660 void* args[1] = {NULL};
4661 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4662 if (result) {
4663 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4664 if (args[0]!=&returnValue) {
4665 if (args[0]==NULL) {
4666 PythonQt::priv()->handleVirtualOverloadReturnError("pixelPoint", methodInfo, result);
4667 } else {
4668 returnValue = *((QPointF*)args[0]);
4669 }
4670 }
4671 }
4672 if (result) { Py_DECREF(result); }
4673 Py_DECREF(obj);
4674 return returnValue;
4675 } else {
4676 PyErr_Clear();
4677 }
4678 }
4679 return QCPItemPosition::pixelPoint();
4680 }
4681 QCPItemPosition* PythonQtShell_QCPItemPosition::toQCPItemPosition()
4682 {
4683 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4684 static PyObject* name = PyString_FromString("toQCPItemPosition");
4685 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4686 if (obj) {
4687 static const char* argumentList[] ={"QCPItemPosition*"};
4688 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4689 QCPItemPosition* returnValue;
4690 void* args[1] = {NULL};
4691 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4692 if (result) {
4693 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4694 if (args[0]!=&returnValue) {
4695 if (args[0]==NULL) {
4696 PythonQt::priv()->handleVirtualOverloadReturnError("toQCPItemPosition", methodInfo, result);
4697 } else {
4698 returnValue = *((QCPItemPosition**)args[0]);
4699 }
4700 }
4701 }
4702 if (result) { Py_DECREF(result); }
4703 Py_DECREF(obj);
4704 return returnValue;
4705 } else {
4706 PyErr_Clear();
4707 }
4708 }
4709 return QCPItemPosition::toQCPItemPosition();
4710 }
4711 QCPItemPosition* PythonQtWrapper_QCPItemPosition::new_QCPItemPosition(QCustomPlot* parentPlot, QCPAbstractItem* parentItem, const QString name)
4712 {
4713 return new PythonQtShell_QCPItemPosition(parentPlot, parentItem, name); }
4714
4715 QCPAxisRect* PythonQtWrapper_QCPItemPosition::axisRect(QCPItemPosition* theWrappedObject) const
4716 {
4717 return ( theWrappedObject->axisRect());
4718 }
4719
4720 QPointF PythonQtWrapper_QCPItemPosition::coords(QCPItemPosition* theWrappedObject) const
4721 {
4722 return ( theWrappedObject->coords());
4723 }
4724
4725 double PythonQtWrapper_QCPItemPosition::key(QCPItemPosition* theWrappedObject) const
4726 {
4727 return ( theWrappedObject->key());
4728 }
4729
4730 QCPAxis* PythonQtWrapper_QCPItemPosition::keyAxis(QCPItemPosition* theWrappedObject) const
4731 {
4732 return ( theWrappedObject->keyAxis());
4733 }
4734
4735 QPointF PythonQtWrapper_QCPItemPosition::pixelPoint(QCPItemPosition* theWrappedObject) const
4736 {
4737 return ( ((PythonQtPublicPromoter_QCPItemPosition*)theWrappedObject)->promoted_pixelPoint());
4738 }
4739
4740 void PythonQtWrapper_QCPItemPosition::setAxes(QCPItemPosition* theWrappedObject, QCPAxis* keyAxis, QCPAxis* valueAxis)
4741 {
4742 ( theWrappedObject->setAxes(keyAxis, valueAxis));
4743 }
4744
4745 void PythonQtWrapper_QCPItemPosition::setAxisRect(QCPItemPosition* theWrappedObject, QCPAxisRect* axisRect)
4746 {
4747 ( theWrappedObject->setAxisRect(axisRect));
4748 }
4749
4750 void PythonQtWrapper_QCPItemPosition::setCoords(QCPItemPosition* theWrappedObject, const QPointF& coords)
4751 {
4752 ( theWrappedObject->setCoords(coords));
4753 }
4754
4755 void PythonQtWrapper_QCPItemPosition::setCoords(QCPItemPosition* theWrappedObject, double key, double value)
4756 {
4757 ( theWrappedObject->setCoords(key, value));
4758 }
4759
4760 void PythonQtWrapper_QCPItemPosition::setPixelPoint(QCPItemPosition* theWrappedObject, const QPointF& pixelPoint)
4761 {
4762 ( theWrappedObject->setPixelPoint(pixelPoint));
4763 }
4764
4765 QCPItemPosition* PythonQtWrapper_QCPItemPosition::toQCPItemPosition(QCPItemPosition* theWrappedObject)
4766 {
4767 return ( ((PythonQtPublicPromoter_QCPItemPosition*)theWrappedObject)->promoted_toQCPItemPosition());
4768 }
4769
4770 double PythonQtWrapper_QCPItemPosition::value(QCPItemPosition* theWrappedObject) const
4771 {
4772 return ( theWrappedObject->value());
4773 }
4774
4775 QCPAxis* PythonQtWrapper_QCPItemPosition::valueAxis(QCPItemPosition* theWrappedObject) const
4776 {
4777 return ( theWrappedObject->valueAxis());
4778 }
4779
4780
4781
4782 PythonQtShell_QCPLayer::~PythonQtShell_QCPLayer() {
4783 PythonQtPrivate* priv = PythonQt::priv();
4784 if (priv) { priv->shellClassDeleted(this); }
4785 }
4786 void PythonQtShell_QCPLayer::childEvent(QChildEvent* arg__1)
4787 {
4788 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4789 static PyObject* name = PyString_FromString("childEvent");
4790 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4791 if (obj) {
4792 static const char* argumentList[] ={"" , "QChildEvent*"};
4793 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4794 void* args[2] = {NULL, (void*)&arg__1};
4795 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4796 if (result) { Py_DECREF(result); }
4797 Py_DECREF(obj);
4798 return;
4799 } else {
4800 PyErr_Clear();
4801 }
4802 }
4803 QCPLayer::childEvent(arg__1);
4804 }
4805 void PythonQtShell_QCPLayer::customEvent(QEvent* arg__1)
4806 {
4807 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4808 static PyObject* name = PyString_FromString("customEvent");
4809 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4810 if (obj) {
4811 static const char* argumentList[] ={"" , "QEvent*"};
4812 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4813 void* args[2] = {NULL, (void*)&arg__1};
4814 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4815 if (result) { Py_DECREF(result); }
4816 Py_DECREF(obj);
4817 return;
4818 } else {
4819 PyErr_Clear();
4820 }
4821 }
4822 QCPLayer::customEvent(arg__1);
4823 }
4824 bool PythonQtShell_QCPLayer::event(QEvent* arg__1)
4825 {
4826 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4827 static PyObject* name = PyString_FromString("event");
4828 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4829 if (obj) {
4830 static const char* argumentList[] ={"bool" , "QEvent*"};
4831 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4832 bool returnValue;
4833 void* args[2] = {NULL, (void*)&arg__1};
4834 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4835 if (result) {
4836 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4837 if (args[0]!=&returnValue) {
4838 if (args[0]==NULL) {
4839 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
4840 } else {
4841 returnValue = *((bool*)args[0]);
4842 }
4843 }
4844 }
4845 if (result) { Py_DECREF(result); }
4846 Py_DECREF(obj);
4847 return returnValue;
4848 } else {
4849 PyErr_Clear();
4850 }
4851 }
4852 return QCPLayer::event(arg__1);
4853 }
4854 bool PythonQtShell_QCPLayer::eventFilter(QObject* arg__1, QEvent* arg__2)
4855 {
4856 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4857 static PyObject* name = PyString_FromString("eventFilter");
4858 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4859 if (obj) {
4860 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
4861 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
4862 bool returnValue;
4863 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
4864 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4865 if (result) {
4866 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4867 if (args[0]!=&returnValue) {
4868 if (args[0]==NULL) {
4869 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
4870 } else {
4871 returnValue = *((bool*)args[0]);
4872 }
4873 }
4874 }
4875 if (result) { Py_DECREF(result); }
4876 Py_DECREF(obj);
4877 return returnValue;
4878 } else {
4879 PyErr_Clear();
4880 }
4881 }
4882 return QCPLayer::eventFilter(arg__1, arg__2);
4883 }
4884 void PythonQtShell_QCPLayer::timerEvent(QTimerEvent* arg__1)
4885 {
4886 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4887 static PyObject* name = PyString_FromString("timerEvent");
4888 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4889 if (obj) {
4890 static const char* argumentList[] ={"" , "QTimerEvent*"};
4891 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4892 void* args[2] = {NULL, (void*)&arg__1};
4893 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4894 if (result) { Py_DECREF(result); }
4895 Py_DECREF(obj);
4896 return;
4897 } else {
4898 PyErr_Clear();
4899 }
4900 }
4901 QCPLayer::timerEvent(arg__1);
4902 }
4903 QCPLayer* PythonQtWrapper_QCPLayer::new_QCPLayer(QCustomPlot* parentPlot, const QString& layerName)
4904 {
4905 return new PythonQtShell_QCPLayer(parentPlot, layerName); }
4906
4907 void PythonQtWrapper_QCPLayer::addChild(QCPLayer* theWrappedObject, QCPLayerable* layerable, bool prepend)
4908 {
4909 ( ((PythonQtPublicPromoter_QCPLayer*)theWrappedObject)->promoted_addChild(layerable, prepend));
4910 }
4911
4912 QList<QCPLayerable* > PythonQtWrapper_QCPLayer::children(QCPLayer* theWrappedObject) const
4913 {
4914 return ( theWrappedObject->children());
4915 }
4916
4917 int PythonQtWrapper_QCPLayer::index(QCPLayer* theWrappedObject) const
4918 {
4919 return ( theWrappedObject->index());
4920 }
4921
4922 QString PythonQtWrapper_QCPLayer::name(QCPLayer* theWrappedObject) const
4923 {
4924 return ( theWrappedObject->name());
4925 }
4926
4927 QCustomPlot* PythonQtWrapper_QCPLayer::parentPlot(QCPLayer* theWrappedObject) const
4928 {
4929 return ( theWrappedObject->parentPlot());
4930 }
4931
4932 void PythonQtWrapper_QCPLayer::removeChild(QCPLayer* theWrappedObject, QCPLayerable* layerable)
4933 {
4934 ( ((PythonQtPublicPromoter_QCPLayer*)theWrappedObject)->promoted_removeChild(layerable));
4935 }
4936
4937 void PythonQtWrapper_QCPLayer::setVisible(QCPLayer* theWrappedObject, bool visible)
4938 {
4939 ( theWrappedObject->setVisible(visible));
4940 }
4941
4942 bool PythonQtWrapper_QCPLayer::visible(QCPLayer* theWrappedObject) const
4943 {
4944 return ( theWrappedObject->visible());
4945 }
4946
4947
4948
4949 PythonQtShell_QCPLayerable::~PythonQtShell_QCPLayerable() {
4950 PythonQtPrivate* priv = PythonQt::priv();
4951 if (priv) { priv->shellClassDeleted(this); }
4952 }
4953 void PythonQtShell_QCPLayerable::applyDefaultAntialiasingHint(QCPPainter* painter0) const
4954 {
4955 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4956 static PyObject* name = PyString_FromString("applyDefaultAntialiasingHint");
4957 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4958 if (obj) {
4959 static const char* argumentList[] ={"" , "QCPPainter*"};
4960 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4961 void* args[2] = {NULL, (void*)&painter0};
4962 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4963 if (result) { Py_DECREF(result); }
4964 Py_DECREF(obj);
4965 return;
4966 } else {
4967 PyErr_Clear();
4968 }
4969 }
4970
4971 }
4972 void PythonQtShell_QCPLayerable::childEvent(QChildEvent* arg__1)
4973 {
4974 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4975 static PyObject* name = PyString_FromString("childEvent");
4976 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4977 if (obj) {
4978 static const char* argumentList[] ={"" , "QChildEvent*"};
4979 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4980 void* args[2] = {NULL, (void*)&arg__1};
4981 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4982 if (result) { Py_DECREF(result); }
4983 Py_DECREF(obj);
4984 return;
4985 } else {
4986 PyErr_Clear();
4987 }
4988 }
4989 QCPLayerable::childEvent(arg__1);
4990 }
4991 QRect PythonQtShell_QCPLayerable::clipRect() const
4992 {
4993 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4994 static PyObject* name = PyString_FromString("clipRect");
4995 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4996 if (obj) {
4997 static const char* argumentList[] ={"QRect"};
4998 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4999 QRect returnValue;
5000 void* args[1] = {NULL};
5001 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5002 if (result) {
5003 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5004 if (args[0]!=&returnValue) {
5005 if (args[0]==NULL) {
5006 PythonQt::priv()->handleVirtualOverloadReturnError("clipRect", methodInfo, result);
5007 } else {
5008 returnValue = *((QRect*)args[0]);
5009 }
5010 }
5011 }
5012 if (result) { Py_DECREF(result); }
5013 Py_DECREF(obj);
5014 return returnValue;
5015 } else {
5016 PyErr_Clear();
5017 }
5018 }
5019 return QCPLayerable::clipRect();
5020 }
5021 void PythonQtShell_QCPLayerable::customEvent(QEvent* arg__1)
5022 {
5023 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5024 static PyObject* name = PyString_FromString("customEvent");
5025 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5026 if (obj) {
5027 static const char* argumentList[] ={"" , "QEvent*"};
5028 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5029 void* args[2] = {NULL, (void*)&arg__1};
5030 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5031 if (result) { Py_DECREF(result); }
5032 Py_DECREF(obj);
5033 return;
5034 } else {
5035 PyErr_Clear();
5036 }
5037 }
5038 QCPLayerable::customEvent(arg__1);
5039 }
5040 void PythonQtShell_QCPLayerable::deselectEvent(bool* selectionStateChanged0)
5041 {
5042 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5043 static PyObject* name = PyString_FromString("deselectEvent");
5044 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5045 if (obj) {
5046 static const char* argumentList[] ={"" , "bool*"};
5047 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5048 void* args[2] = {NULL, (void*)&selectionStateChanged0};
5049 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5050 if (result) { Py_DECREF(result); }
5051 Py_DECREF(obj);
5052 return;
5053 } else {
5054 PyErr_Clear();
5055 }
5056 }
5057 QCPLayerable::deselectEvent(selectionStateChanged0);
5058 }
5059 void PythonQtShell_QCPLayerable::draw(QCPPainter* painter0)
5060 {
5061 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5062 static PyObject* name = PyString_FromString("draw");
5063 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5064 if (obj) {
5065 static const char* argumentList[] ={"" , "QCPPainter*"};
5066 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5067 void* args[2] = {NULL, (void*)&painter0};
5068 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5069 if (result) { Py_DECREF(result); }
5070 Py_DECREF(obj);
5071 return;
5072 } else {
5073 PyErr_Clear();
5074 }
5075 }
5076
5077 }
5078 bool PythonQtShell_QCPLayerable::event(QEvent* arg__1)
5079 {
5080 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5081 static PyObject* name = PyString_FromString("event");
5082 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5083 if (obj) {
5084 static const char* argumentList[] ={"bool" , "QEvent*"};
5085 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5086 bool returnValue;
5087 void* args[2] = {NULL, (void*)&arg__1};
5088 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5089 if (result) {
5090 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5091 if (args[0]!=&returnValue) {
5092 if (args[0]==NULL) {
5093 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
5094 } else {
5095 returnValue = *((bool*)args[0]);
5096 }
5097 }
5098 }
5099 if (result) { Py_DECREF(result); }
5100 Py_DECREF(obj);
5101 return returnValue;
5102 } else {
5103 PyErr_Clear();
5104 }
5105 }
5106 return QCPLayerable::event(arg__1);
5107 }
5108 bool PythonQtShell_QCPLayerable::eventFilter(QObject* arg__1, QEvent* arg__2)
5109 {
5110 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5111 static PyObject* name = PyString_FromString("eventFilter");
5112 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5113 if (obj) {
5114 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
5115 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
5116 bool returnValue;
5117 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
5118 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5119 if (result) {
5120 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5121 if (args[0]!=&returnValue) {
5122 if (args[0]==NULL) {
5123 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
5124 } else {
5125 returnValue = *((bool*)args[0]);
5126 }
5127 }
5128 }
5129 if (result) { Py_DECREF(result); }
5130 Py_DECREF(obj);
5131 return returnValue;
5132 } else {
5133 PyErr_Clear();
5134 }
5135 }
5136 return QCPLayerable::eventFilter(arg__1, arg__2);
5137 }
5138 void PythonQtShell_QCPLayerable::parentPlotInitialized(QCustomPlot* parentPlot0)
5139 {
5140 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5141 static PyObject* name = PyString_FromString("parentPlotInitialized");
5142 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5143 if (obj) {
5144 static const char* argumentList[] ={"" , "QCustomPlot*"};
5145 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5146 void* args[2] = {NULL, (void*)&parentPlot0};
5147 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5148 if (result) { Py_DECREF(result); }
5149 Py_DECREF(obj);
5150 return;
5151 } else {
5152 PyErr_Clear();
5153 }
5154 }
5155 QCPLayerable::parentPlotInitialized(parentPlot0);
5156 }
5157 void PythonQtShell_QCPLayerable::selectEvent(QMouseEvent* event0, bool additive1, const QVariant& details2, bool* selectionStateChanged3)
5158 {
5159 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5160 static PyObject* name = PyString_FromString("selectEvent");
5161 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5162 if (obj) {
5163 static const char* argumentList[] ={"" , "QMouseEvent*" , "bool" , "const QVariant&" , "bool*"};
5164 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList);
5165 void* args[5] = {NULL, (void*)&event0, (void*)&additive1, (void*)&details2, (void*)&selectionStateChanged3};
5166 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5167 if (result) { Py_DECREF(result); }
5168 Py_DECREF(obj);
5169 return;
5170 } else {
5171 PyErr_Clear();
5172 }
5173 }
5174 QCPLayerable::selectEvent(event0, additive1, details2, selectionStateChanged3);
5175 }
5176 double PythonQtShell_QCPLayerable::selectTest(const QPointF& pos0, bool onlySelectable1, QVariant* details2) const
5177 {
5178 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5179 static PyObject* name = PyString_FromString("selectTest");
5180 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5181 if (obj) {
5182 static const char* argumentList[] ={"double" , "const QPointF&" , "bool" , "QVariant*"};
5183 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
5184 double returnValue;
5185 void* args[4] = {NULL, (void*)&pos0, (void*)&onlySelectable1, (void*)&details2};
5186 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5187 if (result) {
5188 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5189 if (args[0]!=&returnValue) {
5190 if (args[0]==NULL) {
5191 PythonQt::priv()->handleVirtualOverloadReturnError("selectTest", methodInfo, result);
5192 } else {
5193 returnValue = *((double*)args[0]);
5194 }
5195 }
5196 }
5197 if (result) { Py_DECREF(result); }
5198 Py_DECREF(obj);
5199 return returnValue;
5200 } else {
5201 PyErr_Clear();
5202 }
5203 }
5204 return QCPLayerable::selectTest(pos0, onlySelectable1, details2);
5205 }
5206 void PythonQtShell_QCPLayerable::timerEvent(QTimerEvent* arg__1)
5207 {
5208 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5209 static PyObject* name = PyString_FromString("timerEvent");
5210 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5211 if (obj) {
5212 static const char* argumentList[] ={"" , "QTimerEvent*"};
5213 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5214 void* args[2] = {NULL, (void*)&arg__1};
5215 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5216 if (result) { Py_DECREF(result); }
5217 Py_DECREF(obj);
5218 return;
5219 } else {
5220 PyErr_Clear();
5221 }
5222 }
5223 QCPLayerable::timerEvent(arg__1);
5224 }
5225 QCPLayerable* PythonQtWrapper_QCPLayerable::new_QCPLayerable(QCustomPlot* plot, QString targetLayer, QCPLayerable* parentLayerable)
5226 {
5227 return new PythonQtShell_QCPLayerable(plot, targetLayer, parentLayerable); }
5228
5229 bool PythonQtWrapper_QCPLayerable::antialiased(QCPLayerable* theWrappedObject) const
5230 {
5231 return ( theWrappedObject->antialiased());
5232 }
5233
5234 void PythonQtWrapper_QCPLayerable::applyDefaultAntialiasingHint(QCPLayerable* theWrappedObject, QCPPainter* painter) const
5235 {
5236 ( ((PythonQtPublicPromoter_QCPLayerable*)theWrappedObject)->promoted_applyDefaultAntialiasingHint(painter));
5237 }
5238
5239 QRect PythonQtWrapper_QCPLayerable::clipRect(QCPLayerable* theWrappedObject) const
5240 {
5241 return ( ((PythonQtPublicPromoter_QCPLayerable*)theWrappedObject)->promoted_clipRect());
5242 }
5243
5244 void PythonQtWrapper_QCPLayerable::deselectEvent(QCPLayerable* theWrappedObject, bool* selectionStateChanged)
5245 {
5246 ( ((PythonQtPublicPromoter_QCPLayerable*)theWrappedObject)->promoted_deselectEvent(selectionStateChanged));
5247 }
5248
5249 void PythonQtWrapper_QCPLayerable::draw(QCPLayerable* theWrappedObject, QCPPainter* painter)
5250 {
5251 ( ((PythonQtPublicPromoter_QCPLayerable*)theWrappedObject)->promoted_draw(painter));
5252 }
5253
5254 void PythonQtWrapper_QCPLayerable::initializeParentPlot(QCPLayerable* theWrappedObject, QCustomPlot* parentPlot)
5255 {
5256 ( ((PythonQtPublicPromoter_QCPLayerable*)theWrappedObject)->promoted_initializeParentPlot(parentPlot));
5257 }
5258
5259 QCPLayer* PythonQtWrapper_QCPLayerable::layer(QCPLayerable* theWrappedObject) const
5260 {
5261 return ( theWrappedObject->layer());
5262 }
5263
5264 bool PythonQtWrapper_QCPLayerable::moveToLayer(QCPLayerable* theWrappedObject, QCPLayer* layer, bool prepend)
5265 {
5266 return ( ((PythonQtPublicPromoter_QCPLayerable*)theWrappedObject)->promoted_moveToLayer(layer, prepend));
5267 }
5268
5269 QCPLayerable* PythonQtWrapper_QCPLayerable::parentLayerable(QCPLayerable* theWrappedObject) const
5270 {
5271 return ( theWrappedObject->parentLayerable());
5272 }
5273
5274 QCustomPlot* PythonQtWrapper_QCPLayerable::parentPlot(QCPLayerable* theWrappedObject) const
5275 {
5276 return ( theWrappedObject->parentPlot());
5277 }
5278
5279 void PythonQtWrapper_QCPLayerable::parentPlotInitialized(QCPLayerable* theWrappedObject, QCustomPlot* parentPlot)
5280 {
5281 ( ((PythonQtPublicPromoter_QCPLayerable*)theWrappedObject)->promoted_parentPlotInitialized(parentPlot));
5282 }
5283
5284 bool PythonQtWrapper_QCPLayerable::realVisibility(QCPLayerable* theWrappedObject) const
5285 {
5286 return ( theWrappedObject->realVisibility());
5287 }
5288
5289 void PythonQtWrapper_QCPLayerable::selectEvent(QCPLayerable* theWrappedObject, QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged)
5290 {
5291 ( ((PythonQtPublicPromoter_QCPLayerable*)theWrappedObject)->promoted_selectEvent(event, additive, details, selectionStateChanged));
5292 }
5293
5294 double PythonQtWrapper_QCPLayerable::selectTest(QCPLayerable* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details) const
5295 {
5296 return ( ((PythonQtPublicPromoter_QCPLayerable*)theWrappedObject)->promoted_selectTest(pos, onlySelectable, details));
5297 }
5298
5299 void PythonQtWrapper_QCPLayerable::setAntialiased(QCPLayerable* theWrappedObject, bool enabled)
5300 {
5301 ( theWrappedObject->setAntialiased(enabled));
5302 }
5303
5304 bool PythonQtWrapper_QCPLayerable::setLayer(QCPLayerable* theWrappedObject, QCPLayer* layer)
5305 {
5306 return ( theWrappedObject->setLayer(layer));
5307 }
5308
5309 bool PythonQtWrapper_QCPLayerable::setLayer(QCPLayerable* theWrappedObject, const QString& layerName)
5310 {
5311 return ( theWrappedObject->setLayer(layerName));
5312 }
5313
5314 void PythonQtWrapper_QCPLayerable::setParentLayerable(QCPLayerable* theWrappedObject, QCPLayerable* parentLayerable)
5315 {
5316 ( ((PythonQtPublicPromoter_QCPLayerable*)theWrappedObject)->promoted_setParentLayerable(parentLayerable));
5317 }
5318
5319 void PythonQtWrapper_QCPLayerable::setVisible(QCPLayerable* theWrappedObject, bool on)
5320 {
5321 ( theWrappedObject->setVisible(on));
5322 }
5323
5324 bool PythonQtWrapper_QCPLayerable::visible(QCPLayerable* theWrappedObject) const
5325 {
5326 return ( theWrappedObject->visible());
5327 }
5328
5329
5330
5331 PythonQtShell_QCPLayout::~PythonQtShell_QCPLayout() {
5332 PythonQtPrivate* priv = PythonQt::priv();
5333 if (priv) { priv->shellClassDeleted(this); }
5334 }
5335 void PythonQtShell_QCPLayout::applyDefaultAntialiasingHint(QCPPainter* painter0) const
5336 {
5337 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5338 static PyObject* name = PyString_FromString("applyDefaultAntialiasingHint");
5339 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5340 if (obj) {
5341 static const char* argumentList[] ={"" , "QCPPainter*"};
5342 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5343 void* args[2] = {NULL, (void*)&painter0};
5344 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5345 if (result) { Py_DECREF(result); }
5346 Py_DECREF(obj);
5347 return;
5348 } else {
5349 PyErr_Clear();
5350 }
5351 }
5352 QCPLayout::applyDefaultAntialiasingHint(painter0);
5353 }
5354 void PythonQtShell_QCPLayout::childEvent(QChildEvent* arg__1)
5355 {
5356 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5357 static PyObject* name = PyString_FromString("childEvent");
5358 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5359 if (obj) {
5360 static const char* argumentList[] ={"" , "QChildEvent*"};
5361 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5362 void* args[2] = {NULL, (void*)&arg__1};
5363 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5364 if (result) { Py_DECREF(result); }
5365 Py_DECREF(obj);
5366 return;
5367 } else {
5368 PyErr_Clear();
5369 }
5370 }
5371 QCPLayout::childEvent(arg__1);
5372 }
5373 QRect PythonQtShell_QCPLayout::clipRect() const
5374 {
5375 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5376 static PyObject* name = PyString_FromString("clipRect");
5377 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5378 if (obj) {
5379 static const char* argumentList[] ={"QRect"};
5380 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5381 QRect returnValue;
5382 void* args[1] = {NULL};
5383 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5384 if (result) {
5385 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5386 if (args[0]!=&returnValue) {
5387 if (args[0]==NULL) {
5388 PythonQt::priv()->handleVirtualOverloadReturnError("clipRect", methodInfo, result);
5389 } else {
5390 returnValue = *((QRect*)args[0]);
5391 }
5392 }
5393 }
5394 if (result) { Py_DECREF(result); }
5395 Py_DECREF(obj);
5396 return returnValue;
5397 } else {
5398 PyErr_Clear();
5399 }
5400 }
5401 return QCPLayout::clipRect();
5402 }
5403 void PythonQtShell_QCPLayout::customEvent(QEvent* arg__1)
5404 {
5405 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5406 static PyObject* name = PyString_FromString("customEvent");
5407 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5408 if (obj) {
5409 static const char* argumentList[] ={"" , "QEvent*"};
5410 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5411 void* args[2] = {NULL, (void*)&arg__1};
5412 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5413 if (result) { Py_DECREF(result); }
5414 Py_DECREF(obj);
5415 return;
5416 } else {
5417 PyErr_Clear();
5418 }
5419 }
5420 QCPLayout::customEvent(arg__1);
5421 }
5422 void PythonQtShell_QCPLayout::deselectEvent(bool* selectionStateChanged0)
5423 {
5424 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5425 static PyObject* name = PyString_FromString("deselectEvent");
5426 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5427 if (obj) {
5428 static const char* argumentList[] ={"" , "bool*"};
5429 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5430 void* args[2] = {NULL, (void*)&selectionStateChanged0};
5431 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5432 if (result) { Py_DECREF(result); }
5433 Py_DECREF(obj);
5434 return;
5435 } else {
5436 PyErr_Clear();
5437 }
5438 }
5439 QCPLayout::deselectEvent(selectionStateChanged0);
5440 }
5441 void PythonQtShell_QCPLayout::draw(QCPPainter* painter0)
5442 {
5443 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5444 static PyObject* name = PyString_FromString("draw");
5445 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5446 if (obj) {
5447 static const char* argumentList[] ={"" , "QCPPainter*"};
5448 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5449 void* args[2] = {NULL, (void*)&painter0};
5450 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5451 if (result) { Py_DECREF(result); }
5452 Py_DECREF(obj);
5453 return;
5454 } else {
5455 PyErr_Clear();
5456 }
5457 }
5458 QCPLayout::draw(painter0);
5459 }
5460 QCPLayoutElement* PythonQtShell_QCPLayout::elementAt(int index0) const
5461 {
5462 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5463 static PyObject* name = PyString_FromString("elementAt");
5464 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5465 if (obj) {
5466 static const char* argumentList[] ={"QCPLayoutElement*" , "int"};
5467 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5468 QCPLayoutElement* returnValue;
5469 void* args[2] = {NULL, (void*)&index0};
5470 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5471 if (result) {
5472 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5473 if (args[0]!=&returnValue) {
5474 if (args[0]==NULL) {
5475 PythonQt::priv()->handleVirtualOverloadReturnError("elementAt", methodInfo, result);
5476 } else {
5477 returnValue = *((QCPLayoutElement**)args[0]);
5478 }
5479 }
5480 }
5481 if (result) { Py_DECREF(result); }
5482 Py_DECREF(obj);
5483 return returnValue;
5484 } else {
5485 PyErr_Clear();
5486 }
5487 }
5488 return 0;
5489 }
5490 int PythonQtShell_QCPLayout::elementCount() const
5491 {
5492 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5493 static PyObject* name = PyString_FromString("elementCount");
5494 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5495 if (obj) {
5496 static const char* argumentList[] ={"int"};
5497 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5498 int returnValue;
5499 void* args[1] = {NULL};
5500 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5501 if (result) {
5502 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5503 if (args[0]!=&returnValue) {
5504 if (args[0]==NULL) {
5505 PythonQt::priv()->handleVirtualOverloadReturnError("elementCount", methodInfo, result);
5506 } else {
5507 returnValue = *((int*)args[0]);
5508 }
5509 }
5510 }
5511 if (result) { Py_DECREF(result); }
5512 Py_DECREF(obj);
5513 return returnValue;
5514 } else {
5515 PyErr_Clear();
5516 }
5517 }
5518 return int();
5519 }
5520 QList<QCPLayoutElement* > PythonQtShell_QCPLayout::elements(bool recursive0) const
5521 {
5522 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5523 static PyObject* name = PyString_FromString("elements");
5524 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5525 if (obj) {
5526 static const char* argumentList[] ={"QList<QCPLayoutElement* >" , "bool"};
5527 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5528 QList<QCPLayoutElement* > returnValue;
5529 void* args[2] = {NULL, (void*)&recursive0};
5530 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5531 if (result) {
5532 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5533 if (args[0]!=&returnValue) {
5534 if (args[0]==NULL) {
5535 PythonQt::priv()->handleVirtualOverloadReturnError("elements", methodInfo, result);
5536 } else {
5537 returnValue = *((QList<QCPLayoutElement* >*)args[0]);
5538 }
5539 }
5540 }
5541 if (result) { Py_DECREF(result); }
5542 Py_DECREF(obj);
5543 return returnValue;
5544 } else {
5545 PyErr_Clear();
5546 }
5547 }
5548 return QCPLayout::elements(recursive0);
5549 }
5550 bool PythonQtShell_QCPLayout::event(QEvent* arg__1)
5551 {
5552 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5553 static PyObject* name = PyString_FromString("event");
5554 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5555 if (obj) {
5556 static const char* argumentList[] ={"bool" , "QEvent*"};
5557 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5558 bool returnValue;
5559 void* args[2] = {NULL, (void*)&arg__1};
5560 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5561 if (result) {
5562 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5563 if (args[0]!=&returnValue) {
5564 if (args[0]==NULL) {
5565 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
5566 } else {
5567 returnValue = *((bool*)args[0]);
5568 }
5569 }
5570 }
5571 if (result) { Py_DECREF(result); }
5572 Py_DECREF(obj);
5573 return returnValue;
5574 } else {
5575 PyErr_Clear();
5576 }
5577 }
5578 return QCPLayout::event(arg__1);
5579 }
5580 bool PythonQtShell_QCPLayout::eventFilter(QObject* arg__1, QEvent* arg__2)
5581 {
5582 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5583 static PyObject* name = PyString_FromString("eventFilter");
5584 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5585 if (obj) {
5586 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
5587 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
5588 bool returnValue;
5589 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
5590 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5591 if (result) {
5592 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5593 if (args[0]!=&returnValue) {
5594 if (args[0]==NULL) {
5595 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
5596 } else {
5597 returnValue = *((bool*)args[0]);
5598 }
5599 }
5600 }
5601 if (result) { Py_DECREF(result); }
5602 Py_DECREF(obj);
5603 return returnValue;
5604 } else {
5605 PyErr_Clear();
5606 }
5607 }
5608 return QCPLayout::eventFilter(arg__1, arg__2);
5609 }
5610 QSize PythonQtShell_QCPLayout::maximumSizeHint() const
5611 {
5612 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5613 static PyObject* name = PyString_FromString("maximumSizeHint");
5614 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5615 if (obj) {
5616 static const char* argumentList[] ={"QSize"};
5617 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5618 QSize returnValue;
5619 void* args[1] = {NULL};
5620 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5621 if (result) {
5622 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5623 if (args[0]!=&returnValue) {
5624 if (args[0]==NULL) {
5625 PythonQt::priv()->handleVirtualOverloadReturnError("maximumSizeHint", methodInfo, result);
5626 } else {
5627 returnValue = *((QSize*)args[0]);
5628 }
5629 }
5630 }
5631 if (result) { Py_DECREF(result); }
5632 Py_DECREF(obj);
5633 return returnValue;
5634 } else {
5635 PyErr_Clear();
5636 }
5637 }
5638 return QCPLayout::maximumSizeHint();
5639 }
5640 QSize PythonQtShell_QCPLayout::minimumSizeHint() const
5641 {
5642 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5643 static PyObject* name = PyString_FromString("minimumSizeHint");
5644 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5645 if (obj) {
5646 static const char* argumentList[] ={"QSize"};
5647 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5648 QSize returnValue;
5649 void* args[1] = {NULL};
5650 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5651 if (result) {
5652 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5653 if (args[0]!=&returnValue) {
5654 if (args[0]==NULL) {
5655 PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result);
5656 } else {
5657 returnValue = *((QSize*)args[0]);
5658 }
5659 }
5660 }
5661 if (result) { Py_DECREF(result); }
5662 Py_DECREF(obj);
5663 return returnValue;
5664 } else {
5665 PyErr_Clear();
5666 }
5667 }
5668 return QCPLayout::minimumSizeHint();
5669 }
5670 void PythonQtShell_QCPLayout::mouseDoubleClickEvent(QMouseEvent* event0)
5671 {
5672 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5673 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
5674 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5675 if (obj) {
5676 static const char* argumentList[] ={"" , "QMouseEvent*"};
5677 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5678 void* args[2] = {NULL, (void*)&event0};
5679 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5680 if (result) { Py_DECREF(result); }
5681 Py_DECREF(obj);
5682 return;
5683 } else {
5684 PyErr_Clear();
5685 }
5686 }
5687 QCPLayout::mouseDoubleClickEvent(event0);
5688 }
5689 void PythonQtShell_QCPLayout::mouseMoveEvent(QMouseEvent* event0)
5690 {
5691 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5692 static PyObject* name = PyString_FromString("mouseMoveEvent");
5693 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5694 if (obj) {
5695 static const char* argumentList[] ={"" , "QMouseEvent*"};
5696 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5697 void* args[2] = {NULL, (void*)&event0};
5698 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5699 if (result) { Py_DECREF(result); }
5700 Py_DECREF(obj);
5701 return;
5702 } else {
5703 PyErr_Clear();
5704 }
5705 }
5706 QCPLayout::mouseMoveEvent(event0);
5707 }
5708 void PythonQtShell_QCPLayout::mousePressEvent(QMouseEvent* event0)
5709 {
5710 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5711 static PyObject* name = PyString_FromString("mousePressEvent");
5712 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5713 if (obj) {
5714 static const char* argumentList[] ={"" , "QMouseEvent*"};
5715 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5716 void* args[2] = {NULL, (void*)&event0};
5717 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5718 if (result) { Py_DECREF(result); }
5719 Py_DECREF(obj);
5720 return;
5721 } else {
5722 PyErr_Clear();
5723 }
5724 }
5725 QCPLayout::mousePressEvent(event0);
5726 }
5727 void PythonQtShell_QCPLayout::mouseReleaseEvent(QMouseEvent* event0)
5728 {
5729 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5730 static PyObject* name = PyString_FromString("mouseReleaseEvent");
5731 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5732 if (obj) {
5733 static const char* argumentList[] ={"" , "QMouseEvent*"};
5734 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5735 void* args[2] = {NULL, (void*)&event0};
5736 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5737 if (result) { Py_DECREF(result); }
5738 Py_DECREF(obj);
5739 return;
5740 } else {
5741 PyErr_Clear();
5742 }
5743 }
5744 QCPLayout::mouseReleaseEvent(event0);
5745 }
5746 void PythonQtShell_QCPLayout::parentPlotInitialized(QCustomPlot* parentPlot0)
5747 {
5748 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5749 static PyObject* name = PyString_FromString("parentPlotInitialized");
5750 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5751 if (obj) {
5752 static const char* argumentList[] ={"" , "QCustomPlot*"};
5753 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5754 void* args[2] = {NULL, (void*)&parentPlot0};
5755 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5756 if (result) { Py_DECREF(result); }
5757 Py_DECREF(obj);
5758 return;
5759 } else {
5760 PyErr_Clear();
5761 }
5762 }
5763 QCPLayout::parentPlotInitialized(parentPlot0);
5764 }
5765 void PythonQtShell_QCPLayout::selectEvent(QMouseEvent* event0, bool additive1, const QVariant& details2, bool* selectionStateChanged3)
5766 {
5767 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5768 static PyObject* name = PyString_FromString("selectEvent");
5769 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5770 if (obj) {
5771 static const char* argumentList[] ={"" , "QMouseEvent*" , "bool" , "const QVariant&" , "bool*"};
5772 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList);
5773 void* args[5] = {NULL, (void*)&event0, (void*)&additive1, (void*)&details2, (void*)&selectionStateChanged3};
5774 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5775 if (result) { Py_DECREF(result); }
5776 Py_DECREF(obj);
5777 return;
5778 } else {
5779 PyErr_Clear();
5780 }
5781 }
5782 QCPLayout::selectEvent(event0, additive1, details2, selectionStateChanged3);
5783 }
5784 double PythonQtShell_QCPLayout::selectTest(const QPointF& pos0, bool onlySelectable1, QVariant* details2) const
5785 {
5786 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5787 static PyObject* name = PyString_FromString("selectTest");
5788 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5789 if (obj) {
5790 static const char* argumentList[] ={"double" , "const QPointF&" , "bool" , "QVariant*"};
5791 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
5792 double returnValue;
5793 void* args[4] = {NULL, (void*)&pos0, (void*)&onlySelectable1, (void*)&details2};
5794 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5795 if (result) {
5796 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5797 if (args[0]!=&returnValue) {
5798 if (args[0]==NULL) {
5799 PythonQt::priv()->handleVirtualOverloadReturnError("selectTest", methodInfo, result);
5800 } else {
5801 returnValue = *((double*)args[0]);
5802 }
5803 }
5804 }
5805 if (result) { Py_DECREF(result); }
5806 Py_DECREF(obj);
5807 return returnValue;
5808 } else {
5809 PyErr_Clear();
5810 }
5811 }
5812 return QCPLayout::selectTest(pos0, onlySelectable1, details2);
5813 }
5814 void PythonQtShell_QCPLayout::simplify()
5815 {
5816 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5817 static PyObject* name = PyString_FromString("simplify");
5818 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5819 if (obj) {
5820 static const char* argumentList[] ={""};
5821 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5822 void* args[1] = {NULL};
5823 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5824 if (result) { Py_DECREF(result); }
5825 Py_DECREF(obj);
5826 return;
5827 } else {
5828 PyErr_Clear();
5829 }
5830 }
5831 QCPLayout::simplify();
5832 }
5833 bool PythonQtShell_QCPLayout::take(QCPLayoutElement* element0)
5834 {
5835 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5836 static PyObject* name = PyString_FromString("take");
5837 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5838 if (obj) {
5839 static const char* argumentList[] ={"bool" , "QCPLayoutElement*"};
5840 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5841 bool returnValue;
5842 void* args[2] = {NULL, (void*)&element0};
5843 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5844 if (result) {
5845 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5846 if (args[0]!=&returnValue) {
5847 if (args[0]==NULL) {
5848 PythonQt::priv()->handleVirtualOverloadReturnError("take", methodInfo, result);
5849 } else {
5850 returnValue = *((bool*)args[0]);
5851 }
5852 }
5853 }
5854 if (result) { Py_DECREF(result); }
5855 Py_DECREF(obj);
5856 return returnValue;
5857 } else {
5858 PyErr_Clear();
5859 }
5860 }
5861 return bool();
5862 }
5863 QCPLayoutElement* PythonQtShell_QCPLayout::takeAt(int index0)
5864 {
5865 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5866 static PyObject* name = PyString_FromString("takeAt");
5867 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5868 if (obj) {
5869 static const char* argumentList[] ={"QCPLayoutElement*" , "int"};
5870 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5871 QCPLayoutElement* returnValue;
5872 void* args[2] = {NULL, (void*)&index0};
5873 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5874 if (result) {
5875 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5876 if (args[0]!=&returnValue) {
5877 if (args[0]==NULL) {
5878 PythonQt::priv()->handleVirtualOverloadReturnError("takeAt", methodInfo, result);
5879 } else {
5880 returnValue = *((QCPLayoutElement**)args[0]);
5881 }
5882 }
5883 }
5884 if (result) { Py_DECREF(result); }
5885 Py_DECREF(obj);
5886 return returnValue;
5887 } else {
5888 PyErr_Clear();
5889 }
5890 }
5891 return 0;
5892 }
5893 void PythonQtShell_QCPLayout::timerEvent(QTimerEvent* arg__1)
5894 {
5895 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5896 static PyObject* name = PyString_FromString("timerEvent");
5897 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5898 if (obj) {
5899 static const char* argumentList[] ={"" , "QTimerEvent*"};
5900 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5901 void* args[2] = {NULL, (void*)&arg__1};
5902 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5903 if (result) { Py_DECREF(result); }
5904 Py_DECREF(obj);
5905 return;
5906 } else {
5907 PyErr_Clear();
5908 }
5909 }
5910 QCPLayout::timerEvent(arg__1);
5911 }
5912 void PythonQtShell_QCPLayout::updateLayout()
5913 {
5914 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5915 static PyObject* name = PyString_FromString("updateLayout");
5916 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5917 if (obj) {
5918 static const char* argumentList[] ={""};
5919 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5920 void* args[1] = {NULL};
5921 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5922 if (result) { Py_DECREF(result); }
5923 Py_DECREF(obj);
5924 return;
5925 } else {
5926 PyErr_Clear();
5927 }
5928 }
5929 QCPLayout::updateLayout();
5930 }
5931 void PythonQtShell_QCPLayout::wheelEvent(QWheelEvent* event0)
5932 {
5933 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5934 static PyObject* name = PyString_FromString("wheelEvent");
5935 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5936 if (obj) {
5937 static const char* argumentList[] ={"" , "QWheelEvent*"};
5938 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5939 void* args[2] = {NULL, (void*)&event0};
5940 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5941 if (result) { Py_DECREF(result); }
5942 Py_DECREF(obj);
5943 return;
5944 } else {
5945 PyErr_Clear();
5946 }
5947 }
5948 QCPLayout::wheelEvent(event0);
5949 }
5950 QCPLayout* PythonQtWrapper_QCPLayout::new_QCPLayout()
5951 {
5952 return new PythonQtShell_QCPLayout(); }
5953
5954 void PythonQtWrapper_QCPLayout::adoptElement(QCPLayout* theWrappedObject, QCPLayoutElement* el)
5955 {
5956 ( ((PythonQtPublicPromoter_QCPLayout*)theWrappedObject)->promoted_adoptElement(el));
5957 }
5958
5959 void PythonQtWrapper_QCPLayout::clear(QCPLayout* theWrappedObject)
5960 {
5961 ( theWrappedObject->clear());
5962 }
5963
5964 QCPLayoutElement* PythonQtWrapper_QCPLayout::elementAt(QCPLayout* theWrappedObject, int index) const
5965 {
5966 return ( ((PythonQtPublicPromoter_QCPLayout*)theWrappedObject)->promoted_elementAt(index));
5967 }
5968
5969 int PythonQtWrapper_QCPLayout::elementCount(QCPLayout* theWrappedObject) const
5970 {
5971 return ( ((PythonQtPublicPromoter_QCPLayout*)theWrappedObject)->promoted_elementCount());
5972 }
5973
5974 QList<QCPLayoutElement* > PythonQtWrapper_QCPLayout::elements(QCPLayout* theWrappedObject, bool recursive) const
5975 {
5976 return ( ((PythonQtPublicPromoter_QCPLayout*)theWrappedObject)->promoted_elements(recursive));
5977 }
5978
5979 QVector<int > PythonQtWrapper_QCPLayout::getSectionSizes(QCPLayout* theWrappedObject, QVector<int > maxSizes, QVector<int > minSizes, QVector<double > stretchFactors, int totalSize) const
5980 {
5981 return ( ((PythonQtPublicPromoter_QCPLayout*)theWrappedObject)->promoted_getSectionSizes(maxSizes, minSizes, stretchFactors, totalSize));
5982 }
5983
5984 void PythonQtWrapper_QCPLayout::releaseElement(QCPLayout* theWrappedObject, QCPLayoutElement* el)
5985 {
5986 ( ((PythonQtPublicPromoter_QCPLayout*)theWrappedObject)->promoted_releaseElement(el));
5987 }
5988
5989 bool PythonQtWrapper_QCPLayout::remove(QCPLayout* theWrappedObject, QCPLayoutElement* element)
5990 {
5991 return ( theWrappedObject->remove(element));
5992 }
5993
5994 bool PythonQtWrapper_QCPLayout::removeAt(QCPLayout* theWrappedObject, int index)
5995 {
5996 return ( theWrappedObject->removeAt(index));
5997 }
5998
5999 void PythonQtWrapper_QCPLayout::simplify(QCPLayout* theWrappedObject)
6000 {
6001 ( ((PythonQtPublicPromoter_QCPLayout*)theWrappedObject)->promoted_simplify());
6002 }
6003
6004 void PythonQtWrapper_QCPLayout::sizeConstraintsChanged(QCPLayout* theWrappedObject) const
6005 {
6006 ( ((PythonQtPublicPromoter_QCPLayout*)theWrappedObject)->promoted_sizeConstraintsChanged());
6007 }
6008
6009 bool PythonQtWrapper_QCPLayout::take(QCPLayout* theWrappedObject, QCPLayoutElement* element)
6010 {
6011 return ( ((PythonQtPublicPromoter_QCPLayout*)theWrappedObject)->promoted_take(element));
6012 }
6013
6014 QCPLayoutElement* PythonQtWrapper_QCPLayout::takeAt(QCPLayout* theWrappedObject, int index)
6015 {
6016 return ( ((PythonQtPublicPromoter_QCPLayout*)theWrappedObject)->promoted_takeAt(index));
6017 }
6018
6019 void PythonQtWrapper_QCPLayout::updateLayout(QCPLayout* theWrappedObject)
6020 {
6021 ( ((PythonQtPublicPromoter_QCPLayout*)theWrappedObject)->promoted_updateLayout());
6022 }
6023
6024
6025
6026 PythonQtShell_QCPLayoutElement::~PythonQtShell_QCPLayoutElement() {
6027 PythonQtPrivate* priv = PythonQt::priv();
6028 if (priv) { priv->shellClassDeleted(this); }
6029 }
6030 void PythonQtShell_QCPLayoutElement::applyDefaultAntialiasingHint(QCPPainter* painter0) const
6031 {
6032 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6033 static PyObject* name = PyString_FromString("applyDefaultAntialiasingHint");
6034 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6035 if (obj) {
6036 static const char* argumentList[] ={"" , "QCPPainter*"};
6037 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6038 void* args[2] = {NULL, (void*)&painter0};
6039 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6040 if (result) { Py_DECREF(result); }
6041 Py_DECREF(obj);
6042 return;
6043 } else {
6044 PyErr_Clear();
6045 }
6046 }
6047 QCPLayoutElement::applyDefaultAntialiasingHint(painter0);
6048 }
6049 void PythonQtShell_QCPLayoutElement::childEvent(QChildEvent* arg__1)
6050 {
6051 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6052 static PyObject* name = PyString_FromString("childEvent");
6053 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6054 if (obj) {
6055 static const char* argumentList[] ={"" , "QChildEvent*"};
6056 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6057 void* args[2] = {NULL, (void*)&arg__1};
6058 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6059 if (result) { Py_DECREF(result); }
6060 Py_DECREF(obj);
6061 return;
6062 } else {
6063 PyErr_Clear();
6064 }
6065 }
6066 QCPLayoutElement::childEvent(arg__1);
6067 }
6068 QRect PythonQtShell_QCPLayoutElement::clipRect() const
6069 {
6070 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6071 static PyObject* name = PyString_FromString("clipRect");
6072 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6073 if (obj) {
6074 static const char* argumentList[] ={"QRect"};
6075 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6076 QRect returnValue;
6077 void* args[1] = {NULL};
6078 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6079 if (result) {
6080 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6081 if (args[0]!=&returnValue) {
6082 if (args[0]==NULL) {
6083 PythonQt::priv()->handleVirtualOverloadReturnError("clipRect", methodInfo, result);
6084 } else {
6085 returnValue = *((QRect*)args[0]);
6086 }
6087 }
6088 }
6089 if (result) { Py_DECREF(result); }
6090 Py_DECREF(obj);
6091 return returnValue;
6092 } else {
6093 PyErr_Clear();
6094 }
6095 }
6096 return QCPLayoutElement::clipRect();
6097 }
6098 void PythonQtShell_QCPLayoutElement::customEvent(QEvent* arg__1)
6099 {
6100 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6101 static PyObject* name = PyString_FromString("customEvent");
6102 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6103 if (obj) {
6104 static const char* argumentList[] ={"" , "QEvent*"};
6105 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6106 void* args[2] = {NULL, (void*)&arg__1};
6107 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6108 if (result) { Py_DECREF(result); }
6109 Py_DECREF(obj);
6110 return;
6111 } else {
6112 PyErr_Clear();
6113 }
6114 }
6115 QCPLayoutElement::customEvent(arg__1);
6116 }
6117 void PythonQtShell_QCPLayoutElement::deselectEvent(bool* selectionStateChanged0)
6118 {
6119 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6120 static PyObject* name = PyString_FromString("deselectEvent");
6121 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6122 if (obj) {
6123 static const char* argumentList[] ={"" , "bool*"};
6124 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6125 void* args[2] = {NULL, (void*)&selectionStateChanged0};
6126 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6127 if (result) { Py_DECREF(result); }
6128 Py_DECREF(obj);
6129 return;
6130 } else {
6131 PyErr_Clear();
6132 }
6133 }
6134 QCPLayoutElement::deselectEvent(selectionStateChanged0);
6135 }
6136 void PythonQtShell_QCPLayoutElement::draw(QCPPainter* painter0)
6137 {
6138 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6139 static PyObject* name = PyString_FromString("draw");
6140 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6141 if (obj) {
6142 static const char* argumentList[] ={"" , "QCPPainter*"};
6143 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6144 void* args[2] = {NULL, (void*)&painter0};
6145 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6146 if (result) { Py_DECREF(result); }
6147 Py_DECREF(obj);
6148 return;
6149 } else {
6150 PyErr_Clear();
6151 }
6152 }
6153 QCPLayoutElement::draw(painter0);
6154 }
6155 QList<QCPLayoutElement* > PythonQtShell_QCPLayoutElement::elements(bool recursive0) const
6156 {
6157 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6158 static PyObject* name = PyString_FromString("elements");
6159 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6160 if (obj) {
6161 static const char* argumentList[] ={"QList<QCPLayoutElement* >" , "bool"};
6162 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6163 QList<QCPLayoutElement* > returnValue;
6164 void* args[2] = {NULL, (void*)&recursive0};
6165 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6166 if (result) {
6167 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6168 if (args[0]!=&returnValue) {
6169 if (args[0]==NULL) {
6170 PythonQt::priv()->handleVirtualOverloadReturnError("elements", methodInfo, result);
6171 } else {
6172 returnValue = *((QList<QCPLayoutElement* >*)args[0]);
6173 }
6174 }
6175 }
6176 if (result) { Py_DECREF(result); }
6177 Py_DECREF(obj);
6178 return returnValue;
6179 } else {
6180 PyErr_Clear();
6181 }
6182 }
6183 return QCPLayoutElement::elements(recursive0);
6184 }
6185 bool PythonQtShell_QCPLayoutElement::event(QEvent* arg__1)
6186 {
6187 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6188 static PyObject* name = PyString_FromString("event");
6189 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6190 if (obj) {
6191 static const char* argumentList[] ={"bool" , "QEvent*"};
6192 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6193 bool returnValue;
6194 void* args[2] = {NULL, (void*)&arg__1};
6195 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6196 if (result) {
6197 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6198 if (args[0]!=&returnValue) {
6199 if (args[0]==NULL) {
6200 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
6201 } else {
6202 returnValue = *((bool*)args[0]);
6203 }
6204 }
6205 }
6206 if (result) { Py_DECREF(result); }
6207 Py_DECREF(obj);
6208 return returnValue;
6209 } else {
6210 PyErr_Clear();
6211 }
6212 }
6213 return QCPLayoutElement::event(arg__1);
6214 }
6215 bool PythonQtShell_QCPLayoutElement::eventFilter(QObject* arg__1, QEvent* arg__2)
6216 {
6217 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6218 static PyObject* name = PyString_FromString("eventFilter");
6219 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6220 if (obj) {
6221 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
6222 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
6223 bool returnValue;
6224 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
6225 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6226 if (result) {
6227 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6228 if (args[0]!=&returnValue) {
6229 if (args[0]==NULL) {
6230 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
6231 } else {
6232 returnValue = *((bool*)args[0]);
6233 }
6234 }
6235 }
6236 if (result) { Py_DECREF(result); }
6237 Py_DECREF(obj);
6238 return returnValue;
6239 } else {
6240 PyErr_Clear();
6241 }
6242 }
6243 return QCPLayoutElement::eventFilter(arg__1, arg__2);
6244 }
6245 QSize PythonQtShell_QCPLayoutElement::maximumSizeHint() const
6246 {
6247 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6248 static PyObject* name = PyString_FromString("maximumSizeHint");
6249 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6250 if (obj) {
6251 static const char* argumentList[] ={"QSize"};
6252 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6253 QSize returnValue;
6254 void* args[1] = {NULL};
6255 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6256 if (result) {
6257 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6258 if (args[0]!=&returnValue) {
6259 if (args[0]==NULL) {
6260 PythonQt::priv()->handleVirtualOverloadReturnError("maximumSizeHint", methodInfo, result);
6261 } else {
6262 returnValue = *((QSize*)args[0]);
6263 }
6264 }
6265 }
6266 if (result) { Py_DECREF(result); }
6267 Py_DECREF(obj);
6268 return returnValue;
6269 } else {
6270 PyErr_Clear();
6271 }
6272 }
6273 return QCPLayoutElement::maximumSizeHint();
6274 }
6275 QSize PythonQtShell_QCPLayoutElement::minimumSizeHint() const
6276 {
6277 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6278 static PyObject* name = PyString_FromString("minimumSizeHint");
6279 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6280 if (obj) {
6281 static const char* argumentList[] ={"QSize"};
6282 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6283 QSize returnValue;
6284 void* args[1] = {NULL};
6285 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6286 if (result) {
6287 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6288 if (args[0]!=&returnValue) {
6289 if (args[0]==NULL) {
6290 PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result);
6291 } else {
6292 returnValue = *((QSize*)args[0]);
6293 }
6294 }
6295 }
6296 if (result) { Py_DECREF(result); }
6297 Py_DECREF(obj);
6298 return returnValue;
6299 } else {
6300 PyErr_Clear();
6301 }
6302 }
6303 return QCPLayoutElement::minimumSizeHint();
6304 }
6305 void PythonQtShell_QCPLayoutElement::mouseDoubleClickEvent(QMouseEvent* event0)
6306 {
6307 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6308 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
6309 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6310 if (obj) {
6311 static const char* argumentList[] ={"" , "QMouseEvent*"};
6312 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6313 void* args[2] = {NULL, (void*)&event0};
6314 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6315 if (result) { Py_DECREF(result); }
6316 Py_DECREF(obj);
6317 return;
6318 } else {
6319 PyErr_Clear();
6320 }
6321 }
6322 QCPLayoutElement::mouseDoubleClickEvent(event0);
6323 }
6324 void PythonQtShell_QCPLayoutElement::mouseMoveEvent(QMouseEvent* event0)
6325 {
6326 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6327 static PyObject* name = PyString_FromString("mouseMoveEvent");
6328 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6329 if (obj) {
6330 static const char* argumentList[] ={"" , "QMouseEvent*"};
6331 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6332 void* args[2] = {NULL, (void*)&event0};
6333 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6334 if (result) { Py_DECREF(result); }
6335 Py_DECREF(obj);
6336 return;
6337 } else {
6338 PyErr_Clear();
6339 }
6340 }
6341 QCPLayoutElement::mouseMoveEvent(event0);
6342 }
6343 void PythonQtShell_QCPLayoutElement::mousePressEvent(QMouseEvent* event0)
6344 {
6345 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6346 static PyObject* name = PyString_FromString("mousePressEvent");
6347 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6348 if (obj) {
6349 static const char* argumentList[] ={"" , "QMouseEvent*"};
6350 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6351 void* args[2] = {NULL, (void*)&event0};
6352 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6353 if (result) { Py_DECREF(result); }
6354 Py_DECREF(obj);
6355 return;
6356 } else {
6357 PyErr_Clear();
6358 }
6359 }
6360 QCPLayoutElement::mousePressEvent(event0);
6361 }
6362 void PythonQtShell_QCPLayoutElement::mouseReleaseEvent(QMouseEvent* event0)
6363 {
6364 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6365 static PyObject* name = PyString_FromString("mouseReleaseEvent");
6366 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6367 if (obj) {
6368 static const char* argumentList[] ={"" , "QMouseEvent*"};
6369 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6370 void* args[2] = {NULL, (void*)&event0};
6371 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6372 if (result) { Py_DECREF(result); }
6373 Py_DECREF(obj);
6374 return;
6375 } else {
6376 PyErr_Clear();
6377 }
6378 }
6379 QCPLayoutElement::mouseReleaseEvent(event0);
6380 }
6381 void PythonQtShell_QCPLayoutElement::parentPlotInitialized(QCustomPlot* parentPlot0)
6382 {
6383 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6384 static PyObject* name = PyString_FromString("parentPlotInitialized");
6385 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6386 if (obj) {
6387 static const char* argumentList[] ={"" , "QCustomPlot*"};
6388 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6389 void* args[2] = {NULL, (void*)&parentPlot0};
6390 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6391 if (result) { Py_DECREF(result); }
6392 Py_DECREF(obj);
6393 return;
6394 } else {
6395 PyErr_Clear();
6396 }
6397 }
6398 QCPLayoutElement::parentPlotInitialized(parentPlot0);
6399 }
6400 void PythonQtShell_QCPLayoutElement::selectEvent(QMouseEvent* event0, bool additive1, const QVariant& details2, bool* selectionStateChanged3)
6401 {
6402 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6403 static PyObject* name = PyString_FromString("selectEvent");
6404 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6405 if (obj) {
6406 static const char* argumentList[] ={"" , "QMouseEvent*" , "bool" , "const QVariant&" , "bool*"};
6407 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList);
6408 void* args[5] = {NULL, (void*)&event0, (void*)&additive1, (void*)&details2, (void*)&selectionStateChanged3};
6409 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6410 if (result) { Py_DECREF(result); }
6411 Py_DECREF(obj);
6412 return;
6413 } else {
6414 PyErr_Clear();
6415 }
6416 }
6417 QCPLayoutElement::selectEvent(event0, additive1, details2, selectionStateChanged3);
6418 }
6419 double PythonQtShell_QCPLayoutElement::selectTest(const QPointF& pos0, bool onlySelectable1, QVariant* details2) const
6420 {
6421 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6422 static PyObject* name = PyString_FromString("selectTest");
6423 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6424 if (obj) {
6425 static const char* argumentList[] ={"double" , "const QPointF&" , "bool" , "QVariant*"};
6426 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
6427 double returnValue;
6428 void* args[4] = {NULL, (void*)&pos0, (void*)&onlySelectable1, (void*)&details2};
6429 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6430 if (result) {
6431 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6432 if (args[0]!=&returnValue) {
6433 if (args[0]==NULL) {
6434 PythonQt::priv()->handleVirtualOverloadReturnError("selectTest", methodInfo, result);
6435 } else {
6436 returnValue = *((double*)args[0]);
6437 }
6438 }
6439 }
6440 if (result) { Py_DECREF(result); }
6441 Py_DECREF(obj);
6442 return returnValue;
6443 } else {
6444 PyErr_Clear();
6445 }
6446 }
6447 return QCPLayoutElement::selectTest(pos0, onlySelectable1, details2);
6448 }
6449 void PythonQtShell_QCPLayoutElement::timerEvent(QTimerEvent* arg__1)
6450 {
6451 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6452 static PyObject* name = PyString_FromString("timerEvent");
6453 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6454 if (obj) {
6455 static const char* argumentList[] ={"" , "QTimerEvent*"};
6456 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6457 void* args[2] = {NULL, (void*)&arg__1};
6458 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6459 if (result) { Py_DECREF(result); }
6460 Py_DECREF(obj);
6461 return;
6462 } else {
6463 PyErr_Clear();
6464 }
6465 }
6466 QCPLayoutElement::timerEvent(arg__1);
6467 }
6468 void PythonQtShell_QCPLayoutElement::wheelEvent(QWheelEvent* event0)
6469 {
6470 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6471 static PyObject* name = PyString_FromString("wheelEvent");
6472 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6473 if (obj) {
6474 static const char* argumentList[] ={"" , "QWheelEvent*"};
6475 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6476 void* args[2] = {NULL, (void*)&event0};
6477 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6478 if (result) { Py_DECREF(result); }
6479 Py_DECREF(obj);
6480 return;
6481 } else {
6482 PyErr_Clear();
6483 }
6484 }
6485 QCPLayoutElement::wheelEvent(event0);
6486 }
6487 QCPLayoutElement* PythonQtWrapper_QCPLayoutElement::new_QCPLayoutElement(QCustomPlot* parentPlot)
6488 {
6489 return new PythonQtShell_QCPLayoutElement(parentPlot); }
6490
6491 void PythonQtWrapper_QCPLayoutElement::applyDefaultAntialiasingHint(QCPLayoutElement* theWrappedObject, QCPPainter* painter) const
6492 {
6493 ( ((PythonQtPublicPromoter_QCPLayoutElement*)theWrappedObject)->promoted_applyDefaultAntialiasingHint(painter));
6494 }
6495
6496 void PythonQtWrapper_QCPLayoutElement::draw(QCPLayoutElement* theWrappedObject, QCPPainter* painter)
6497 {
6498 ( ((PythonQtPublicPromoter_QCPLayoutElement*)theWrappedObject)->promoted_draw(painter));
6499 }
6500
6501 QList<QCPLayoutElement* > PythonQtWrapper_QCPLayoutElement::elements(QCPLayoutElement* theWrappedObject, bool recursive) const
6502 {
6503 return ( ((PythonQtPublicPromoter_QCPLayoutElement*)theWrappedObject)->promoted_elements(recursive));
6504 }
6505
6506 QCPLayout* PythonQtWrapper_QCPLayoutElement::layout(QCPLayoutElement* theWrappedObject) const
6507 {
6508 return ( theWrappedObject->layout());
6509 }
6510
6511 QMargins PythonQtWrapper_QCPLayoutElement::margins(QCPLayoutElement* theWrappedObject) const
6512 {
6513 return ( theWrappedObject->margins());
6514 }
6515
6516 QSize PythonQtWrapper_QCPLayoutElement::maximumSize(QCPLayoutElement* theWrappedObject) const
6517 {
6518 return ( theWrappedObject->maximumSize());
6519 }
6520
6521 QSize PythonQtWrapper_QCPLayoutElement::maximumSizeHint(QCPLayoutElement* theWrappedObject) const
6522 {
6523 return ( ((PythonQtPublicPromoter_QCPLayoutElement*)theWrappedObject)->promoted_maximumSizeHint());
6524 }
6525
6526 QMargins PythonQtWrapper_QCPLayoutElement::minimumMargins(QCPLayoutElement* theWrappedObject) const
6527 {
6528 return ( theWrappedObject->minimumMargins());
6529 }
6530
6531 QSize PythonQtWrapper_QCPLayoutElement::minimumSize(QCPLayoutElement* theWrappedObject) const
6532 {
6533 return ( theWrappedObject->minimumSize());
6534 }
6535
6536 QSize PythonQtWrapper_QCPLayoutElement::minimumSizeHint(QCPLayoutElement* theWrappedObject) const
6537 {
6538 return ( ((PythonQtPublicPromoter_QCPLayoutElement*)theWrappedObject)->promoted_minimumSizeHint());
6539 }
6540
6541 void PythonQtWrapper_QCPLayoutElement::mouseDoubleClickEvent(QCPLayoutElement* theWrappedObject, QMouseEvent* event)
6542 {
6543 ( ((PythonQtPublicPromoter_QCPLayoutElement*)theWrappedObject)->promoted_mouseDoubleClickEvent(event));
6544 }
6545
6546 void PythonQtWrapper_QCPLayoutElement::mouseMoveEvent(QCPLayoutElement* theWrappedObject, QMouseEvent* event)
6547 {
6548 ( ((PythonQtPublicPromoter_QCPLayoutElement*)theWrappedObject)->promoted_mouseMoveEvent(event));
6549 }
6550
6551 void PythonQtWrapper_QCPLayoutElement::mousePressEvent(QCPLayoutElement* theWrappedObject, QMouseEvent* event)
6552 {
6553 ( ((PythonQtPublicPromoter_QCPLayoutElement*)theWrappedObject)->promoted_mousePressEvent(event));
6554 }
6555
6556 void PythonQtWrapper_QCPLayoutElement::mouseReleaseEvent(QCPLayoutElement* theWrappedObject, QMouseEvent* event)
6557 {
6558 ( ((PythonQtPublicPromoter_QCPLayoutElement*)theWrappedObject)->promoted_mouseReleaseEvent(event));
6559 }
6560
6561 QRect PythonQtWrapper_QCPLayoutElement::outerRect(QCPLayoutElement* theWrappedObject) const
6562 {
6563 return ( theWrappedObject->outerRect());
6564 }
6565
6566 void PythonQtWrapper_QCPLayoutElement::parentPlotInitialized(QCPLayoutElement* theWrappedObject, QCustomPlot* parentPlot)
6567 {
6568 ( ((PythonQtPublicPromoter_QCPLayoutElement*)theWrappedObject)->promoted_parentPlotInitialized(parentPlot));
6569 }
6570
6571 QRect PythonQtWrapper_QCPLayoutElement::rect(QCPLayoutElement* theWrappedObject) const
6572 {
6573 return ( theWrappedObject->rect());
6574 }
6575
6576 double PythonQtWrapper_QCPLayoutElement::selectTest(QCPLayoutElement* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details) const
6577 {
6578 return ( ((PythonQtPublicPromoter_QCPLayoutElement*)theWrappedObject)->promoted_selectTest(pos, onlySelectable, details));
6579 }
6580
6581 void PythonQtWrapper_QCPLayoutElement::setMargins(QCPLayoutElement* theWrappedObject, const QMargins& margins)
6582 {
6583 ( theWrappedObject->setMargins(margins));
6584 }
6585
6586 void PythonQtWrapper_QCPLayoutElement::setMaximumSize(QCPLayoutElement* theWrappedObject, const QSize& size)
6587 {
6588 ( theWrappedObject->setMaximumSize(size));
6589 }
6590
6591 void PythonQtWrapper_QCPLayoutElement::setMaximumSize(QCPLayoutElement* theWrappedObject, int width, int height)
6592 {
6593 ( theWrappedObject->setMaximumSize(width, height));
6594 }
6595
6596 void PythonQtWrapper_QCPLayoutElement::setMinimumMargins(QCPLayoutElement* theWrappedObject, const QMargins& margins)
6597 {
6598 ( theWrappedObject->setMinimumMargins(margins));
6599 }
6600
6601 void PythonQtWrapper_QCPLayoutElement::setMinimumSize(QCPLayoutElement* theWrappedObject, const QSize& size)
6602 {
6603 ( theWrappedObject->setMinimumSize(size));
6604 }
6605
6606 void PythonQtWrapper_QCPLayoutElement::setMinimumSize(QCPLayoutElement* theWrappedObject, int width, int height)
6607 {
6608 ( theWrappedObject->setMinimumSize(width, height));
6609 }
6610
6611 void PythonQtWrapper_QCPLayoutElement::setOuterRect(QCPLayoutElement* theWrappedObject, const QRect& rect)
6612 {
6613 ( theWrappedObject->setOuterRect(rect));
6614 }
6615
6616 void PythonQtWrapper_QCPLayoutElement::wheelEvent(QCPLayoutElement* theWrappedObject, QWheelEvent* event)
6617 {
6618 ( ((PythonQtPublicPromoter_QCPLayoutElement*)theWrappedObject)->promoted_wheelEvent(event));
6619 }
6620
6621
6622
6623 PythonQtShell_QCPLegend::~PythonQtShell_QCPLegend() {
6624 PythonQtPrivate* priv = PythonQt::priv();
6625 if (priv) { priv->shellClassDeleted(this); }
6626 }
6627 void PythonQtShell_QCPLegend::applyDefaultAntialiasingHint(QCPPainter* painter0) const
6628 {
6629 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6630 static PyObject* name = PyString_FromString("applyDefaultAntialiasingHint");
6631 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6632 if (obj) {
6633 static const char* argumentList[] ={"" , "QCPPainter*"};
6634 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6635 void* args[2] = {NULL, (void*)&painter0};
6636 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6637 if (result) { Py_DECREF(result); }
6638 Py_DECREF(obj);
6639 return;
6640 } else {
6641 PyErr_Clear();
6642 }
6643 }
6644 QCPLegend::applyDefaultAntialiasingHint(painter0);
6645 }
6646 void PythonQtShell_QCPLegend::deselectEvent(bool* selectionStateChanged0)
6647 {
6648 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6649 static PyObject* name = PyString_FromString("deselectEvent");
6650 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6651 if (obj) {
6652 static const char* argumentList[] ={"" , "bool*"};
6653 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6654 void* args[2] = {NULL, (void*)&selectionStateChanged0};
6655 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6656 if (result) { Py_DECREF(result); }
6657 Py_DECREF(obj);
6658 return;
6659 } else {
6660 PyErr_Clear();
6661 }
6662 }
6663 QCPLegend::deselectEvent(selectionStateChanged0);
6664 }
6665 void PythonQtShell_QCPLegend::draw(QCPPainter* painter0)
6666 {
6667 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6668 static PyObject* name = PyString_FromString("draw");
6669 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6670 if (obj) {
6671 static const char* argumentList[] ={"" , "QCPPainter*"};
6672 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6673 void* args[2] = {NULL, (void*)&painter0};
6674 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6675 if (result) { Py_DECREF(result); }
6676 Py_DECREF(obj);
6677 return;
6678 } else {
6679 PyErr_Clear();
6680 }
6681 }
6682 QCPLegend::draw(painter0);
6683 }
6684 void PythonQtShell_QCPLegend::parentPlotInitialized(QCustomPlot* parentPlot0)
6685 {
6686 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6687 static PyObject* name = PyString_FromString("parentPlotInitialized");
6688 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6689 if (obj) {
6690 static const char* argumentList[] ={"" , "QCustomPlot*"};
6691 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6692 void* args[2] = {NULL, (void*)&parentPlot0};
6693 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6694 if (result) { Py_DECREF(result); }
6695 Py_DECREF(obj);
6696 return;
6697 } else {
6698 PyErr_Clear();
6699 }
6700 }
6701 QCPLegend::parentPlotInitialized(parentPlot0);
6702 }
6703 void PythonQtShell_QCPLegend::selectEvent(QMouseEvent* event0, bool additive1, const QVariant& details2, bool* selectionStateChanged3)
6704 {
6705 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6706 static PyObject* name = PyString_FromString("selectEvent");
6707 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6708 if (obj) {
6709 static const char* argumentList[] ={"" , "QMouseEvent*" , "bool" , "const QVariant&" , "bool*"};
6710 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList);
6711 void* args[5] = {NULL, (void*)&event0, (void*)&additive1, (void*)&details2, (void*)&selectionStateChanged3};
6712 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6713 if (result) { Py_DECREF(result); }
6714 Py_DECREF(obj);
6715 return;
6716 } else {
6717 PyErr_Clear();
6718 }
6719 }
6720 QCPLegend::selectEvent(event0, additive1, details2, selectionStateChanged3);
6721 }
6722 double PythonQtShell_QCPLegend::selectTest(const QPointF& pos0, bool onlySelectable1, QVariant* details2) const
6723 {
6724 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6725 static PyObject* name = PyString_FromString("selectTest");
6726 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6727 if (obj) {
6728 static const char* argumentList[] ={"double" , "const QPointF&" , "bool" , "QVariant*"};
6729 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
6730 double returnValue;
6731 void* args[4] = {NULL, (void*)&pos0, (void*)&onlySelectable1, (void*)&details2};
6732 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6733 if (result) {
6734 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6735 if (args[0]!=&returnValue) {
6736 if (args[0]==NULL) {
6737 PythonQt::priv()->handleVirtualOverloadReturnError("selectTest", methodInfo, result);
6738 } else {
6739 returnValue = *((double*)args[0]);
6740 }
6741 }
6742 }
6743 if (result) { Py_DECREF(result); }
6744 Py_DECREF(obj);
6745 return returnValue;
6746 } else {
6747 PyErr_Clear();
6748 }
6749 }
6750 return QCPLegend::selectTest(pos0, onlySelectable1, details2);
6751 }
6752 QCPLegend* PythonQtWrapper_QCPLegend::new_QCPLegend()
6753 {
6754 return new PythonQtShell_QCPLegend(); }
6755
6756 bool PythonQtWrapper_QCPLegend::addItem(QCPLegend* theWrappedObject, QCPAbstractLegendItem* item)
6757 {
6758 return ( theWrappedObject->addItem(item));
6759 }
6760
6761 void PythonQtWrapper_QCPLegend::applyDefaultAntialiasingHint(QCPLegend* theWrappedObject, QCPPainter* painter) const
6762 {
6763 ( ((PythonQtPublicPromoter_QCPLegend*)theWrappedObject)->promoted_applyDefaultAntialiasingHint(painter));
6764 }
6765
6766 QPen PythonQtWrapper_QCPLegend::borderPen(QCPLegend* theWrappedObject) const
6767 {
6768 return ( theWrappedObject->borderPen());
6769 }
6770
6771 QBrush PythonQtWrapper_QCPLegend::brush(QCPLegend* theWrappedObject) const
6772 {
6773 return ( theWrappedObject->brush());
6774 }
6775
6776 void PythonQtWrapper_QCPLegend::clearItems(QCPLegend* theWrappedObject)
6777 {
6778 ( theWrappedObject->clearItems());
6779 }
6780
6781 void PythonQtWrapper_QCPLegend::deselectEvent(QCPLegend* theWrappedObject, bool* selectionStateChanged)
6782 {
6783 ( ((PythonQtPublicPromoter_QCPLegend*)theWrappedObject)->promoted_deselectEvent(selectionStateChanged));
6784 }
6785
6786 void PythonQtWrapper_QCPLegend::draw(QCPLegend* theWrappedObject, QCPPainter* painter)
6787 {
6788 ( ((PythonQtPublicPromoter_QCPLegend*)theWrappedObject)->promoted_draw(painter));
6789 }
6790
6791 QFont PythonQtWrapper_QCPLegend::font(QCPLegend* theWrappedObject) const
6792 {
6793 return ( theWrappedObject->font());
6794 }
6795
6796 QPen PythonQtWrapper_QCPLegend::getBorderPen(QCPLegend* theWrappedObject) const
6797 {
6798 return ( ((PythonQtPublicPromoter_QCPLegend*)theWrappedObject)->promoted_getBorderPen());
6799 }
6800
6801 QBrush PythonQtWrapper_QCPLegend::getBrush(QCPLegend* theWrappedObject) const
6802 {
6803 return ( ((PythonQtPublicPromoter_QCPLegend*)theWrappedObject)->promoted_getBrush());
6804 }
6805
6806 bool PythonQtWrapper_QCPLegend::hasItem(QCPLegend* theWrappedObject, QCPAbstractLegendItem* item) const
6807 {
6808 return ( theWrappedObject->hasItem(item));
6809 }
6810
6811 QPen PythonQtWrapper_QCPLegend::iconBorderPen(QCPLegend* theWrappedObject) const
6812 {
6813 return ( theWrappedObject->iconBorderPen());
6814 }
6815
6816 QSize PythonQtWrapper_QCPLegend::iconSize(QCPLegend* theWrappedObject) const
6817 {
6818 return ( theWrappedObject->iconSize());
6819 }
6820
6821 int PythonQtWrapper_QCPLegend::iconTextPadding(QCPLegend* theWrappedObject) const
6822 {
6823 return ( theWrappedObject->iconTextPadding());
6824 }
6825
6826 QCPAbstractLegendItem* PythonQtWrapper_QCPLegend::item(QCPLegend* theWrappedObject, int index) const
6827 {
6828 return ( theWrappedObject->item(index));
6829 }
6830
6831 int PythonQtWrapper_QCPLegend::itemCount(QCPLegend* theWrappedObject) const
6832 {
6833 return ( theWrappedObject->itemCount());
6834 }
6835
6836 void PythonQtWrapper_QCPLegend::parentPlotInitialized(QCPLegend* theWrappedObject, QCustomPlot* parentPlot)
6837 {
6838 ( ((PythonQtPublicPromoter_QCPLegend*)theWrappedObject)->promoted_parentPlotInitialized(parentPlot));
6839 }
6840
6841 bool PythonQtWrapper_QCPLegend::removeItem(QCPLegend* theWrappedObject, QCPAbstractLegendItem* item)
6842 {
6843 return ( theWrappedObject->removeItem(item));
6844 }
6845
6846 bool PythonQtWrapper_QCPLegend::removeItem(QCPLegend* theWrappedObject, int index)
6847 {
6848 return ( theWrappedObject->removeItem(index));
6849 }
6850
6851 void PythonQtWrapper_QCPLegend::selectEvent(QCPLegend* theWrappedObject, QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged)
6852 {
6853 ( ((PythonQtPublicPromoter_QCPLegend*)theWrappedObject)->promoted_selectEvent(event, additive, details, selectionStateChanged));
6854 }
6855
6856 double PythonQtWrapper_QCPLegend::selectTest(QCPLegend* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details) const
6857 {
6858 return ( ((PythonQtPublicPromoter_QCPLegend*)theWrappedObject)->promoted_selectTest(pos, onlySelectable, details));
6859 }
6860
6861 QPen PythonQtWrapper_QCPLegend::selectedBorderPen(QCPLegend* theWrappedObject) const
6862 {
6863 return ( theWrappedObject->selectedBorderPen());
6864 }
6865
6866 QBrush PythonQtWrapper_QCPLegend::selectedBrush(QCPLegend* theWrappedObject) const
6867 {
6868 return ( theWrappedObject->selectedBrush());
6869 }
6870
6871 QFont PythonQtWrapper_QCPLegend::selectedFont(QCPLegend* theWrappedObject) const
6872 {
6873 return ( theWrappedObject->selectedFont());
6874 }
6875
6876 QPen PythonQtWrapper_QCPLegend::selectedIconBorderPen(QCPLegend* theWrappedObject) const
6877 {
6878 return ( theWrappedObject->selectedIconBorderPen());
6879 }
6880
6881 QList<QCPAbstractLegendItem* > PythonQtWrapper_QCPLegend::selectedItems(QCPLegend* theWrappedObject) const
6882 {
6883 return ( theWrappedObject->selectedItems());
6884 }
6885
6886 QColor PythonQtWrapper_QCPLegend::selectedTextColor(QCPLegend* theWrappedObject) const
6887 {
6888 return ( theWrappedObject->selectedTextColor());
6889 }
6890
6891 void PythonQtWrapper_QCPLegend::setBorderPen(QCPLegend* theWrappedObject, const QPen& pen)
6892 {
6893 ( theWrappedObject->setBorderPen(pen));
6894 }
6895
6896 void PythonQtWrapper_QCPLegend::setBrush(QCPLegend* theWrappedObject, const QBrush& brush)
6897 {
6898 ( theWrappedObject->setBrush(brush));
6899 }
6900
6901 void PythonQtWrapper_QCPLegend::setFont(QCPLegend* theWrappedObject, const QFont& font)
6902 {
6903 ( theWrappedObject->setFont(font));
6904 }
6905
6906 void PythonQtWrapper_QCPLegend::setIconBorderPen(QCPLegend* theWrappedObject, const QPen& pen)
6907 {
6908 ( theWrappedObject->setIconBorderPen(pen));
6909 }
6910
6911 void PythonQtWrapper_QCPLegend::setIconSize(QCPLegend* theWrappedObject, const QSize& size)
6912 {
6913 ( theWrappedObject->setIconSize(size));
6914 }
6915
6916 void PythonQtWrapper_QCPLegend::setIconSize(QCPLegend* theWrappedObject, int width, int height)
6917 {
6918 ( theWrappedObject->setIconSize(width, height));
6919 }
6920
6921 void PythonQtWrapper_QCPLegend::setIconTextPadding(QCPLegend* theWrappedObject, int padding)
6922 {
6923 ( theWrappedObject->setIconTextPadding(padding));
6924 }
6925
6926 void PythonQtWrapper_QCPLegend::setSelectedBorderPen(QCPLegend* theWrappedObject, const QPen& pen)
6927 {
6928 ( theWrappedObject->setSelectedBorderPen(pen));
6929 }
6930
6931 void PythonQtWrapper_QCPLegend::setSelectedBrush(QCPLegend* theWrappedObject, const QBrush& brush)
6932 {
6933 ( theWrappedObject->setSelectedBrush(brush));
6934 }
6935
6936 void PythonQtWrapper_QCPLegend::setSelectedFont(QCPLegend* theWrappedObject, const QFont& font)
6937 {
6938 ( theWrappedObject->setSelectedFont(font));
6939 }
6940
6941 void PythonQtWrapper_QCPLegend::setSelectedIconBorderPen(QCPLegend* theWrappedObject, const QPen& pen)
6942 {
6943 ( theWrappedObject->setSelectedIconBorderPen(pen));
6944 }
6945
6946 void PythonQtWrapper_QCPLegend::setSelectedTextColor(QCPLegend* theWrappedObject, const QColor& color)
6947 {
6948 ( theWrappedObject->setSelectedTextColor(color));
6949 }
6950
6951 void PythonQtWrapper_QCPLegend::setTextColor(QCPLegend* theWrappedObject, const QColor& color)
6952 {
6953 ( theWrappedObject->setTextColor(color));
6954 }
6955
6956 QColor PythonQtWrapper_QCPLegend::textColor(QCPLegend* theWrappedObject) const
6957 {
6958 return ( theWrappedObject->textColor());
6959 }
6960
6961
6962
6963 PythonQtShell_QCPPainter::~PythonQtShell_QCPPainter() {
6964 PythonQtPrivate* priv = PythonQt::priv();
6965 if (priv) { priv->shellClassDeleted(this); }
6966 }
6967 QCPPainter* PythonQtWrapper_QCPPainter::new_QCPPainter()
6968 {
6969 return new PythonQtShell_QCPPainter(); }
6970
6971 QCPPainter* PythonQtWrapper_QCPPainter::new_QCPPainter(QPaintDevice* device)
6972 {
6973 return new PythonQtShell_QCPPainter(device); }
6974
6975 bool PythonQtWrapper_QCPPainter::antialiasing(QCPPainter* theWrappedObject) const
6976 {
6977 return ( theWrappedObject->antialiasing());
6978 }
6979
6980 bool PythonQtWrapper_QCPPainter::begin(QCPPainter* theWrappedObject, QPaintDevice* device)
6981 {
6982 return ( theWrappedObject->begin(device));
6983 }
6984
6985 void PythonQtWrapper_QCPPainter::drawLine(QCPPainter* theWrappedObject, const QLineF& line)
6986 {
6987 ( theWrappedObject->drawLine(line));
6988 }
6989
6990 void PythonQtWrapper_QCPPainter::drawLine(QCPPainter* theWrappedObject, const QPointF& p1, const QPointF& p2)
6991 {
6992 ( theWrappedObject->drawLine(p1, p2));
6993 }
6994
6995 void PythonQtWrapper_QCPPainter::makeNonCosmetic(QCPPainter* theWrappedObject)
6996 {
6997 ( theWrappedObject->makeNonCosmetic());
6998 }
6999
7000 void PythonQtWrapper_QCPPainter::restore(QCPPainter* theWrappedObject)
7001 {
7002 ( theWrappedObject->restore());
7003 }
7004
7005 void PythonQtWrapper_QCPPainter::save(QCPPainter* theWrappedObject)
7006 {
7007 ( theWrappedObject->save());
7008 }
7009
7010 void PythonQtWrapper_QCPPainter::setAntialiasing(QCPPainter* theWrappedObject, bool enabled)
7011 {
7012 ( theWrappedObject->setAntialiasing(enabled));
7013 }
7014
7015 void PythonQtWrapper_QCPPainter::setPen(QCPPainter* theWrappedObject, Qt::PenStyle penStyle)
7016 {
7017 ( theWrappedObject->setPen(penStyle));
7018 }
7019
7020 void PythonQtWrapper_QCPPainter::setPen(QCPPainter* theWrappedObject, const QColor& color)
7021 {
7022 ( theWrappedObject->setPen(color));
7023 }
7024
7025 void PythonQtWrapper_QCPPainter::setPen(QCPPainter* theWrappedObject, const QPen& pen)
7026 {
7027 ( theWrappedObject->setPen(pen));
7028 }
7029
7030
7031
7032 PythonQtShell_QCPPlotTitle::~PythonQtShell_QCPPlotTitle() {
7033 PythonQtPrivate* priv = PythonQt::priv();
7034 if (priv) { priv->shellClassDeleted(this); }
7035 }
7036 void PythonQtShell_QCPPlotTitle::applyDefaultAntialiasingHint(QCPPainter* painter0) const
7037 {
7038 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7039 static PyObject* name = PyString_FromString("applyDefaultAntialiasingHint");
7040 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7041 if (obj) {
7042 static const char* argumentList[] ={"" , "QCPPainter*"};
7043 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7044 void* args[2] = {NULL, (void*)&painter0};
7045 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7046 if (result) { Py_DECREF(result); }
7047 Py_DECREF(obj);
7048 return;
7049 } else {
7050 PyErr_Clear();
7051 }
7052 }
7053 QCPPlotTitle::applyDefaultAntialiasingHint(painter0);
7054 }
7055 void PythonQtShell_QCPPlotTitle::childEvent(QChildEvent* arg__1)
7056 {
7057 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7058 static PyObject* name = PyString_FromString("childEvent");
7059 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7060 if (obj) {
7061 static const char* argumentList[] ={"" , "QChildEvent*"};
7062 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7063 void* args[2] = {NULL, (void*)&arg__1};
7064 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7065 if (result) { Py_DECREF(result); }
7066 Py_DECREF(obj);
7067 return;
7068 } else {
7069 PyErr_Clear();
7070 }
7071 }
7072 QCPPlotTitle::childEvent(arg__1);
7073 }
7074 QRect PythonQtShell_QCPPlotTitle::clipRect() const
7075 {
7076 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7077 static PyObject* name = PyString_FromString("clipRect");
7078 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7079 if (obj) {
7080 static const char* argumentList[] ={"QRect"};
7081 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7082 QRect returnValue;
7083 void* args[1] = {NULL};
7084 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7085 if (result) {
7086 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7087 if (args[0]!=&returnValue) {
7088 if (args[0]==NULL) {
7089 PythonQt::priv()->handleVirtualOverloadReturnError("clipRect", methodInfo, result);
7090 } else {
7091 returnValue = *((QRect*)args[0]);
7092 }
7093 }
7094 }
7095 if (result) { Py_DECREF(result); }
7096 Py_DECREF(obj);
7097 return returnValue;
7098 } else {
7099 PyErr_Clear();
7100 }
7101 }
7102 return QCPPlotTitle::clipRect();
7103 }
7104 void PythonQtShell_QCPPlotTitle::customEvent(QEvent* arg__1)
7105 {
7106 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7107 static PyObject* name = PyString_FromString("customEvent");
7108 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7109 if (obj) {
7110 static const char* argumentList[] ={"" , "QEvent*"};
7111 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7112 void* args[2] = {NULL, (void*)&arg__1};
7113 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7114 if (result) { Py_DECREF(result); }
7115 Py_DECREF(obj);
7116 return;
7117 } else {
7118 PyErr_Clear();
7119 }
7120 }
7121 QCPPlotTitle::customEvent(arg__1);
7122 }
7123 void PythonQtShell_QCPPlotTitle::deselectEvent(bool* selectionStateChanged0)
7124 {
7125 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7126 static PyObject* name = PyString_FromString("deselectEvent");
7127 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7128 if (obj) {
7129 static const char* argumentList[] ={"" , "bool*"};
7130 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7131 void* args[2] = {NULL, (void*)&selectionStateChanged0};
7132 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7133 if (result) { Py_DECREF(result); }
7134 Py_DECREF(obj);
7135 return;
7136 } else {
7137 PyErr_Clear();
7138 }
7139 }
7140 QCPPlotTitle::deselectEvent(selectionStateChanged0);
7141 }
7142 void PythonQtShell_QCPPlotTitle::draw(QCPPainter* painter0)
7143 {
7144 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7145 static PyObject* name = PyString_FromString("draw");
7146 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7147 if (obj) {
7148 static const char* argumentList[] ={"" , "QCPPainter*"};
7149 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7150 void* args[2] = {NULL, (void*)&painter0};
7151 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7152 if (result) { Py_DECREF(result); }
7153 Py_DECREF(obj);
7154 return;
7155 } else {
7156 PyErr_Clear();
7157 }
7158 }
7159 QCPPlotTitle::draw(painter0);
7160 }
7161 QList<QCPLayoutElement* > PythonQtShell_QCPPlotTitle::elements(bool recursive0) const
7162 {
7163 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7164 static PyObject* name = PyString_FromString("elements");
7165 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7166 if (obj) {
7167 static const char* argumentList[] ={"QList<QCPLayoutElement* >" , "bool"};
7168 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7169 QList<QCPLayoutElement* > returnValue;
7170 void* args[2] = {NULL, (void*)&recursive0};
7171 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7172 if (result) {
7173 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7174 if (args[0]!=&returnValue) {
7175 if (args[0]==NULL) {
7176 PythonQt::priv()->handleVirtualOverloadReturnError("elements", methodInfo, result);
7177 } else {
7178 returnValue = *((QList<QCPLayoutElement* >*)args[0]);
7179 }
7180 }
7181 }
7182 if (result) { Py_DECREF(result); }
7183 Py_DECREF(obj);
7184 return returnValue;
7185 } else {
7186 PyErr_Clear();
7187 }
7188 }
7189 return QCPPlotTitle::elements(recursive0);
7190 }
7191 bool PythonQtShell_QCPPlotTitle::event(QEvent* arg__1)
7192 {
7193 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7194 static PyObject* name = PyString_FromString("event");
7195 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7196 if (obj) {
7197 static const char* argumentList[] ={"bool" , "QEvent*"};
7198 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7199 bool returnValue;
7200 void* args[2] = {NULL, (void*)&arg__1};
7201 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7202 if (result) {
7203 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7204 if (args[0]!=&returnValue) {
7205 if (args[0]==NULL) {
7206 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
7207 } else {
7208 returnValue = *((bool*)args[0]);
7209 }
7210 }
7211 }
7212 if (result) { Py_DECREF(result); }
7213 Py_DECREF(obj);
7214 return returnValue;
7215 } else {
7216 PyErr_Clear();
7217 }
7218 }
7219 return QCPPlotTitle::event(arg__1);
7220 }
7221 bool PythonQtShell_QCPPlotTitle::eventFilter(QObject* arg__1, QEvent* arg__2)
7222 {
7223 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7224 static PyObject* name = PyString_FromString("eventFilter");
7225 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7226 if (obj) {
7227 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
7228 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
7229 bool returnValue;
7230 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
7231 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7232 if (result) {
7233 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7234 if (args[0]!=&returnValue) {
7235 if (args[0]==NULL) {
7236 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
7237 } else {
7238 returnValue = *((bool*)args[0]);
7239 }
7240 }
7241 }
7242 if (result) { Py_DECREF(result); }
7243 Py_DECREF(obj);
7244 return returnValue;
7245 } else {
7246 PyErr_Clear();
7247 }
7248 }
7249 return QCPPlotTitle::eventFilter(arg__1, arg__2);
7250 }
7251 QSize PythonQtShell_QCPPlotTitle::maximumSizeHint() const
7252 {
7253 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7254 static PyObject* name = PyString_FromString("maximumSizeHint");
7255 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7256 if (obj) {
7257 static const char* argumentList[] ={"QSize"};
7258 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7259 QSize returnValue;
7260 void* args[1] = {NULL};
7261 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7262 if (result) {
7263 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7264 if (args[0]!=&returnValue) {
7265 if (args[0]==NULL) {
7266 PythonQt::priv()->handleVirtualOverloadReturnError("maximumSizeHint", methodInfo, result);
7267 } else {
7268 returnValue = *((QSize*)args[0]);
7269 }
7270 }
7271 }
7272 if (result) { Py_DECREF(result); }
7273 Py_DECREF(obj);
7274 return returnValue;
7275 } else {
7276 PyErr_Clear();
7277 }
7278 }
7279 return QCPPlotTitle::maximumSizeHint();
7280 }
7281 QSize PythonQtShell_QCPPlotTitle::minimumSizeHint() const
7282 {
7283 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7284 static PyObject* name = PyString_FromString("minimumSizeHint");
7285 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7286 if (obj) {
7287 static const char* argumentList[] ={"QSize"};
7288 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7289 QSize returnValue;
7290 void* args[1] = {NULL};
7291 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7292 if (result) {
7293 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7294 if (args[0]!=&returnValue) {
7295 if (args[0]==NULL) {
7296 PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result);
7297 } else {
7298 returnValue = *((QSize*)args[0]);
7299 }
7300 }
7301 }
7302 if (result) { Py_DECREF(result); }
7303 Py_DECREF(obj);
7304 return returnValue;
7305 } else {
7306 PyErr_Clear();
7307 }
7308 }
7309 return QCPPlotTitle::minimumSizeHint();
7310 }
7311 void PythonQtShell_QCPPlotTitle::mouseDoubleClickEvent(QMouseEvent* event0)
7312 {
7313 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7314 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
7315 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7316 if (obj) {
7317 static const char* argumentList[] ={"" , "QMouseEvent*"};
7318 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7319 void* args[2] = {NULL, (void*)&event0};
7320 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7321 if (result) { Py_DECREF(result); }
7322 Py_DECREF(obj);
7323 return;
7324 } else {
7325 PyErr_Clear();
7326 }
7327 }
7328 QCPPlotTitle::mouseDoubleClickEvent(event0);
7329 }
7330 void PythonQtShell_QCPPlotTitle::mouseMoveEvent(QMouseEvent* event0)
7331 {
7332 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7333 static PyObject* name = PyString_FromString("mouseMoveEvent");
7334 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7335 if (obj) {
7336 static const char* argumentList[] ={"" , "QMouseEvent*"};
7337 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7338 void* args[2] = {NULL, (void*)&event0};
7339 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7340 if (result) { Py_DECREF(result); }
7341 Py_DECREF(obj);
7342 return;
7343 } else {
7344 PyErr_Clear();
7345 }
7346 }
7347 QCPPlotTitle::mouseMoveEvent(event0);
7348 }
7349 void PythonQtShell_QCPPlotTitle::mousePressEvent(QMouseEvent* event0)
7350 {
7351 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7352 static PyObject* name = PyString_FromString("mousePressEvent");
7353 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7354 if (obj) {
7355 static const char* argumentList[] ={"" , "QMouseEvent*"};
7356 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7357 void* args[2] = {NULL, (void*)&event0};
7358 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7359 if (result) { Py_DECREF(result); }
7360 Py_DECREF(obj);
7361 return;
7362 } else {
7363 PyErr_Clear();
7364 }
7365 }
7366 QCPPlotTitle::mousePressEvent(event0);
7367 }
7368 void PythonQtShell_QCPPlotTitle::mouseReleaseEvent(QMouseEvent* event0)
7369 {
7370 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7371 static PyObject* name = PyString_FromString("mouseReleaseEvent");
7372 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7373 if (obj) {
7374 static const char* argumentList[] ={"" , "QMouseEvent*"};
7375 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7376 void* args[2] = {NULL, (void*)&event0};
7377 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7378 if (result) { Py_DECREF(result); }
7379 Py_DECREF(obj);
7380 return;
7381 } else {
7382 PyErr_Clear();
7383 }
7384 }
7385 QCPPlotTitle::mouseReleaseEvent(event0);
7386 }
7387 void PythonQtShell_QCPPlotTitle::parentPlotInitialized(QCustomPlot* parentPlot0)
7388 {
7389 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7390 static PyObject* name = PyString_FromString("parentPlotInitialized");
7391 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7392 if (obj) {
7393 static const char* argumentList[] ={"" , "QCustomPlot*"};
7394 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7395 void* args[2] = {NULL, (void*)&parentPlot0};
7396 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7397 if (result) { Py_DECREF(result); }
7398 Py_DECREF(obj);
7399 return;
7400 } else {
7401 PyErr_Clear();
7402 }
7403 }
7404 QCPPlotTitle::parentPlotInitialized(parentPlot0);
7405 }
7406 void PythonQtShell_QCPPlotTitle::selectEvent(QMouseEvent* event0, bool additive1, const QVariant& details2, bool* selectionStateChanged3)
7407 {
7408 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7409 static PyObject* name = PyString_FromString("selectEvent");
7410 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7411 if (obj) {
7412 static const char* argumentList[] ={"" , "QMouseEvent*" , "bool" , "const QVariant&" , "bool*"};
7413 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList);
7414 void* args[5] = {NULL, (void*)&event0, (void*)&additive1, (void*)&details2, (void*)&selectionStateChanged3};
7415 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7416 if (result) { Py_DECREF(result); }
7417 Py_DECREF(obj);
7418 return;
7419 } else {
7420 PyErr_Clear();
7421 }
7422 }
7423 QCPPlotTitle::selectEvent(event0, additive1, details2, selectionStateChanged3);
7424 }
7425 double PythonQtShell_QCPPlotTitle::selectTest(const QPointF& pos0, bool onlySelectable1, QVariant* details2) const
7426 {
7427 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7428 static PyObject* name = PyString_FromString("selectTest");
7429 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7430 if (obj) {
7431 static const char* argumentList[] ={"double" , "const QPointF&" , "bool" , "QVariant*"};
7432 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
7433 double returnValue;
7434 void* args[4] = {NULL, (void*)&pos0, (void*)&onlySelectable1, (void*)&details2};
7435 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7436 if (result) {
7437 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7438 if (args[0]!=&returnValue) {
7439 if (args[0]==NULL) {
7440 PythonQt::priv()->handleVirtualOverloadReturnError("selectTest", methodInfo, result);
7441 } else {
7442 returnValue = *((double*)args[0]);
7443 }
7444 }
7445 }
7446 if (result) { Py_DECREF(result); }
7447 Py_DECREF(obj);
7448 return returnValue;
7449 } else {
7450 PyErr_Clear();
7451 }
7452 }
7453 return QCPPlotTitle::selectTest(pos0, onlySelectable1, details2);
7454 }
7455 void PythonQtShell_QCPPlotTitle::timerEvent(QTimerEvent* arg__1)
7456 {
7457 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7458 static PyObject* name = PyString_FromString("timerEvent");
7459 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7460 if (obj) {
7461 static const char* argumentList[] ={"" , "QTimerEvent*"};
7462 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7463 void* args[2] = {NULL, (void*)&arg__1};
7464 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7465 if (result) { Py_DECREF(result); }
7466 Py_DECREF(obj);
7467 return;
7468 } else {
7469 PyErr_Clear();
7470 }
7471 }
7472 QCPPlotTitle::timerEvent(arg__1);
7473 }
7474 void PythonQtShell_QCPPlotTitle::wheelEvent(QWheelEvent* event0)
7475 {
7476 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7477 static PyObject* name = PyString_FromString("wheelEvent");
7478 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7479 if (obj) {
7480 static const char* argumentList[] ={"" , "QWheelEvent*"};
7481 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7482 void* args[2] = {NULL, (void*)&event0};
7483 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7484 if (result) { Py_DECREF(result); }
7485 Py_DECREF(obj);
7486 return;
7487 } else {
7488 PyErr_Clear();
7489 }
7490 }
7491 QCPPlotTitle::wheelEvent(event0);
7492 }
7493 QCPPlotTitle* PythonQtWrapper_QCPPlotTitle::new_QCPPlotTitle(QCustomPlot* parentPlot)
7494 {
7495 return new PythonQtShell_QCPPlotTitle(parentPlot); }
7496
7497 QCPPlotTitle* PythonQtWrapper_QCPPlotTitle::new_QCPPlotTitle(QCustomPlot* parentPlot, const QString& text)
7498 {
7499 return new PythonQtShell_QCPPlotTitle(parentPlot, text); }
7500
7501 void PythonQtWrapper_QCPPlotTitle::applyDefaultAntialiasingHint(QCPPlotTitle* theWrappedObject, QCPPainter* painter) const
7502 {
7503 ( ((PythonQtPublicPromoter_QCPPlotTitle*)theWrappedObject)->promoted_applyDefaultAntialiasingHint(painter));
7504 }
7505
7506 void PythonQtWrapper_QCPPlotTitle::deselectEvent(QCPPlotTitle* theWrappedObject, bool* selectionStateChanged)
7507 {
7508 ( ((PythonQtPublicPromoter_QCPPlotTitle*)theWrappedObject)->promoted_deselectEvent(selectionStateChanged));
7509 }
7510
7511 void PythonQtWrapper_QCPPlotTitle::draw(QCPPlotTitle* theWrappedObject, QCPPainter* painter)
7512 {
7513 ( ((PythonQtPublicPromoter_QCPPlotTitle*)theWrappedObject)->promoted_draw(painter));
7514 }
7515
7516 QFont PythonQtWrapper_QCPPlotTitle::font(QCPPlotTitle* theWrappedObject) const
7517 {
7518 return ( theWrappedObject->font());
7519 }
7520
7521 QFont PythonQtWrapper_QCPPlotTitle::mainFont(QCPPlotTitle* theWrappedObject) const
7522 {
7523 return ( ((PythonQtPublicPromoter_QCPPlotTitle*)theWrappedObject)->promoted_mainFont());
7524 }
7525
7526 QColor PythonQtWrapper_QCPPlotTitle::mainTextColor(QCPPlotTitle* theWrappedObject) const
7527 {
7528 return ( ((PythonQtPublicPromoter_QCPPlotTitle*)theWrappedObject)->promoted_mainTextColor());
7529 }
7530
7531 QSize PythonQtWrapper_QCPPlotTitle::maximumSizeHint(QCPPlotTitle* theWrappedObject) const
7532 {
7533 return ( ((PythonQtPublicPromoter_QCPPlotTitle*)theWrappedObject)->promoted_maximumSizeHint());
7534 }
7535
7536 QSize PythonQtWrapper_QCPPlotTitle::minimumSizeHint(QCPPlotTitle* theWrappedObject) const
7537 {
7538 return ( ((PythonQtPublicPromoter_QCPPlotTitle*)theWrappedObject)->promoted_minimumSizeHint());
7539 }
7540
7541 void PythonQtWrapper_QCPPlotTitle::selectEvent(QCPPlotTitle* theWrappedObject, QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged)
7542 {
7543 ( ((PythonQtPublicPromoter_QCPPlotTitle*)theWrappedObject)->promoted_selectEvent(event, additive, details, selectionStateChanged));
7544 }
7545
7546 double PythonQtWrapper_QCPPlotTitle::selectTest(QCPPlotTitle* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details) const
7547 {
7548 return ( ((PythonQtPublicPromoter_QCPPlotTitle*)theWrappedObject)->promoted_selectTest(pos, onlySelectable, details));
7549 }
7550
7551 bool PythonQtWrapper_QCPPlotTitle::selectable(QCPPlotTitle* theWrappedObject) const
7552 {
7553 return ( theWrappedObject->selectable());
7554 }
7555
7556 bool PythonQtWrapper_QCPPlotTitle::selected(QCPPlotTitle* theWrappedObject) const
7557 {
7558 return ( theWrappedObject->selected());
7559 }
7560
7561 QFont PythonQtWrapper_QCPPlotTitle::selectedFont(QCPPlotTitle* theWrappedObject) const
7562 {
7563 return ( theWrappedObject->selectedFont());
7564 }
7565
7566 QColor PythonQtWrapper_QCPPlotTitle::selectedTextColor(QCPPlotTitle* theWrappedObject) const
7567 {
7568 return ( theWrappedObject->selectedTextColor());
7569 }
7570
7571 void PythonQtWrapper_QCPPlotTitle::setFont(QCPPlotTitle* theWrappedObject, const QFont& font)
7572 {
7573 ( theWrappedObject->setFont(font));
7574 }
7575
7576 void PythonQtWrapper_QCPPlotTitle::setSelectable(QCPPlotTitle* theWrappedObject, bool selectable)
7577 {
7578 ( theWrappedObject->setSelectable(selectable));
7579 }
7580
7581 void PythonQtWrapper_QCPPlotTitle::setSelected(QCPPlotTitle* theWrappedObject, bool selected)
7582 {
7583 ( theWrappedObject->setSelected(selected));
7584 }
7585
7586 void PythonQtWrapper_QCPPlotTitle::setSelectedFont(QCPPlotTitle* theWrappedObject, const QFont& font)
7587 {
7588 ( theWrappedObject->setSelectedFont(font));
7589 }
7590
7591 void PythonQtWrapper_QCPPlotTitle::setSelectedTextColor(QCPPlotTitle* theWrappedObject, const QColor& color)
7592 {
7593 ( theWrappedObject->setSelectedTextColor(color));
7594 }
7595
7596 void PythonQtWrapper_QCPPlotTitle::setText(QCPPlotTitle* theWrappedObject, const QString& text)
7597 {
7598 ( theWrappedObject->setText(text));
7599 }
7600
7601 void PythonQtWrapper_QCPPlotTitle::setTextColor(QCPPlotTitle* theWrappedObject, const QColor& color)
7602 {
7603 ( theWrappedObject->setTextColor(color));
7604 }
7605
7606 QString PythonQtWrapper_QCPPlotTitle::text(QCPPlotTitle* theWrappedObject) const
7607 {
7608 return ( theWrappedObject->text());
7609 }
7610
7611 QColor PythonQtWrapper_QCPPlotTitle::textColor(QCPPlotTitle* theWrappedObject) const
7612 {
7613 return ( theWrappedObject->textColor());
7614 }
7615
7616
7617
7618 PythonQtShell_QCustomPlot::~PythonQtShell_QCustomPlot() {
7619 PythonQtPrivate* priv = PythonQt::priv();
7620 if (priv) { priv->shellClassDeleted(this); }
7621 }
7622 void PythonQtShell_QCustomPlot::actionEvent(QActionEvent* arg__1)
7623 {
7624 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7625 static PyObject* name = PyString_FromString("actionEvent");
7626 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7627 if (obj) {
7628 static const char* argumentList[] ={"" , "QActionEvent*"};
7629 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7630 void* args[2] = {NULL, (void*)&arg__1};
7631 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7632 if (result) { Py_DECREF(result); }
7633 Py_DECREF(obj);
7634 return;
7635 } else {
7636 PyErr_Clear();
7637 }
7638 }
7639 QCustomPlot::actionEvent(arg__1);
7640 }
7641 void PythonQtShell_QCustomPlot::axisRemoved(QCPAxis* axis0)
7642 {
7643 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7644 static PyObject* name = PyString_FromString("axisRemoved");
7645 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7646 if (obj) {
7647 static const char* argumentList[] ={"" , "QCPAxis*"};
7648 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7649 void* args[2] = {NULL, (void*)&axis0};
7650 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7651 if (result) { Py_DECREF(result); }
7652 Py_DECREF(obj);
7653 return;
7654 } else {
7655 PyErr_Clear();
7656 }
7657 }
7658 QCustomPlot::axisRemoved(axis0);
7659 }
7660 void PythonQtShell_QCustomPlot::changeEvent(QEvent* arg__1)
7661 {
7662 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7663 static PyObject* name = PyString_FromString("changeEvent");
7664 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7665 if (obj) {
7666 static const char* argumentList[] ={"" , "QEvent*"};
7667 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7668 void* args[2] = {NULL, (void*)&arg__1};
7669 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7670 if (result) { Py_DECREF(result); }
7671 Py_DECREF(obj);
7672 return;
7673 } else {
7674 PyErr_Clear();
7675 }
7676 }
7677 QCustomPlot::changeEvent(arg__1);
7678 }
7679 void PythonQtShell_QCustomPlot::childEvent(QChildEvent* arg__1)
7680 {
7681 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7682 static PyObject* name = PyString_FromString("childEvent");
7683 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7684 if (obj) {
7685 static const char* argumentList[] ={"" , "QChildEvent*"};
7686 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7687 void* args[2] = {NULL, (void*)&arg__1};
7688 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7689 if (result) { Py_DECREF(result); }
7690 Py_DECREF(obj);
7691 return;
7692 } else {
7693 PyErr_Clear();
7694 }
7695 }
7696 QCustomPlot::childEvent(arg__1);
7697 }
7698 void PythonQtShell_QCustomPlot::closeEvent(QCloseEvent* arg__1)
7699 {
7700 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7701 static PyObject* name = PyString_FromString("closeEvent");
7702 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7703 if (obj) {
7704 static const char* argumentList[] ={"" , "QCloseEvent*"};
7705 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7706 void* args[2] = {NULL, (void*)&arg__1};
7707 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7708 if (result) { Py_DECREF(result); }
7709 Py_DECREF(obj);
7710 return;
7711 } else {
7712 PyErr_Clear();
7713 }
7714 }
7715 QCustomPlot::closeEvent(arg__1);
7716 }
7717 void PythonQtShell_QCustomPlot::contextMenuEvent(QContextMenuEvent* arg__1)
7718 {
7719 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7720 static PyObject* name = PyString_FromString("contextMenuEvent");
7721 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7722 if (obj) {
7723 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
7724 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7725 void* args[2] = {NULL, (void*)&arg__1};
7726 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7727 if (result) { Py_DECREF(result); }
7728 Py_DECREF(obj);
7729 return;
7730 } else {
7731 PyErr_Clear();
7732 }
7733 }
7734 QCustomPlot::contextMenuEvent(arg__1);
7735 }
7736 void PythonQtShell_QCustomPlot::customEvent(QEvent* arg__1)
7737 {
7738 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7739 static PyObject* name = PyString_FromString("customEvent");
7740 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7741 if (obj) {
7742 static const char* argumentList[] ={"" , "QEvent*"};
7743 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7744 void* args[2] = {NULL, (void*)&arg__1};
7745 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7746 if (result) { Py_DECREF(result); }
7747 Py_DECREF(obj);
7748 return;
7749 } else {
7750 PyErr_Clear();
7751 }
7752 }
7753 QCustomPlot::customEvent(arg__1);
7754 }
7755 int PythonQtShell_QCustomPlot::devType() const
7756 {
7757 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7758 static PyObject* name = PyString_FromString("devType");
7759 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7760 if (obj) {
7761 static const char* argumentList[] ={"int"};
7762 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7763 int returnValue;
7764 void* args[1] = {NULL};
7765 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7766 if (result) {
7767 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7768 if (args[0]!=&returnValue) {
7769 if (args[0]==NULL) {
7770 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
7771 } else {
7772 returnValue = *((int*)args[0]);
7773 }
7774 }
7775 }
7776 if (result) { Py_DECREF(result); }
7777 Py_DECREF(obj);
7778 return returnValue;
7779 } else {
7780 PyErr_Clear();
7781 }
7782 }
7783 return QCustomPlot::devType();
7784 }
7785 void PythonQtShell_QCustomPlot::dragEnterEvent(QDragEnterEvent* arg__1)
7786 {
7787 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7788 static PyObject* name = PyString_FromString("dragEnterEvent");
7789 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7790 if (obj) {
7791 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
7792 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7793 void* args[2] = {NULL, (void*)&arg__1};
7794 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7795 if (result) { Py_DECREF(result); }
7796 Py_DECREF(obj);
7797 return;
7798 } else {
7799 PyErr_Clear();
7800 }
7801 }
7802 QCustomPlot::dragEnterEvent(arg__1);
7803 }
7804 void PythonQtShell_QCustomPlot::dragLeaveEvent(QDragLeaveEvent* arg__1)
7805 {
7806 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7807 static PyObject* name = PyString_FromString("dragLeaveEvent");
7808 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7809 if (obj) {
7810 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
7811 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7812 void* args[2] = {NULL, (void*)&arg__1};
7813 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7814 if (result) { Py_DECREF(result); }
7815 Py_DECREF(obj);
7816 return;
7817 } else {
7818 PyErr_Clear();
7819 }
7820 }
7821 QCustomPlot::dragLeaveEvent(arg__1);
7822 }
7823 void PythonQtShell_QCustomPlot::dragMoveEvent(QDragMoveEvent* arg__1)
7824 {
7825 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7826 static PyObject* name = PyString_FromString("dragMoveEvent");
7827 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7828 if (obj) {
7829 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
7830 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7831 void* args[2] = {NULL, (void*)&arg__1};
7832 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7833 if (result) { Py_DECREF(result); }
7834 Py_DECREF(obj);
7835 return;
7836 } else {
7837 PyErr_Clear();
7838 }
7839 }
7840 QCustomPlot::dragMoveEvent(arg__1);
7841 }
7842 void PythonQtShell_QCustomPlot::draw(QCPPainter* painter0)
7843 {
7844 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7845 static PyObject* name = PyString_FromString("draw");
7846 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7847 if (obj) {
7848 static const char* argumentList[] ={"" , "QCPPainter*"};
7849 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7850 void* args[2] = {NULL, (void*)&painter0};
7851 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7852 if (result) { Py_DECREF(result); }
7853 Py_DECREF(obj);
7854 return;
7855 } else {
7856 PyErr_Clear();
7857 }
7858 }
7859 QCustomPlot::draw(painter0);
7860 }
7861 void PythonQtShell_QCustomPlot::dropEvent(QDropEvent* arg__1)
7862 {
7863 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7864 static PyObject* name = PyString_FromString("dropEvent");
7865 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7866 if (obj) {
7867 static const char* argumentList[] ={"" , "QDropEvent*"};
7868 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7869 void* args[2] = {NULL, (void*)&arg__1};
7870 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7871 if (result) { Py_DECREF(result); }
7872 Py_DECREF(obj);
7873 return;
7874 } else {
7875 PyErr_Clear();
7876 }
7877 }
7878 QCustomPlot::dropEvent(arg__1);
7879 }
7880 void PythonQtShell_QCustomPlot::enterEvent(QEvent* arg__1)
7881 {
7882 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7883 static PyObject* name = PyString_FromString("enterEvent");
7884 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7885 if (obj) {
7886 static const char* argumentList[] ={"" , "QEvent*"};
7887 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7888 void* args[2] = {NULL, (void*)&arg__1};
7889 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7890 if (result) { Py_DECREF(result); }
7891 Py_DECREF(obj);
7892 return;
7893 } else {
7894 PyErr_Clear();
7895 }
7896 }
7897 QCustomPlot::enterEvent(arg__1);
7898 }
7899 bool PythonQtShell_QCustomPlot::event(QEvent* arg__1)
7900 {
7901 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7902 static PyObject* name = PyString_FromString("event");
7903 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7904 if (obj) {
7905 static const char* argumentList[] ={"bool" , "QEvent*"};
7906 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7907 bool returnValue;
7908 void* args[2] = {NULL, (void*)&arg__1};
7909 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7910 if (result) {
7911 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7912 if (args[0]!=&returnValue) {
7913 if (args[0]==NULL) {
7914 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
7915 } else {
7916 returnValue = *((bool*)args[0]);
7917 }
7918 }
7919 }
7920 if (result) { Py_DECREF(result); }
7921 Py_DECREF(obj);
7922 return returnValue;
7923 } else {
7924 PyErr_Clear();
7925 }
7926 }
7927 return QCustomPlot::event(arg__1);
7928 }
7929 bool PythonQtShell_QCustomPlot::eventFilter(QObject* arg__1, QEvent* arg__2)
7930 {
7931 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7932 static PyObject* name = PyString_FromString("eventFilter");
7933 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7934 if (obj) {
7935 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
7936 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
7937 bool returnValue;
7938 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
7939 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7940 if (result) {
7941 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7942 if (args[0]!=&returnValue) {
7943 if (args[0]==NULL) {
7944 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
7945 } else {
7946 returnValue = *((bool*)args[0]);
7947 }
7948 }
7949 }
7950 if (result) { Py_DECREF(result); }
7951 Py_DECREF(obj);
7952 return returnValue;
7953 } else {
7954 PyErr_Clear();
7955 }
7956 }
7957 return QCustomPlot::eventFilter(arg__1, arg__2);
7958 }
7959 void PythonQtShell_QCustomPlot::focusInEvent(QFocusEvent* arg__1)
7960 {
7961 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7962 static PyObject* name = PyString_FromString("focusInEvent");
7963 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7964 if (obj) {
7965 static const char* argumentList[] ={"" , "QFocusEvent*"};
7966 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7967 void* args[2] = {NULL, (void*)&arg__1};
7968 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7969 if (result) { Py_DECREF(result); }
7970 Py_DECREF(obj);
7971 return;
7972 } else {
7973 PyErr_Clear();
7974 }
7975 }
7976 QCustomPlot::focusInEvent(arg__1);
7977 }
7978 bool PythonQtShell_QCustomPlot::focusNextPrevChild(bool next0)
7979 {
7980 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7981 static PyObject* name = PyString_FromString("focusNextPrevChild");
7982 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7983 if (obj) {
7984 static const char* argumentList[] ={"bool" , "bool"};
7985 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7986 bool returnValue;
7987 void* args[2] = {NULL, (void*)&next0};
7988 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7989 if (result) {
7990 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7991 if (args[0]!=&returnValue) {
7992 if (args[0]==NULL) {
7993 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
7994 } else {
7995 returnValue = *((bool*)args[0]);
7996 }
7997 }
7998 }
7999 if (result) { Py_DECREF(result); }
8000 Py_DECREF(obj);
8001 return returnValue;
8002 } else {
8003 PyErr_Clear();
8004 }
8005 }
8006 return QCustomPlot::focusNextPrevChild(next0);
8007 }
8008 void PythonQtShell_QCustomPlot::focusOutEvent(QFocusEvent* arg__1)
8009 {
8010 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8011 static PyObject* name = PyString_FromString("focusOutEvent");
8012 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8013 if (obj) {
8014 static const char* argumentList[] ={"" , "QFocusEvent*"};
8015 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8016 void* args[2] = {NULL, (void*)&arg__1};
8017 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8018 if (result) { Py_DECREF(result); }
8019 Py_DECREF(obj);
8020 return;
8021 } else {
8022 PyErr_Clear();
8023 }
8024 }
8025 QCustomPlot::focusOutEvent(arg__1);
8026 }
8027 bool PythonQtShell_QCustomPlot::hasHeightForWidth() const
8028 {
8029 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8030 static PyObject* name = PyString_FromString("hasHeightForWidth");
8031 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8032 if (obj) {
8033 static const char* argumentList[] ={"bool"};
8034 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8035 bool returnValue;
8036 void* args[1] = {NULL};
8037 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8038 if (result) {
8039 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8040 if (args[0]!=&returnValue) {
8041 if (args[0]==NULL) {
8042 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
8043 } else {
8044 returnValue = *((bool*)args[0]);
8045 }
8046 }
8047 }
8048 if (result) { Py_DECREF(result); }
8049 Py_DECREF(obj);
8050 return returnValue;
8051 } else {
8052 PyErr_Clear();
8053 }
8054 }
8055 return QCustomPlot::hasHeightForWidth();
8056 }
8057 int PythonQtShell_QCustomPlot::heightForWidth(int arg__1) const
8058 {
8059 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8060 static PyObject* name = PyString_FromString("heightForWidth");
8061 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8062 if (obj) {
8063 static const char* argumentList[] ={"int" , "int"};
8064 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8065 int returnValue;
8066 void* args[2] = {NULL, (void*)&arg__1};
8067 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8068 if (result) {
8069 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8070 if (args[0]!=&returnValue) {
8071 if (args[0]==NULL) {
8072 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
8073 } else {
8074 returnValue = *((int*)args[0]);
8075 }
8076 }
8077 }
8078 if (result) { Py_DECREF(result); }
8079 Py_DECREF(obj);
8080 return returnValue;
8081 } else {
8082 PyErr_Clear();
8083 }
8084 }
8085 return QCustomPlot::heightForWidth(arg__1);
8086 }
8087 void PythonQtShell_QCustomPlot::hideEvent(QHideEvent* arg__1)
8088 {
8089 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8090 static PyObject* name = PyString_FromString("hideEvent");
8091 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8092 if (obj) {
8093 static const char* argumentList[] ={"" , "QHideEvent*"};
8094 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8095 void* args[2] = {NULL, (void*)&arg__1};
8096 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8097 if (result) { Py_DECREF(result); }
8098 Py_DECREF(obj);
8099 return;
8100 } else {
8101 PyErr_Clear();
8102 }
8103 }
8104 QCustomPlot::hideEvent(arg__1);
8105 }
8106 void PythonQtShell_QCustomPlot::initPainter(QPainter* painter0) const
8107 {
8108 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8109 static PyObject* name = PyString_FromString("initPainter");
8110 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8111 if (obj) {
8112 static const char* argumentList[] ={"" , "QPainter*"};
8113 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8114 void* args[2] = {NULL, (void*)&painter0};
8115 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8116 if (result) { Py_DECREF(result); }
8117 Py_DECREF(obj);
8118 return;
8119 } else {
8120 PyErr_Clear();
8121 }
8122 }
8123 QCustomPlot::initPainter(painter0);
8124 }
8125 void PythonQtShell_QCustomPlot::inputMethodEvent(QInputMethodEvent* arg__1)
8126 {
8127 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8128 static PyObject* name = PyString_FromString("inputMethodEvent");
8129 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8130 if (obj) {
8131 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
8132 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8133 void* args[2] = {NULL, (void*)&arg__1};
8134 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8135 if (result) { Py_DECREF(result); }
8136 Py_DECREF(obj);
8137 return;
8138 } else {
8139 PyErr_Clear();
8140 }
8141 }
8142 QCustomPlot::inputMethodEvent(arg__1);
8143 }
8144 QVariant PythonQtShell_QCustomPlot::inputMethodQuery(Qt::InputMethodQuery arg__1) const
8145 {
8146 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8147 static PyObject* name = PyString_FromString("inputMethodQuery");
8148 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8149 if (obj) {
8150 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
8151 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8152 QVariant returnValue;
8153 void* args[2] = {NULL, (void*)&arg__1};
8154 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8155 if (result) {
8156 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8157 if (args[0]!=&returnValue) {
8158 if (args[0]==NULL) {
8159 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
8160 } else {
8161 returnValue = *((QVariant*)args[0]);
8162 }
8163 }
8164 }
8165 if (result) { Py_DECREF(result); }
8166 Py_DECREF(obj);
8167 return returnValue;
8168 } else {
8169 PyErr_Clear();
8170 }
8171 }
8172 return QCustomPlot::inputMethodQuery(arg__1);
8173 }
8174 void PythonQtShell_QCustomPlot::keyPressEvent(QKeyEvent* arg__1)
8175 {
8176 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8177 static PyObject* name = PyString_FromString("keyPressEvent");
8178 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8179 if (obj) {
8180 static const char* argumentList[] ={"" , "QKeyEvent*"};
8181 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8182 void* args[2] = {NULL, (void*)&arg__1};
8183 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8184 if (result) { Py_DECREF(result); }
8185 Py_DECREF(obj);
8186 return;
8187 } else {
8188 PyErr_Clear();
8189 }
8190 }
8191 QCustomPlot::keyPressEvent(arg__1);
8192 }
8193 void PythonQtShell_QCustomPlot::keyReleaseEvent(QKeyEvent* arg__1)
8194 {
8195 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8196 static PyObject* name = PyString_FromString("keyReleaseEvent");
8197 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8198 if (obj) {
8199 static const char* argumentList[] ={"" , "QKeyEvent*"};
8200 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8201 void* args[2] = {NULL, (void*)&arg__1};
8202 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8203 if (result) { Py_DECREF(result); }
8204 Py_DECREF(obj);
8205 return;
8206 } else {
8207 PyErr_Clear();
8208 }
8209 }
8210 QCustomPlot::keyReleaseEvent(arg__1);
8211 }
8212 void PythonQtShell_QCustomPlot::leaveEvent(QEvent* arg__1)
8213 {
8214 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8215 static PyObject* name = PyString_FromString("leaveEvent");
8216 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8217 if (obj) {
8218 static const char* argumentList[] ={"" , "QEvent*"};
8219 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8220 void* args[2] = {NULL, (void*)&arg__1};
8221 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8222 if (result) { Py_DECREF(result); }
8223 Py_DECREF(obj);
8224 return;
8225 } else {
8226 PyErr_Clear();
8227 }
8228 }
8229 QCustomPlot::leaveEvent(arg__1);
8230 }
8231 void PythonQtShell_QCustomPlot::legendRemoved(QCPLegend* legend0)
8232 {
8233 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8234 static PyObject* name = PyString_FromString("legendRemoved");
8235 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8236 if (obj) {
8237 static const char* argumentList[] ={"" , "QCPLegend*"};
8238 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8239 void* args[2] = {NULL, (void*)&legend0};
8240 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8241 if (result) { Py_DECREF(result); }
8242 Py_DECREF(obj);
8243 return;
8244 } else {
8245 PyErr_Clear();
8246 }
8247 }
8248 QCustomPlot::legendRemoved(legend0);
8249 }
8250 int PythonQtShell_QCustomPlot::metric(QPaintDevice::PaintDeviceMetric arg__1) const
8251 {
8252 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8253 static PyObject* name = PyString_FromString("metric");
8254 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8255 if (obj) {
8256 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
8257 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8258 int returnValue;
8259 void* args[2] = {NULL, (void*)&arg__1};
8260 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8261 if (result) {
8262 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8263 if (args[0]!=&returnValue) {
8264 if (args[0]==NULL) {
8265 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
8266 } else {
8267 returnValue = *((int*)args[0]);
8268 }
8269 }
8270 }
8271 if (result) { Py_DECREF(result); }
8272 Py_DECREF(obj);
8273 return returnValue;
8274 } else {
8275 PyErr_Clear();
8276 }
8277 }
8278 return QCustomPlot::metric(arg__1);
8279 }
8280 QSize PythonQtShell_QCustomPlot::minimumSizeHint() const
8281 {
8282 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8283 static PyObject* name = PyString_FromString("minimumSizeHint");
8284 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8285 if (obj) {
8286 static const char* argumentList[] ={"QSize"};
8287 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8288 QSize returnValue;
8289 void* args[1] = {NULL};
8290 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8291 if (result) {
8292 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8293 if (args[0]!=&returnValue) {
8294 if (args[0]==NULL) {
8295 PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result);
8296 } else {
8297 returnValue = *((QSize*)args[0]);
8298 }
8299 }
8300 }
8301 if (result) { Py_DECREF(result); }
8302 Py_DECREF(obj);
8303 return returnValue;
8304 } else {
8305 PyErr_Clear();
8306 }
8307 }
8308 return QCustomPlot::minimumSizeHint();
8309 }
8310 void PythonQtShell_QCustomPlot::mouseDoubleClickEvent(QMouseEvent* event0)
8311 {
8312 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8313 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
8314 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8315 if (obj) {
8316 static const char* argumentList[] ={"" , "QMouseEvent*"};
8317 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8318 void* args[2] = {NULL, (void*)&event0};
8319 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8320 if (result) { Py_DECREF(result); }
8321 Py_DECREF(obj);
8322 return;
8323 } else {
8324 PyErr_Clear();
8325 }
8326 }
8327 QCustomPlot::mouseDoubleClickEvent(event0);
8328 }
8329 void PythonQtShell_QCustomPlot::mouseMoveEvent(QMouseEvent* event0)
8330 {
8331 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8332 static PyObject* name = PyString_FromString("mouseMoveEvent");
8333 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8334 if (obj) {
8335 static const char* argumentList[] ={"" , "QMouseEvent*"};
8336 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8337 void* args[2] = {NULL, (void*)&event0};
8338 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8339 if (result) { Py_DECREF(result); }
8340 Py_DECREF(obj);
8341 return;
8342 } else {
8343 PyErr_Clear();
8344 }
8345 }
8346 QCustomPlot::mouseMoveEvent(event0);
8347 }
8348 void PythonQtShell_QCustomPlot::mousePressEvent(QMouseEvent* event0)
8349 {
8350 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8351 static PyObject* name = PyString_FromString("mousePressEvent");
8352 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8353 if (obj) {
8354 static const char* argumentList[] ={"" , "QMouseEvent*"};
8355 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8356 void* args[2] = {NULL, (void*)&event0};
8357 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8358 if (result) { Py_DECREF(result); }
8359 Py_DECREF(obj);
8360 return;
8361 } else {
8362 PyErr_Clear();
8363 }
8364 }
8365 QCustomPlot::mousePressEvent(event0);
8366 }
8367 void PythonQtShell_QCustomPlot::mouseReleaseEvent(QMouseEvent* event0)
8368 {
8369 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8370 static PyObject* name = PyString_FromString("mouseReleaseEvent");
8371 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8372 if (obj) {
8373 static const char* argumentList[] ={"" , "QMouseEvent*"};
8374 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8375 void* args[2] = {NULL, (void*)&event0};
8376 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8377 if (result) { Py_DECREF(result); }
8378 Py_DECREF(obj);
8379 return;
8380 } else {
8381 PyErr_Clear();
8382 }
8383 }
8384 QCustomPlot::mouseReleaseEvent(event0);
8385 }
8386 void PythonQtShell_QCustomPlot::moveEvent(QMoveEvent* arg__1)
8387 {
8388 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8389 static PyObject* name = PyString_FromString("moveEvent");
8390 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8391 if (obj) {
8392 static const char* argumentList[] ={"" , "QMoveEvent*"};
8393 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8394 void* args[2] = {NULL, (void*)&arg__1};
8395 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8396 if (result) { Py_DECREF(result); }
8397 Py_DECREF(obj);
8398 return;
8399 } else {
8400 PyErr_Clear();
8401 }
8402 }
8403 QCustomPlot::moveEvent(arg__1);
8404 }
8405 bool PythonQtShell_QCustomPlot::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
8406 {
8407 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8408 static PyObject* name = PyString_FromString("nativeEvent");
8409 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8410 if (obj) {
8411 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
8412 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
8413 bool returnValue;
8414 void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
8415 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8416 if (result) {
8417 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8418 if (args[0]!=&returnValue) {
8419 if (args[0]==NULL) {
8420 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
8421 } else {
8422 returnValue = *((bool*)args[0]);
8423 }
8424 }
8425 }
8426 if (result) { Py_DECREF(result); }
8427 Py_DECREF(obj);
8428 return returnValue;
8429 } else {
8430 PyErr_Clear();
8431 }
8432 }
8433 return QCustomPlot::nativeEvent(eventType0, message1, result2);
8434 }
8435 QPaintEngine* PythonQtShell_QCustomPlot::paintEngine() const
8436 {
8437 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8438 static PyObject* name = PyString_FromString("paintEngine");
8439 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8440 if (obj) {
8441 static const char* argumentList[] ={"QPaintEngine*"};
8442 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8443 QPaintEngine* returnValue;
8444 void* args[1] = {NULL};
8445 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8446 if (result) {
8447 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8448 if (args[0]!=&returnValue) {
8449 if (args[0]==NULL) {
8450 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
8451 } else {
8452 returnValue = *((QPaintEngine**)args[0]);
8453 }
8454 }
8455 }
8456 if (result) { Py_DECREF(result); }
8457 Py_DECREF(obj);
8458 return returnValue;
8459 } else {
8460 PyErr_Clear();
8461 }
8462 }
8463 return QCustomPlot::paintEngine();
8464 }
8465 void PythonQtShell_QCustomPlot::paintEvent(QPaintEvent* event0)
8466 {
8467 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8468 static PyObject* name = PyString_FromString("paintEvent");
8469 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8470 if (obj) {
8471 static const char* argumentList[] ={"" , "QPaintEvent*"};
8472 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8473 void* args[2] = {NULL, (void*)&event0};
8474 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8475 if (result) { Py_DECREF(result); }
8476 Py_DECREF(obj);
8477 return;
8478 } else {
8479 PyErr_Clear();
8480 }
8481 }
8482 QCustomPlot::paintEvent(event0);
8483 }
8484 QPaintDevice* PythonQtShell_QCustomPlot::redirected(QPoint* offset0) const
8485 {
8486 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8487 static PyObject* name = PyString_FromString("redirected");
8488 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8489 if (obj) {
8490 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
8491 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8492 QPaintDevice* returnValue;
8493 void* args[2] = {NULL, (void*)&offset0};
8494 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8495 if (result) {
8496 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8497 if (args[0]!=&returnValue) {
8498 if (args[0]==NULL) {
8499 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
8500 } else {
8501 returnValue = *((QPaintDevice**)args[0]);
8502 }
8503 }
8504 }
8505 if (result) { Py_DECREF(result); }
8506 Py_DECREF(obj);
8507 return returnValue;
8508 } else {
8509 PyErr_Clear();
8510 }
8511 }
8512 return QCustomPlot::redirected(offset0);
8513 }
8514 void PythonQtShell_QCustomPlot::resizeEvent(QResizeEvent* event0)
8515 {
8516 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8517 static PyObject* name = PyString_FromString("resizeEvent");
8518 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8519 if (obj) {
8520 static const char* argumentList[] ={"" , "QResizeEvent*"};
8521 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8522 void* args[2] = {NULL, (void*)&event0};
8523 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8524 if (result) { Py_DECREF(result); }
8525 Py_DECREF(obj);
8526 return;
8527 } else {
8528 PyErr_Clear();
8529 }
8530 }
8531 QCustomPlot::resizeEvent(event0);
8532 }
8533 QPainter* PythonQtShell_QCustomPlot::sharedPainter() const
8534 {
8535 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8536 static PyObject* name = PyString_FromString("sharedPainter");
8537 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8538 if (obj) {
8539 static const char* argumentList[] ={"QPainter*"};
8540 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8541 QPainter* returnValue;
8542 void* args[1] = {NULL};
8543 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8544 if (result) {
8545 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8546 if (args[0]!=&returnValue) {
8547 if (args[0]==NULL) {
8548 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
8549 } else {
8550 returnValue = *((QPainter**)args[0]);
8551 }
8552 }
8553 }
8554 if (result) { Py_DECREF(result); }
8555 Py_DECREF(obj);
8556 return returnValue;
8557 } else {
8558 PyErr_Clear();
8559 }
8560 }
8561 return QCustomPlot::sharedPainter();
8562 }
8563 void PythonQtShell_QCustomPlot::showEvent(QShowEvent* arg__1)
8564 {
8565 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8566 static PyObject* name = PyString_FromString("showEvent");
8567 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8568 if (obj) {
8569 static const char* argumentList[] ={"" , "QShowEvent*"};
8570 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8571 void* args[2] = {NULL, (void*)&arg__1};
8572 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8573 if (result) { Py_DECREF(result); }
8574 Py_DECREF(obj);
8575 return;
8576 } else {
8577 PyErr_Clear();
8578 }
8579 }
8580 QCustomPlot::showEvent(arg__1);
8581 }
8582 QSize PythonQtShell_QCustomPlot::sizeHint() const
8583 {
8584 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8585 static PyObject* name = PyString_FromString("sizeHint");
8586 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8587 if (obj) {
8588 static const char* argumentList[] ={"QSize"};
8589 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8590 QSize returnValue;
8591 void* args[1] = {NULL};
8592 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8593 if (result) {
8594 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8595 if (args[0]!=&returnValue) {
8596 if (args[0]==NULL) {
8597 PythonQt::priv()->handleVirtualOverloadReturnError("sizeHint", methodInfo, result);
8598 } else {
8599 returnValue = *((QSize*)args[0]);
8600 }
8601 }
8602 }
8603 if (result) { Py_DECREF(result); }
8604 Py_DECREF(obj);
8605 return returnValue;
8606 } else {
8607 PyErr_Clear();
8608 }
8609 }
8610 return QCustomPlot::sizeHint();
8611 }
8612 void PythonQtShell_QCustomPlot::tabletEvent(QTabletEvent* arg__1)
8613 {
8614 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8615 static PyObject* name = PyString_FromString("tabletEvent");
8616 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8617 if (obj) {
8618 static const char* argumentList[] ={"" , "QTabletEvent*"};
8619 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8620 void* args[2] = {NULL, (void*)&arg__1};
8621 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8622 if (result) { Py_DECREF(result); }
8623 Py_DECREF(obj);
8624 return;
8625 } else {
8626 PyErr_Clear();
8627 }
8628 }
8629 QCustomPlot::tabletEvent(arg__1);
8630 }
8631 void PythonQtShell_QCustomPlot::timerEvent(QTimerEvent* arg__1)
8632 {
8633 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8634 static PyObject* name = PyString_FromString("timerEvent");
8635 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8636 if (obj) {
8637 static const char* argumentList[] ={"" , "QTimerEvent*"};
8638 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8639 void* args[2] = {NULL, (void*)&arg__1};
8640 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8641 if (result) { Py_DECREF(result); }
8642 Py_DECREF(obj);
8643 return;
8644 } else {
8645 PyErr_Clear();
8646 }
8647 }
8648 QCustomPlot::timerEvent(arg__1);
8649 }
8650 void PythonQtShell_QCustomPlot::wheelEvent(QWheelEvent* event0)
8651 {
8652 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8653 static PyObject* name = PyString_FromString("wheelEvent");
8654 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8655 if (obj) {
8656 static const char* argumentList[] ={"" , "QWheelEvent*"};
8657 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8658 void* args[2] = {NULL, (void*)&event0};
8659 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8660 if (result) { Py_DECREF(result); }
8661 Py_DECREF(obj);
8662 return;
8663 } else {
8664 PyErr_Clear();
8665 }
8666 }
8667 QCustomPlot::wheelEvent(event0);
8668 }
8669 QCustomPlot* PythonQtWrapper_QCustomPlot::new_QCustomPlot(QWidget* parent)
8670 {
8671 return new PythonQtShell_QCustomPlot(parent); }
8672
8673 QCPGraph* PythonQtWrapper_QCustomPlot::addGraph(QCustomPlot* theWrappedObject, QCPAxis* keyAxis, QCPAxis* valueAxis)
8674 {
8675 return ( theWrappedObject->addGraph(keyAxis, valueAxis));
8676 }
8677
8678 bool PythonQtWrapper_QCustomPlot::addItem(QCustomPlot* theWrappedObject, QCPAbstractItem* item)
8679 {
8680 return ( theWrappedObject->addItem(item));
8681 }
8682
8683 bool PythonQtWrapper_QCustomPlot::autoAddPlottableToLegend(QCustomPlot* theWrappedObject) const
8684 {
8685 return ( theWrappedObject->autoAddPlottableToLegend());
8686 }
8687
8688 QCPAxisRect* PythonQtWrapper_QCustomPlot::axisRect(QCustomPlot* theWrappedObject, int index) const
8689 {
8690 return ( theWrappedObject->axisRect(index));
8691 }
8692
8693 int PythonQtWrapper_QCustomPlot::axisRectCount(QCustomPlot* theWrappedObject) const
8694 {
8695 return ( theWrappedObject->axisRectCount());
8696 }
8697
8698 QList<QCPAxisRect* > PythonQtWrapper_QCustomPlot::axisRects(QCustomPlot* theWrappedObject) const
8699 {
8700 return ( theWrappedObject->axisRects());
8701 }
8702
8703 void PythonQtWrapper_QCustomPlot::axisRemoved(QCustomPlot* theWrappedObject, QCPAxis* axis)
8704 {
8705 ( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_axisRemoved(axis));
8706 }
8707
8708 QPixmap PythonQtWrapper_QCustomPlot::background(QCustomPlot* theWrappedObject) const
8709 {
8710 return ( theWrappedObject->background());
8711 }
8712
8713 bool PythonQtWrapper_QCustomPlot::backgroundScaled(QCustomPlot* theWrappedObject) const
8714 {
8715 return ( theWrappedObject->backgroundScaled());
8716 }
8717
8718 Qt::AspectRatioMode PythonQtWrapper_QCustomPlot::backgroundScaledMode(QCustomPlot* theWrappedObject) const
8719 {
8720 return ( theWrappedObject->backgroundScaledMode());
8721 }
8722
8723 int PythonQtWrapper_QCustomPlot::clearGraphs(QCustomPlot* theWrappedObject)
8724 {
8725 return ( theWrappedObject->clearGraphs());
8726 }
8727
8728 int PythonQtWrapper_QCustomPlot::clearItems(QCustomPlot* theWrappedObject)
8729 {
8730 return ( theWrappedObject->clearItems());
8731 }
8732
8733 int PythonQtWrapper_QCustomPlot::clearPlottables(QCustomPlot* theWrappedObject)
8734 {
8735 return ( theWrappedObject->clearPlottables());
8736 }
8737
8738 QCPLayer* PythonQtWrapper_QCustomPlot::currentLayer(QCustomPlot* theWrappedObject) const
8739 {
8740 return ( theWrappedObject->currentLayer());
8741 }
8742
8743 void PythonQtWrapper_QCustomPlot::deselectAll(QCustomPlot* theWrappedObject)
8744 {
8745 ( theWrappedObject->deselectAll());
8746 }
8747
8748 void PythonQtWrapper_QCustomPlot::draw(QCustomPlot* theWrappedObject, QCPPainter* painter)
8749 {
8750 ( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_draw(painter));
8751 }
8752
8753 void PythonQtWrapper_QCustomPlot::drawBackground(QCustomPlot* theWrappedObject, QCPPainter* painter)
8754 {
8755 ( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_drawBackground(painter));
8756 }
8757
8758 QCPGraph* PythonQtWrapper_QCustomPlot::graph(QCustomPlot* theWrappedObject) const
8759 {
8760 return ( theWrappedObject->graph());
8761 }
8762
8763 QCPGraph* PythonQtWrapper_QCustomPlot::graph(QCustomPlot* theWrappedObject, int index) const
8764 {
8765 return ( theWrappedObject->graph(index));
8766 }
8767
8768 int PythonQtWrapper_QCustomPlot::graphCount(QCustomPlot* theWrappedObject) const
8769 {
8770 return ( theWrappedObject->graphCount());
8771 }
8772
8773 bool PythonQtWrapper_QCustomPlot::hasItem(QCustomPlot* theWrappedObject, QCPAbstractItem* item) const
8774 {
8775 return ( theWrappedObject->hasItem(item));
8776 }
8777
8778 QCPAbstractItem* PythonQtWrapper_QCustomPlot::item(QCustomPlot* theWrappedObject) const
8779 {
8780 return ( theWrappedObject->item());
8781 }
8782
8783 QCPAbstractItem* PythonQtWrapper_QCustomPlot::item(QCustomPlot* theWrappedObject, int index) const
8784 {
8785 return ( theWrappedObject->item(index));
8786 }
8787
8788 QCPAbstractItem* PythonQtWrapper_QCustomPlot::itemAt(QCustomPlot* theWrappedObject, const QPointF& pos, bool onlySelectable) const
8789 {
8790 return ( theWrappedObject->itemAt(pos, onlySelectable));
8791 }
8792
8793 int PythonQtWrapper_QCustomPlot::itemCount(QCustomPlot* theWrappedObject) const
8794 {
8795 return ( theWrappedObject->itemCount());
8796 }
8797
8798 QCPLayer* PythonQtWrapper_QCustomPlot::layer(QCustomPlot* theWrappedObject, const QString& name) const
8799 {
8800 return ( theWrappedObject->layer(name));
8801 }
8802
8803 QCPLayer* PythonQtWrapper_QCustomPlot::layer(QCustomPlot* theWrappedObject, int index) const
8804 {
8805 return ( theWrappedObject->layer(index));
8806 }
8807
8808 int PythonQtWrapper_QCustomPlot::layerCount(QCustomPlot* theWrappedObject) const
8809 {
8810 return ( theWrappedObject->layerCount());
8811 }
8812
8813 QCPLayerable* PythonQtWrapper_QCustomPlot::layerableAt(QCustomPlot* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* selectionDetails) const
8814 {
8815 return ( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_layerableAt(pos, onlySelectable, selectionDetails));
8816 }
8817
8818 QCPLayoutElement* PythonQtWrapper_QCustomPlot::layoutElementAt(QCustomPlot* theWrappedObject, const QPointF& pos) const
8819 {
8820 return ( theWrappedObject->layoutElementAt(pos));
8821 }
8822
8823 void PythonQtWrapper_QCustomPlot::legendRemoved(QCustomPlot* theWrappedObject, QCPLegend* legend)
8824 {
8825 ( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_legendRemoved(legend));
8826 }
8827
8828 QSize PythonQtWrapper_QCustomPlot::minimumSizeHint(QCustomPlot* theWrappedObject) const
8829 {
8830 return ( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_minimumSizeHint());
8831 }
8832
8833 void PythonQtWrapper_QCustomPlot::mouseDoubleClickEvent(QCustomPlot* theWrappedObject, QMouseEvent* event)
8834 {
8835 ( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_mouseDoubleClickEvent(event));
8836 }
8837
8838 void PythonQtWrapper_QCustomPlot::mouseMoveEvent(QCustomPlot* theWrappedObject, QMouseEvent* event)
8839 {
8840 ( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_mouseMoveEvent(event));
8841 }
8842
8843 void PythonQtWrapper_QCustomPlot::mousePressEvent(QCustomPlot* theWrappedObject, QMouseEvent* event)
8844 {
8845 ( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_mousePressEvent(event));
8846 }
8847
8848 void PythonQtWrapper_QCustomPlot::mouseReleaseEvent(QCustomPlot* theWrappedObject, QMouseEvent* event)
8849 {
8850 ( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_mouseReleaseEvent(event));
8851 }
8852
8853 Qt::KeyboardModifier PythonQtWrapper_QCustomPlot::multiSelectModifier(QCustomPlot* theWrappedObject) const
8854 {
8855 return ( theWrappedObject->multiSelectModifier());
8856 }
8857
8858 bool PythonQtWrapper_QCustomPlot::noAntialiasingOnDrag(QCustomPlot* theWrappedObject) const
8859 {
8860 return ( theWrappedObject->noAntialiasingOnDrag());
8861 }
8862
8863 void PythonQtWrapper_QCustomPlot::paintEvent(QCustomPlot* theWrappedObject, QPaintEvent* event)
8864 {
8865 ( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_paintEvent(event));
8866 }
8867
8868 int PythonQtWrapper_QCustomPlot::plottableCount(QCustomPlot* theWrappedObject) const
8869 {
8870 return ( theWrappedObject->plottableCount());
8871 }
8872
8873 bool PythonQtWrapper_QCustomPlot::removeGraph(QCustomPlot* theWrappedObject, QCPGraph* graph)
8874 {
8875 return ( theWrappedObject->removeGraph(graph));
8876 }
8877
8878 bool PythonQtWrapper_QCustomPlot::removeGraph(QCustomPlot* theWrappedObject, int index)
8879 {
8880 return ( theWrappedObject->removeGraph(index));
8881 }
8882
8883 bool PythonQtWrapper_QCustomPlot::removeItem(QCustomPlot* theWrappedObject, QCPAbstractItem* item)
8884 {
8885 return ( theWrappedObject->removeItem(item));
8886 }
8887
8888 bool PythonQtWrapper_QCustomPlot::removeItem(QCustomPlot* theWrappedObject, int index)
8889 {
8890 return ( theWrappedObject->removeItem(index));
8891 }
8892
8893 bool PythonQtWrapper_QCustomPlot::removeLayer(QCustomPlot* theWrappedObject, QCPLayer* layer)
8894 {
8895 return ( theWrappedObject->removeLayer(layer));
8896 }
8897
8898 bool PythonQtWrapper_QCustomPlot::removePlottable(QCustomPlot* theWrappedObject, int index)
8899 {
8900 return ( theWrappedObject->removePlottable(index));
8901 }
8902
8903 void PythonQtWrapper_QCustomPlot::rescaleAxes(QCustomPlot* theWrappedObject, bool onlyVisiblePlottables)
8904 {
8905 ( theWrappedObject->rescaleAxes(onlyVisiblePlottables));
8906 }
8907
8908 void PythonQtWrapper_QCustomPlot::resizeEvent(QCustomPlot* theWrappedObject, QResizeEvent* event)
8909 {
8910 ( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_resizeEvent(event));
8911 }
8912
8913 bool PythonQtWrapper_QCustomPlot::saveBmp(QCustomPlot* theWrappedObject, const QString& fileName, int width, int height, double scale)
8914 {
8915 return ( theWrappedObject->saveBmp(fileName, width, height, scale));
8916 }
8917
8918 bool PythonQtWrapper_QCustomPlot::saveJpg(QCustomPlot* theWrappedObject, const QString& fileName, int width, int height, double scale, int quality)
8919 {
8920 return ( theWrappedObject->saveJpg(fileName, width, height, scale, quality));
8921 }
8922
8923 bool PythonQtWrapper_QCustomPlot::savePdf(QCustomPlot* theWrappedObject, const QString& fileName, bool noCosmeticPen, int width, int height, const QString& pdfCreator, const QString& pdfTitle)
8924 {
8925 return ( theWrappedObject->savePdf(fileName, noCosmeticPen, width, height, pdfCreator, pdfTitle));
8926 }
8927
8928 bool PythonQtWrapper_QCustomPlot::savePng(QCustomPlot* theWrappedObject, const QString& fileName, int width, int height, double scale, int quality)
8929 {
8930 return ( theWrappedObject->savePng(fileName, width, height, scale, quality));
8931 }
8932
8933 bool PythonQtWrapper_QCustomPlot::saveRastered(QCustomPlot* theWrappedObject, const QString& fileName, int width, int height, double scale, const char* format, int quality)
8934 {
8935 return ( theWrappedObject->saveRastered(fileName, width, height, scale, format, quality));
8936 }
8937
8938 QList<QCPAxis* > PythonQtWrapper_QCustomPlot::selectedAxes(QCustomPlot* theWrappedObject) const
8939 {
8940 return ( theWrappedObject->selectedAxes());
8941 }
8942
8943 QList<QCPGraph* > PythonQtWrapper_QCustomPlot::selectedGraphs(QCustomPlot* theWrappedObject) const
8944 {
8945 return ( theWrappedObject->selectedGraphs());
8946 }
8947
8948 QList<QCPAbstractItem* > PythonQtWrapper_QCustomPlot::selectedItems(QCustomPlot* theWrappedObject) const
8949 {
8950 return ( theWrappedObject->selectedItems());
8951 }
8952
8953 QList<QCPLegend* > PythonQtWrapper_QCustomPlot::selectedLegends(QCustomPlot* theWrappedObject) const
8954 {
8955 return ( theWrappedObject->selectedLegends());
8956 }
8957
8958 int PythonQtWrapper_QCustomPlot::selectionTolerance(QCustomPlot* theWrappedObject) const
8959 {
8960 return ( theWrappedObject->selectionTolerance());
8961 }
8962
8963 void PythonQtWrapper_QCustomPlot::setAutoAddPlottableToLegend(QCustomPlot* theWrappedObject, bool on)
8964 {
8965 ( theWrappedObject->setAutoAddPlottableToLegend(on));
8966 }
8967
8968 void PythonQtWrapper_QCustomPlot::setBackground(QCustomPlot* theWrappedObject, const QBrush& brush)
8969 {
8970 ( theWrappedObject->setBackground(brush));
8971 }
8972
8973 void PythonQtWrapper_QCustomPlot::setBackground(QCustomPlot* theWrappedObject, const QPixmap& pm)
8974 {
8975 ( theWrappedObject->setBackground(pm));
8976 }
8977
8978 void PythonQtWrapper_QCustomPlot::setBackground(QCustomPlot* theWrappedObject, const QPixmap& pm, bool scaled, Qt::AspectRatioMode mode)
8979 {
8980 ( theWrappedObject->setBackground(pm, scaled, mode));
8981 }
8982
8983 void PythonQtWrapper_QCustomPlot::setBackgroundScaled(QCustomPlot* theWrappedObject, bool scaled)
8984 {
8985 ( theWrappedObject->setBackgroundScaled(scaled));
8986 }
8987
8988 void PythonQtWrapper_QCustomPlot::setBackgroundScaledMode(QCustomPlot* theWrappedObject, Qt::AspectRatioMode mode)
8989 {
8990 ( theWrappedObject->setBackgroundScaledMode(mode));
8991 }
8992
8993 bool PythonQtWrapper_QCustomPlot::setCurrentLayer(QCustomPlot* theWrappedObject, QCPLayer* layer)
8994 {
8995 return ( theWrappedObject->setCurrentLayer(layer));
8996 }
8997
8998 bool PythonQtWrapper_QCustomPlot::setCurrentLayer(QCustomPlot* theWrappedObject, const QString& name)
8999 {
9000 return ( theWrappedObject->setCurrentLayer(name));
9001 }
9002
9003 void PythonQtWrapper_QCustomPlot::setMultiSelectModifier(QCustomPlot* theWrappedObject, Qt::KeyboardModifier modifier)
9004 {
9005 ( theWrappedObject->setMultiSelectModifier(modifier));
9006 }
9007
9008 void PythonQtWrapper_QCustomPlot::setNoAntialiasingOnDrag(QCustomPlot* theWrappedObject, bool enabled)
9009 {
9010 ( theWrappedObject->setNoAntialiasingOnDrag(enabled));
9011 }
9012
9013 void PythonQtWrapper_QCustomPlot::setSelectionTolerance(QCustomPlot* theWrappedObject, int pixels)
9014 {
9015 ( theWrappedObject->setSelectionTolerance(pixels));
9016 }
9017
9018 void PythonQtWrapper_QCustomPlot::setViewport(QCustomPlot* theWrappedObject, const QRect& rect)
9019 {
9020 ( theWrappedObject->setViewport(rect));
9021 }
9022
9023 QSize PythonQtWrapper_QCustomPlot::sizeHint(QCustomPlot* theWrappedObject) const
9024 {
9025 return ( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_sizeHint());
9026 }
9027
9028 void PythonQtWrapper_QCustomPlot::toPainter(QCustomPlot* theWrappedObject, QCPPainter* painter, int width, int height)
9029 {
9030 ( theWrappedObject->toPainter(painter, width, height));
9031 }
9032
9033 QPixmap PythonQtWrapper_QCustomPlot::toPixmap(QCustomPlot* theWrappedObject, int width, int height, double scale)
9034 {
9035 return ( theWrappedObject->toPixmap(width, height, scale));
9036 }
9037
9038 void PythonQtWrapper_QCustomPlot::updateLayerIndices(QCustomPlot* theWrappedObject) const
9039 {
9040 ( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_updateLayerIndices());
9041 }
9042
9043 QRect PythonQtWrapper_QCustomPlot::viewport(QCustomPlot* theWrappedObject) const
9044 {
9045 return ( theWrappedObject->viewport());
9046 }
9047
9048 void PythonQtWrapper_QCustomPlot::wheelEvent(QCustomPlot* theWrappedObject, QWheelEvent* event)
9049 {
9050 ( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_wheelEvent(event));
9051 }
9052
9053
9054
9055 PythonQtShell_QLopData::~PythonQtShell_QLopData() {
9056 PythonQtPrivate* priv = PythonQt::priv();
9057 if (priv) { priv->shellClassDeleted(this); }
9058 }
9059 void PythonQtShell_QLopData::childEvent(QChildEvent* arg__1)
9060 {
9061 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9062 static PyObject* name = PyString_FromString("childEvent");
9063 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9064 if (obj) {
9065 static const char* argumentList[] ={"" , "QChildEvent*"};
9066 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9067 void* args[2] = {NULL, (void*)&arg__1};
9068 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9069 if (result) { Py_DECREF(result); }
9070 Py_DECREF(obj);
9071 return;
9072 } else {
9073 PyErr_Clear();
9074 }
9075 }
9076 QLopData::childEvent(arg__1);
9077 }
9078 void PythonQtShell_QLopData::customEvent(QEvent* arg__1)
9079 {
9080 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9081 static PyObject* name = PyString_FromString("customEvent");
9082 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9083 if (obj) {
9084 static const char* argumentList[] ={"" , "QEvent*"};
9085 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9086 void* args[2] = {NULL, (void*)&arg__1};
9087 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9088 if (result) { Py_DECREF(result); }
9089 Py_DECREF(obj);
9090 return;
9091 } else {
9092 PyErr_Clear();
9093 }
9094 }
9095 QLopData::customEvent(arg__1);
9096 }
9097 bool PythonQtShell_QLopData::event(QEvent* arg__1)
9098 {
9099 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9100 static PyObject* name = PyString_FromString("event");
9101 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9102 if (obj) {
9103 static const char* argumentList[] ={"bool" , "QEvent*"};
9104 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9105 bool returnValue;
9106 void* args[2] = {NULL, (void*)&arg__1};
9107 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9108 if (result) {
9109 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
9110 if (args[0]!=&returnValue) {
9111 if (args[0]==NULL) {
9112 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
9113 } else {
9114 returnValue = *((bool*)args[0]);
9115 }
9116 }
9117 }
9118 if (result) { Py_DECREF(result); }
9119 Py_DECREF(obj);
9120 return returnValue;
9121 } else {
9122 PyErr_Clear();
9123 }
9124 }
9125 return QLopData::event(arg__1);
9126 }
9127 bool PythonQtShell_QLopData::eventFilter(QObject* arg__1, QEvent* arg__2)
9128 {
9129 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9130 static PyObject* name = PyString_FromString("eventFilter");
9131 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9132 if (obj) {
9133 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
9134 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
9135 bool returnValue;
9136 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
9137 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9138 if (result) {
9139 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
9140 if (args[0]!=&returnValue) {
9141 if (args[0]==NULL) {
9142 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
9143 } else {
9144 returnValue = *((bool*)args[0]);
9145 }
9146 }
9147 }
9148 if (result) { Py_DECREF(result); }
9149 Py_DECREF(obj);
9150 return returnValue;
9151 } else {
9152 PyErr_Clear();
9153 }
9154 }
9155 return QLopData::eventFilter(arg__1, arg__2);
9156 }
9157 void PythonQtShell_QLopData::timerEvent(QTimerEvent* arg__1)
9158 {
9159 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9160 static PyObject* name = PyString_FromString("timerEvent");
9161 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9162 if (obj) {
9163 static const char* argumentList[] ={"" , "QTimerEvent*"};
9164 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9165 void* args[2] = {NULL, (void*)&arg__1};
9166 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9167 if (result) { Py_DECREF(result); }
9168 Py_DECREF(obj);
9169 return;
9170 } else {
9171 PyErr_Clear();
9172 }
9173 }
9174 QLopData::timerEvent(arg__1);
9175 }
9176 QLopData* PythonQtWrapper_QLopData::new_QLopData(QObject* parent)
9177 {
9178 return new PythonQtShell_QLopData(parent); }
9179
9180
9181
9182 QLopDataList* PythonQtWrapper_QLopDataList::new_QLopDataList()
9183 {
9184 return new QLopDataList(); }
9185
9186 QLopDataList* PythonQtWrapper_QLopDataList::new_QLopDataList(const QList<QLopData* >& l)
9187 {
9188 return new QLopDataList(l); }
9189
9190 void PythonQtWrapper_QLopDataList::append(QLopDataList* theWrappedObject, QLopData* t)
9191 {
9192 ( theWrappedObject->append(t));
9193 }
9194
9195 void PythonQtWrapper_QLopDataList::append(QLopDataList* theWrappedObject, const QList<QLopData* >& t)
9196 {
9197 ( theWrappedObject->append(t));
9198 }
9199
9200 QLopData* PythonQtWrapper_QLopDataList::at(QLopDataList* theWrappedObject, int i) const
9201 {
9202 return ( theWrappedObject->at(i));
9203 }
9204
9205 QLopData* PythonQtWrapper_QLopDataList::back(QLopDataList* theWrappedObject) const
9206 {
9207 return ( theWrappedObject->back());
9208 }
9209
9210 void PythonQtWrapper_QLopDataList::clear(QLopDataList* theWrappedObject)
9211 {
9212 ( theWrappedObject->clear());
9213 }
9214
9215 bool PythonQtWrapper_QLopDataList::contains(QLopDataList* theWrappedObject, QLopData* t) const
9216 {
9217 return ( theWrappedObject->contains(t));
9218 }
9219
9220 int PythonQtWrapper_QLopDataList::count(QLopDataList* theWrappedObject) const
9221 {
9222 return ( theWrappedObject->count());
9223 }
9224
9225 int PythonQtWrapper_QLopDataList::count(QLopDataList* theWrappedObject, QLopData* t) const
9226 {
9227 return ( theWrappedObject->count(t));
9228 }
9229
9230 void PythonQtWrapper_QLopDataList::detachShared(QLopDataList* theWrappedObject)
9231 {
9232 ( theWrappedObject->detachShared());
9233 }
9234
9235 bool PythonQtWrapper_QLopDataList::empty(QLopDataList* theWrappedObject) const
9236 {
9237 return ( theWrappedObject->empty());
9238 }
9239
9240 bool PythonQtWrapper_QLopDataList::endsWith(QLopDataList* theWrappedObject, QLopData* t) const
9241 {
9242 return ( theWrappedObject->endsWith(t));
9243 }
9244
9245 QLopData* PythonQtWrapper_QLopDataList::first(QLopDataList* theWrappedObject) const
9246 {
9247 return ( theWrappedObject->first());
9248 }
9249
9250 QList<QLopData* > PythonQtWrapper_QLopDataList::static_QLopDataList_fromVector(const QVector<QLopData* >& vector)
9251 {
9252 return (QLopDataList::fromVector(vector));
9253 }
9254
9255 QLopData* PythonQtWrapper_QLopDataList::front(QLopDataList* theWrappedObject) const
9256 {
9257 return ( theWrappedObject->front());
9258 }
9259
9260 int PythonQtWrapper_QLopDataList::indexOf(QLopDataList* theWrappedObject, QLopData* t, int from) const
9261 {
9262 return ( theWrappedObject->indexOf(t, from));
9263 }
9264
9265 bool PythonQtWrapper_QLopDataList::isEmpty(QLopDataList* theWrappedObject) const
9266 {
9267 return ( theWrappedObject->isEmpty());
9268 }
9269
9270 bool PythonQtWrapper_QLopDataList::isSharedWith(QLopDataList* theWrappedObject, const QList<QLopData* >& other) const
9271 {
9272 return ( theWrappedObject->isSharedWith(other));
9273 }
9274
9275 QLopData* PythonQtWrapper_QLopDataList::last(QLopDataList* theWrappedObject) const
9276 {
9277 return ( theWrappedObject->last());
9278 }
9279
9280 int PythonQtWrapper_QLopDataList::lastIndexOf(QLopDataList* theWrappedObject, QLopData* t, int from) const
9281 {
9282 return ( theWrappedObject->lastIndexOf(t, from));
9283 }
9284
9285 int PythonQtWrapper_QLopDataList::length(QLopDataList* theWrappedObject) const
9286 {
9287 return ( theWrappedObject->length());
9288 }
9289
9290 QList<QLopData* > PythonQtWrapper_QLopDataList::mid(QLopDataList* theWrappedObject, int pos, int length) const
9291 {
9292 return ( theWrappedObject->mid(pos, length));
9293 }
9294
9295 void PythonQtWrapper_QLopDataList::move(QLopDataList* theWrappedObject, int from, int to)
9296 {
9297 ( theWrappedObject->move(from, to));
9298 }
9299
9300 bool PythonQtWrapper_QLopDataList::__ne__(QLopDataList* theWrappedObject, const QList<QLopData* >& l) const
9301 {
9302 return ( (*theWrappedObject)!= l);
9303 }
9304
9305 QList<QLopData* > PythonQtWrapper_QLopDataList::__add__(QLopDataList* theWrappedObject, const QList<QLopData* >& l) const
9306 {
9307 return ( (*theWrappedObject)+ l);
9308 }
9309
9310 QList<QLopData* >* PythonQtWrapper_QLopDataList::__iadd__(QLopDataList* theWrappedObject, QLopData* t)
9311 {
9312 return &( (*theWrappedObject)+= t);
9313 }
9314
9315 QList<QLopData* >* PythonQtWrapper_QLopDataList::__iadd__(QLopDataList* theWrappedObject, const QList<QLopData* >& l)
9316 {
9317 return &( (*theWrappedObject)+= l);
9318 }
9319
9320 QList<QLopData* >* PythonQtWrapper_QLopDataList::__lshift__(QLopDataList* theWrappedObject, QLopData* t)
9321 {
9322 return &( (*theWrappedObject) <<t);
9323 }
9324
9325 QList<QLopData* >* PythonQtWrapper_QLopDataList::__lshift__(QLopDataList* theWrappedObject, const QList<QLopData* >& l)
9326 {
9327 return &( (*theWrappedObject) <<l);
9328 }
9329
9330 bool PythonQtWrapper_QLopDataList::__eq__(QLopDataList* theWrappedObject, const QList<QLopData* >& l) const
9331 {
9332 return ( (*theWrappedObject)== l);
9333 }
9334
9335 void PythonQtWrapper_QLopDataList::pop_back(QLopDataList* theWrappedObject)
9336 {
9337 ( theWrappedObject->pop_back());
9338 }
9339
9340 void PythonQtWrapper_QLopDataList::pop_front(QLopDataList* theWrappedObject)
9341 {
9342 ( theWrappedObject->pop_front());
9343 }
9344
9345 void PythonQtWrapper_QLopDataList::prepend(QLopDataList* theWrappedObject, QLopData* t)
9346 {
9347 ( theWrappedObject->prepend(t));
9348 }
9349
9350 void PythonQtWrapper_QLopDataList::push_back(QLopDataList* theWrappedObject, QLopData* t)
9351 {
9352 ( theWrappedObject->push_back(t));
9353 }
9354
9355 void PythonQtWrapper_QLopDataList::push_front(QLopDataList* theWrappedObject, QLopData* t)
9356 {
9357 ( theWrappedObject->push_front(t));
9358 }
9359
9360 int PythonQtWrapper_QLopDataList::removeAll(QLopDataList* theWrappedObject, QLopData* t)
9361 {
9362 return ( theWrappedObject->removeAll(t));
9363 }
9364
9365 void PythonQtWrapper_QLopDataList::removeAt(QLopDataList* theWrappedObject, int i)
9366 {
9367 ( theWrappedObject->removeAt(i));
9368 }
9369
9370 void PythonQtWrapper_QLopDataList::removeFirst(QLopDataList* theWrappedObject)
9371 {
9372 ( theWrappedObject->removeFirst());
9373 }
9374
9375 void PythonQtWrapper_QLopDataList::removeLast(QLopDataList* theWrappedObject)
9376 {
9377 ( theWrappedObject->removeLast());
9378 }
9379
9380 bool PythonQtWrapper_QLopDataList::removeOne(QLopDataList* theWrappedObject, QLopData* t)
9381 {
9382 return ( theWrappedObject->removeOne(t));
9383 }
9384
9385 void PythonQtWrapper_QLopDataList::replace(QLopDataList* theWrappedObject, int i, QLopData* t)
9386 {
9387 ( theWrappedObject->replace(i, t));
9388 }
9389
9390 void PythonQtWrapper_QLopDataList::reserve(QLopDataList* theWrappedObject, int size)
9391 {
9392 ( theWrappedObject->reserve(size));
9393 }
9394
9395 void PythonQtWrapper_QLopDataList::setSharable(QLopDataList* theWrappedObject, bool sharable)
9396 {
9397 ( theWrappedObject->setSharable(sharable));
9398 }
9399
9400 int PythonQtWrapper_QLopDataList::size(QLopDataList* theWrappedObject) const
9401 {
9402 return ( theWrappedObject->size());
9403 }
9404
9405 bool PythonQtWrapper_QLopDataList::startsWith(QLopDataList* theWrappedObject, QLopData* t) const
9406 {
9407 return ( theWrappedObject->startsWith(t));
9408 }
9409
9410 void PythonQtWrapper_QLopDataList::swap(QLopDataList* theWrappedObject, QList<QLopData* >& other)
9411 {
9412 ( theWrappedObject->swap(other));
9413 }
9414
9415 void PythonQtWrapper_QLopDataList::swap(QLopDataList* theWrappedObject, int i, int j)
9416 {
9417 ( theWrappedObject->swap(i, j));
9418 }
9419
9420 QLopData* PythonQtWrapper_QLopDataList::takeAt(QLopDataList* theWrappedObject, int i)
9421 {
9422 return ( theWrappedObject->takeAt(i));
9423 }
9424
9425 QLopData* PythonQtWrapper_QLopDataList::takeFirst(QLopDataList* theWrappedObject)
9426 {
9427 return ( theWrappedObject->takeFirst());
9428 }
9429
9430 QLopData* PythonQtWrapper_QLopDataList::takeLast(QLopDataList* theWrappedObject)
9431 {
9432 return ( theWrappedObject->takeLast());
9433 }
9434
9435 QVector<QLopData* > PythonQtWrapper_QLopDataList::toVector(QLopDataList* theWrappedObject) const
9436 {
9437 return ( theWrappedObject->toVector());
9438 }
9439
9440 QLopData* PythonQtWrapper_QLopDataList::value(QLopDataList* theWrappedObject, int i) const
9441 {
9442 return ( theWrappedObject->value(i));
9443 }
9444
9445 QLopData* PythonQtWrapper_QLopDataList::value(QLopDataList* theWrappedObject, int i, QLopData* defaultValue) const
9446 {
9447 return ( theWrappedObject->value(i, defaultValue));
9448 }
9449
9450
9451
40 PythonQtShell_QLopService::~PythonQtShell_QLopService() {
9452 PythonQtShell_QLopService::~PythonQtShell_QLopService() {
41 PythonQtPrivate* priv = PythonQt::priv();
9453 PythonQtPrivate* priv = PythonQt::priv();
42 if (priv) { priv->shellClassDeleted(this); }
9454 if (priv) { priv->shellClassDeleted(this); }
Show file before | Show file after | Hide comments
This diff has been collapsed as it changes many lines, (1555 lines changed) Show them Hide them
@@ -2,43 +2,1598
2 #include <QObject>
2 #include <QObject>
3 #include <QVariant>
3 #include <QVariant>
4 #include <SocExplorerPlot.h>
4 #include <SocExplorerPlot.h>
5 #include <filebrowser.h>
6 #include <qabstractitemmodel.h>
5 #include <qaction.h>
7 #include <qaction.h>
6 #include <qbackingstore.h>
8 #include <qbackingstore.h>
7 #include <qbitmap.h>
9 #include <qbitmap.h>
10 #include <qbrush.h>
8 #include <qbytearray.h>
11 #include <qbytearray.h>
12 #include <qcolor.h>
9 #include <qcoreevent.h>
13 #include <qcoreevent.h>
10 #include <qcursor.h>
14 #include <qcursor.h>
15 #include <qcustomplot.h>
11 #include <qdockwidget.h>
16 #include <qdockwidget.h>
12 #include <qevent.h>
17 #include <qevent.h>
13 #include <qfont.h>
18 #include <qfont.h>
19 #include <qfontinfo.h>
20 #include <qfontmetrics.h>
21 #include <qglyphrun.h>
14 #include <qgraphicseffect.h>
22 #include <qgraphicseffect.h>
15 #include <qgraphicsproxywidget.h>
23 #include <qgraphicsproxywidget.h>
16 #include <qicon.h>
24 #include <qicon.h>
25 #include <qimage.h>
17 #include <qkeysequence.h>
26 #include <qkeysequence.h>
18 #include <qlayout.h>
27 #include <qlayout.h>
28 #include <qline.h>
19 #include <qlist.h>
29 #include <qlist.h>
20 #include <qlocale.h>
30 #include <qlocale.h>
31 #include <qlopdata.h>
21 #include <qlopservice.h>
32 #include <qlopservice.h>
22 #include <qmargins.h>
33 #include <qmargins.h>
34 #include <qmatrix.h>
23 #include <qmetaobject.h>
35 #include <qmetaobject.h>
24 #include <qobject.h>
36 #include <qobject.h>
25 #include <qpaintdevice.h>
37 #include <qpaintdevice.h>
26 #include <qpaintengine.h>
38 #include <qpaintengine.h>
27 #include <qpainter.h>
39 #include <qpainter.h>
40 #include <qpainterpath.h>
28 #include <qpalette.h>
41 #include <qpalette.h>
29 #include <qpen.h>
42 #include <qpen.h>
43 #include <qpicture.h>
30 #include <qpixmap.h>
44 #include <qpixmap.h>
31 #include <qpoint.h>
45 #include <qpoint.h>
46 #include <qpolygon.h>
32 #include <qrect.h>
47 #include <qrect.h>
33 #include <qregion.h>
48 #include <qregion.h>
34 #include <qsize.h>
49 #include <qsize.h>
35 #include <qsizepolicy.h>
50 #include <qsizepolicy.h>
51 #include <qstatictext.h>
52 #include <qstringlist.h>
36 #include <qstyle.h>
53 #include <qstyle.h>
54 #include <qstyleoption.h>
55 #include <qtextoption.h>
56 #include <qtransform.h>
57 #include <qvector.h>
37 #include <qwidget.h>
58 #include <qwidget.h>
38 #include <qwindow.h>
59 #include <qwindow.h>
39
60
40
61
41
62
63 class PythonQtShell_FileBrowser : public FileBrowser
64 {
65 public:
66 PythonQtShell_FileBrowser(QWidget* parent = 0):FileBrowser(parent),_wrapper(NULL) { };
67
68 ~PythonQtShell_FileBrowser();
69
70 virtual void actionEvent(QActionEvent* arg__1);
71 virtual void changeEvent(QEvent* e);
72 virtual void childEvent(QChildEvent* arg__1);
73 virtual void closeEvent(QCloseEvent* event);
74 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
75 virtual void customEvent(QEvent* arg__1);
76 virtual int devType() const;
77 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
78 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
79 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
80 virtual void dropEvent(QDropEvent* arg__1);
81 virtual void enterEvent(QEvent* arg__1);
82 virtual bool event(QEvent* event);
83 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
84 virtual void focusInEvent(QFocusEvent* arg__1);
85 virtual bool focusNextPrevChild(bool next);
86 virtual void focusOutEvent(QFocusEvent* arg__1);
87 virtual bool hasHeightForWidth() const;
88 virtual int heightForWidth(int arg__1) const;
89 virtual void hideEvent(QHideEvent* arg__1);
90 virtual void initPainter(QPainter* painter) const;
91 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
92 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
93 virtual void keyPressEvent(QKeyEvent* e);
94 virtual void keyReleaseEvent(QKeyEvent* arg__1);
95 virtual void leaveEvent(QEvent* arg__1);
96 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
97 virtual QSize minimumSizeHint() const;
98 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
99 virtual void mouseMoveEvent(QMouseEvent* arg__1);
100 virtual void mousePressEvent(QMouseEvent* arg__1);
101 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
102 virtual void moveEvent(QMoveEvent* arg__1);
103 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
104 virtual QPaintEngine* paintEngine() const;
105 virtual void paintEvent(QPaintEvent* event);
106 virtual QPaintDevice* redirected(QPoint* offset) const;
107 virtual void resizeEvent(QResizeEvent* arg__1);
108 virtual QPainter* sharedPainter() const;
109 virtual void showEvent(QShowEvent* arg__1);
110 virtual QSize sizeHint() const;
111 virtual void tabletEvent(QTabletEvent* arg__1);
112 virtual void timerEvent(QTimerEvent* arg__1);
113 virtual void wheelEvent(QWheelEvent* arg__1);
114
115 PythonQtInstanceWrapper* _wrapper;
116 };
117
118 class PythonQtPublicPromoter_FileBrowser : public FileBrowser
119 { public:
120 inline void promoted_changeEvent(QEvent* e) { FileBrowser::changeEvent(e); }
121 inline void promoted_keyPressEvent(QKeyEvent* e) { FileBrowser::keyPressEvent(e); }
122 };
123
124 class PythonQtWrapper_FileBrowser : public QObject
125 { Q_OBJECT
126 public:
127 public slots:
128 FileBrowser* new_FileBrowser(QWidget* parent = 0);
129 void delete_FileBrowser(FileBrowser* obj) { delete obj; }
130 void changeEvent(FileBrowser* theWrappedObject, QEvent* e);
131 void keyPressEvent(FileBrowser* theWrappedObject, QKeyEvent* e);
132 void setNameFilters(FileBrowser* theWrappedObject, const QStringList& filters, bool disables = false);
133 };
134
135
136
137
138
139 class PythonQtShell_QCPAbstractItem : public QCPAbstractItem
140 {
141 public:
142 PythonQtShell_QCPAbstractItem(QCustomPlot* parentPlot):QCPAbstractItem(parentPlot),_wrapper(NULL) { };
143
144 ~PythonQtShell_QCPAbstractItem();
145
146 virtual QPointF anchorPixelPoint(int anchorId) const;
147 virtual void applyDefaultAntialiasingHint(QCPPainter* painter) const;
148 virtual void childEvent(QChildEvent* arg__1);
149 virtual QRect clipRect() const;
150 virtual void customEvent(QEvent* arg__1);
151 virtual void deselectEvent(bool* selectionStateChanged);
152 virtual void draw(QCPPainter* painter);
153 virtual bool event(QEvent* arg__1);
154 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
155 virtual void parentPlotInitialized(QCustomPlot* parentPlot);
156 virtual void selectEvent(QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged);
157 virtual double selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const;
158 virtual void timerEvent(QTimerEvent* arg__1);
159
160 PythonQtInstanceWrapper* _wrapper;
161 };
162
163 class PythonQtPublicPromoter_QCPAbstractItem : public QCPAbstractItem
164 { public:
165 inline QPointF promoted_anchorPixelPoint(int anchorId) const { return QCPAbstractItem::anchorPixelPoint(anchorId); }
166 inline void promoted_applyDefaultAntialiasingHint(QCPPainter* painter) const { QCPAbstractItem::applyDefaultAntialiasingHint(painter); }
167 inline QRect promoted_clipRect() const { return QCPAbstractItem::clipRect(); }
168 inline QCPItemPosition* promoted_createPosition(const QString& name) { return QCPAbstractItem::createPosition(name); }
169 inline void promoted_deselectEvent(bool* selectionStateChanged) { QCPAbstractItem::deselectEvent(selectionStateChanged); }
170 inline double promoted_distSqrToLine(const QPointF& start, const QPointF& end, const QPointF& point) const { return QCPAbstractItem::distSqrToLine(start, end, point); }
171 inline void promoted_draw(QCPPainter* painter) { draw(painter); }
172 inline double promoted_rectSelectTest(const QRectF& rect, const QPointF& pos, bool filledRect) const { return QCPAbstractItem::rectSelectTest(rect, pos, filledRect); }
173 inline void promoted_selectEvent(QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged) { QCPAbstractItem::selectEvent(event, additive, details, selectionStateChanged); }
174 inline double promoted_selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const { return selectTest(pos, onlySelectable, details); }
175 };
176
177 class PythonQtWrapper_QCPAbstractItem : public QObject
178 { Q_OBJECT
179 public:
180 public slots:
181 QCPAbstractItem* new_QCPAbstractItem(QCustomPlot* parentPlot);
182 void delete_QCPAbstractItem(QCPAbstractItem* obj) { delete obj; }
183 QPointF anchorPixelPoint(QCPAbstractItem* theWrappedObject, int anchorId) const;
184 void applyDefaultAntialiasingHint(QCPAbstractItem* theWrappedObject, QCPPainter* painter) const;
185 QCPAxisRect* clipAxisRect(QCPAbstractItem* theWrappedObject) const;
186 QRect clipRect(QCPAbstractItem* theWrappedObject) const;
187 bool clipToAxisRect(QCPAbstractItem* theWrappedObject) const;
188 QCPItemPosition* createPosition(QCPAbstractItem* theWrappedObject, const QString& name);
189 void deselectEvent(QCPAbstractItem* theWrappedObject, bool* selectionStateChanged);
190 double distSqrToLine(QCPAbstractItem* theWrappedObject, const QPointF& start, const QPointF& end, const QPointF& point) const;
191 void draw(QCPAbstractItem* theWrappedObject, QCPPainter* painter);
192 bool hasAnchor(QCPAbstractItem* theWrappedObject, const QString& name) const;
193 QCPItemPosition* position(QCPAbstractItem* theWrappedObject, const QString& name) const;
194 QList<QCPItemPosition* > positions(QCPAbstractItem* theWrappedObject) const;
195 double rectSelectTest(QCPAbstractItem* theWrappedObject, const QRectF& rect, const QPointF& pos, bool filledRect) const;
196 void selectEvent(QCPAbstractItem* theWrappedObject, QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged);
197 double selectTest(QCPAbstractItem* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details = 0) const;
198 bool selectable(QCPAbstractItem* theWrappedObject) const;
199 bool selected(QCPAbstractItem* theWrappedObject) const;
200 void setClipAxisRect(QCPAbstractItem* theWrappedObject, QCPAxisRect* rect);
201 void setClipToAxisRect(QCPAbstractItem* theWrappedObject, bool clip);
202 void setSelectable(QCPAbstractItem* theWrappedObject, bool selectable);
203 void setSelected(QCPAbstractItem* theWrappedObject, bool selected);
204 };
205
206
207
208
209
210 class PythonQtShell_QCPAbstractLegendItem : public QCPAbstractLegendItem
211 {
212 public:
213 PythonQtShell_QCPAbstractLegendItem(QCPLegend* parent):QCPAbstractLegendItem(parent),_wrapper(NULL) { };
214
215 ~PythonQtShell_QCPAbstractLegendItem();
216
217 virtual void applyDefaultAntialiasingHint(QCPPainter* painter) const;
218 virtual void childEvent(QChildEvent* arg__1);
219 virtual QRect clipRect() const;
220 virtual void customEvent(QEvent* arg__1);
221 virtual void deselectEvent(bool* selectionStateChanged);
222 virtual void draw(QCPPainter* painter);
223 virtual QList<QCPLayoutElement* > elements(bool recursive) const;
224 virtual bool event(QEvent* arg__1);
225 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
226 virtual QSize maximumSizeHint() const;
227 virtual QSize minimumSizeHint() const;
228 virtual void mouseDoubleClickEvent(QMouseEvent* event);
229 virtual void mouseMoveEvent(QMouseEvent* event);
230 virtual void mousePressEvent(QMouseEvent* event);
231 virtual void mouseReleaseEvent(QMouseEvent* event);
232 virtual void parentPlotInitialized(QCustomPlot* parentPlot);
233 virtual void selectEvent(QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged);
234 virtual double selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const;
235 virtual void timerEvent(QTimerEvent* arg__1);
236 virtual void wheelEvent(QWheelEvent* event);
237
238 PythonQtInstanceWrapper* _wrapper;
239 };
240
241 class PythonQtPublicPromoter_QCPAbstractLegendItem : public QCPAbstractLegendItem
242 { public:
243 inline void promoted_applyDefaultAntialiasingHint(QCPPainter* painter) const { QCPAbstractLegendItem::applyDefaultAntialiasingHint(painter); }
244 inline QRect promoted_clipRect() const { return QCPAbstractLegendItem::clipRect(); }
245 inline void promoted_deselectEvent(bool* selectionStateChanged) { QCPAbstractLegendItem::deselectEvent(selectionStateChanged); }
246 inline void promoted_draw(QCPPainter* painter) { draw(painter); }
247 inline void promoted_selectEvent(QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged) { QCPAbstractLegendItem::selectEvent(event, additive, details, selectionStateChanged); }
248 inline double promoted_selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const { return QCPAbstractLegendItem::selectTest(pos, onlySelectable, details); }
249 };
250
251 class PythonQtWrapper_QCPAbstractLegendItem : public QObject
252 { Q_OBJECT
253 public:
254 public slots:
255 QCPAbstractLegendItem* new_QCPAbstractLegendItem(QCPLegend* parent);
256 void delete_QCPAbstractLegendItem(QCPAbstractLegendItem* obj) { delete obj; }
257 void applyDefaultAntialiasingHint(QCPAbstractLegendItem* theWrappedObject, QCPPainter* painter) const;
258 QRect clipRect(QCPAbstractLegendItem* theWrappedObject) const;
259 void deselectEvent(QCPAbstractLegendItem* theWrappedObject, bool* selectionStateChanged);
260 void draw(QCPAbstractLegendItem* theWrappedObject, QCPPainter* painter);
261 QFont font(QCPAbstractLegendItem* theWrappedObject) const;
262 QCPLegend* parentLegend(QCPAbstractLegendItem* theWrappedObject) const;
263 void selectEvent(QCPAbstractLegendItem* theWrappedObject, QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged);
264 double selectTest(QCPAbstractLegendItem* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details = 0) const;
265 bool selectable(QCPAbstractLegendItem* theWrappedObject) const;
266 bool selected(QCPAbstractLegendItem* theWrappedObject) const;
267 QFont selectedFont(QCPAbstractLegendItem* theWrappedObject) const;
268 QColor selectedTextColor(QCPAbstractLegendItem* theWrappedObject) const;
269 void setFont(QCPAbstractLegendItem* theWrappedObject, const QFont& font);
270 void setSelectable(QCPAbstractLegendItem* theWrappedObject, bool selectable);
271 void setSelected(QCPAbstractLegendItem* theWrappedObject, bool selected);
272 void setSelectedFont(QCPAbstractLegendItem* theWrappedObject, const QFont& font);
273 void setSelectedTextColor(QCPAbstractLegendItem* theWrappedObject, const QColor& color);
274 void setTextColor(QCPAbstractLegendItem* theWrappedObject, const QColor& color);
275 QColor textColor(QCPAbstractLegendItem* theWrappedObject) const;
276 };
277
278
279
280
281
282 class PythonQtPublicPromoter_QCPAxis : public QCPAxis
283 { public:
284 inline void promoted_applyDefaultAntialiasingHint(QCPPainter* painter) const { QCPAxis::applyDefaultAntialiasingHint(painter); }
285 inline double promoted_baseLog(double value) const { return QCPAxis::baseLog(value); }
286 inline double promoted_basePow(double value) const { return QCPAxis::basePow(value); }
287 inline int promoted_calculateAutoSubTickCount(double tickStep) const { return QCPAxis::calculateAutoSubTickCount(tickStep); }
288 inline int promoted_calculateMargin() { return QCPAxis::calculateMargin(); }
289 inline void promoted_deselectEvent(bool* selectionStateChanged) { QCPAxis::deselectEvent(selectionStateChanged); }
290 inline void promoted_draw(QCPPainter* painter) { QCPAxis::draw(painter); }
291 inline void promoted_generateAutoTicks() { QCPAxis::generateAutoTicks(); }
292 inline QPen promoted_getBasePen() const { return QCPAxis::getBasePen(); }
293 inline QColor promoted_getLabelColor() const { return QCPAxis::getLabelColor(); }
294 inline QFont promoted_getLabelFont() const { return QCPAxis::getLabelFont(); }
295 inline QPen promoted_getSubTickPen() const { return QCPAxis::getSubTickPen(); }
296 inline QColor promoted_getTickLabelColor() const { return QCPAxis::getTickLabelColor(); }
297 inline QFont promoted_getTickLabelFont() const { return QCPAxis::getTickLabelFont(); }
298 inline QPen promoted_getTickPen() const { return QCPAxis::getTickPen(); }
299 inline void promoted_selectEvent(QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged) { QCPAxis::selectEvent(event, additive, details, selectionStateChanged); }
300 inline double promoted_selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const { return QCPAxis::selectTest(pos, onlySelectable, details); }
301 inline void promoted_setupTickVectors() { QCPAxis::setupTickVectors(); }
302 inline void promoted_visibleTickBounds(int& lowIndex, int& highIndex) const { QCPAxis::visibleTickBounds(lowIndex, highIndex); }
303 };
304
305 class PythonQtWrapper_QCPAxis : public QObject
306 { Q_OBJECT
307 public:
308 public slots:
309 void delete_QCPAxis(QCPAxis* obj) { delete obj; }
310 void applyDefaultAntialiasingHint(QCPAxis* theWrappedObject, QCPPainter* painter) const;
311 bool autoSubTicks(QCPAxis* theWrappedObject) const;
312 int autoTickCount(QCPAxis* theWrappedObject) const;
313 bool autoTickLabels(QCPAxis* theWrappedObject) const;
314 bool autoTickStep(QCPAxis* theWrappedObject) const;
315 bool autoTicks(QCPAxis* theWrappedObject) const;
316 QCPAxisRect* axisRect(QCPAxis* theWrappedObject) const;
317 double baseLog(QCPAxis* theWrappedObject, double value) const;
318 QPen basePen(QCPAxis* theWrappedObject) const;
319 double basePow(QCPAxis* theWrappedObject, double value) const;
320 int calculateAutoSubTickCount(QCPAxis* theWrappedObject, double tickStep) const;
321 int calculateMargin(QCPAxis* theWrappedObject);
322 double coordToPixel(QCPAxis* theWrappedObject, double value) const;
323 QString dateTimeFormat(QCPAxis* theWrappedObject) const;
324 Qt::TimeSpec dateTimeSpec(QCPAxis* theWrappedObject) const;
325 void deselectEvent(QCPAxis* theWrappedObject, bool* selectionStateChanged);
326 void draw(QCPAxis* theWrappedObject, QCPPainter* painter);
327 void generateAutoTicks(QCPAxis* theWrappedObject);
328 QPen getBasePen(QCPAxis* theWrappedObject) const;
329 QColor getLabelColor(QCPAxis* theWrappedObject) const;
330 QFont getLabelFont(QCPAxis* theWrappedObject) const;
331 QPen getSubTickPen(QCPAxis* theWrappedObject) const;
332 QColor getTickLabelColor(QCPAxis* theWrappedObject) const;
333 QFont getTickLabelFont(QCPAxis* theWrappedObject) const;
334 QPen getTickPen(QCPAxis* theWrappedObject) const;
335 QList<QCPGraph* > graphs(QCPAxis* theWrappedObject) const;
336 QList<QCPAbstractItem* > items(QCPAxis* theWrappedObject) const;
337 QString label(QCPAxis* theWrappedObject) const;
338 QColor labelColor(QCPAxis* theWrappedObject) const;
339 QFont labelFont(QCPAxis* theWrappedObject) const;
340 int labelPadding(QCPAxis* theWrappedObject) const;
341 void moveRange(QCPAxis* theWrappedObject, double diff);
342 QString numberFormat(QCPAxis* theWrappedObject) const;
343 int numberPrecision(QCPAxis* theWrappedObject) const;
344 int offset(QCPAxis* theWrappedObject) const;
345 Qt::Orientation orientation(QCPAxis* theWrappedObject) const;
346 int padding(QCPAxis* theWrappedObject) const;
347 double pixelToCoord(QCPAxis* theWrappedObject, double value) const;
348 bool rangeReversed(QCPAxis* theWrappedObject) const;
349 void rescale(QCPAxis* theWrappedObject, bool onlyVisiblePlottables = false);
350 double scaleLogBase(QCPAxis* theWrappedObject) const;
351 void scaleRange(QCPAxis* theWrappedObject, double factor, double center);
352 void selectEvent(QCPAxis* theWrappedObject, QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged);
353 double selectTest(QCPAxis* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details = 0) const;
354 QPen selectedBasePen(QCPAxis* theWrappedObject) const;
355 QColor selectedLabelColor(QCPAxis* theWrappedObject) const;
356 QFont selectedLabelFont(QCPAxis* theWrappedObject) const;
357 QPen selectedSubTickPen(QCPAxis* theWrappedObject) const;
358 QColor selectedTickLabelColor(QCPAxis* theWrappedObject) const;
359 QFont selectedTickLabelFont(QCPAxis* theWrappedObject) const;
360 QPen selectedTickPen(QCPAxis* theWrappedObject) const;
361 void setAutoSubTicks(QCPAxis* theWrappedObject, bool on);
362 void setAutoTickCount(QCPAxis* theWrappedObject, int approximateCount);
363 void setAutoTickLabels(QCPAxis* theWrappedObject, bool on);
364 void setAutoTickStep(QCPAxis* theWrappedObject, bool on);
365 void setAutoTicks(QCPAxis* theWrappedObject, bool on);
366 void setBasePen(QCPAxis* theWrappedObject, const QPen& pen);
367 void setDateTimeFormat(QCPAxis* theWrappedObject, const QString& format);
368 void setDateTimeSpec(QCPAxis* theWrappedObject, const Qt::TimeSpec& timeSpec);
369 void setLabel(QCPAxis* theWrappedObject, const QString& str);
370 void setLabelColor(QCPAxis* theWrappedObject, const QColor& color);
371 void setLabelFont(QCPAxis* theWrappedObject, const QFont& font);
372 void setLabelPadding(QCPAxis* theWrappedObject, int padding);
373 void setNumberFormat(QCPAxis* theWrappedObject, const QString& formatCode);
374 void setNumberPrecision(QCPAxis* theWrappedObject, int precision);
375 void setOffset(QCPAxis* theWrappedObject, int offset);
376 void setPadding(QCPAxis* theWrappedObject, int padding);
377 void setRange(QCPAxis* theWrappedObject, double lower, double upper);
378 void setRange(QCPAxis* theWrappedObject, double position, double size, Qt::AlignmentFlag alignment);
379 void setRangeLower(QCPAxis* theWrappedObject, double lower);
380 void setRangeReversed(QCPAxis* theWrappedObject, bool reversed);
381 void setRangeUpper(QCPAxis* theWrappedObject, double upper);
382 void setScaleLogBase(QCPAxis* theWrappedObject, double base);
383 void setScaleRatio(QCPAxis* theWrappedObject, const QCPAxis* otherAxis, double ratio = 1.0);
384 void setSelectedBasePen(QCPAxis* theWrappedObject, const QPen& pen);
385 void setSelectedLabelColor(QCPAxis* theWrappedObject, const QColor& color);
386 void setSelectedLabelFont(QCPAxis* theWrappedObject, const QFont& font);
387 void setSelectedSubTickPen(QCPAxis* theWrappedObject, const QPen& pen);
388 void setSelectedTickLabelColor(QCPAxis* theWrappedObject, const QColor& color);
389 void setSelectedTickLabelFont(QCPAxis* theWrappedObject, const QFont& font);
390 void setSelectedTickPen(QCPAxis* theWrappedObject, const QPen& pen);
391 void setSubTickCount(QCPAxis* theWrappedObject, int count);
392 void setSubTickLength(QCPAxis* theWrappedObject, int inside, int outside = 0);
393 void setSubTickLengthIn(QCPAxis* theWrappedObject, int inside);
394 void setSubTickLengthOut(QCPAxis* theWrappedObject, int outside);
395 void setSubTickPen(QCPAxis* theWrappedObject, const QPen& pen);
396 void setTickLabelColor(QCPAxis* theWrappedObject, const QColor& color);
397 void setTickLabelFont(QCPAxis* theWrappedObject, const QFont& font);
398 void setTickLabelPadding(QCPAxis* theWrappedObject, int padding);
399 void setTickLabelRotation(QCPAxis* theWrappedObject, double degrees);
400 void setTickLabels(QCPAxis* theWrappedObject, bool show);
401 void setTickLength(QCPAxis* theWrappedObject, int inside, int outside = 0);
402 void setTickLengthIn(QCPAxis* theWrappedObject, int inside);
403 void setTickLengthOut(QCPAxis* theWrappedObject, int outside);
404 void setTickPen(QCPAxis* theWrappedObject, const QPen& pen);
405 void setTickStep(QCPAxis* theWrappedObject, double step);
406 void setTickVector(QCPAxis* theWrappedObject, const QVector<double >& vec);
407 void setTickVectorLabels(QCPAxis* theWrappedObject, const QVector<QString >& vec);
408 void setTicks(QCPAxis* theWrappedObject, bool show);
409 void setupTickVectors(QCPAxis* theWrappedObject);
410 int subTickCount(QCPAxis* theWrappedObject) const;
411 int subTickLengthIn(QCPAxis* theWrappedObject) const;
412 int subTickLengthOut(QCPAxis* theWrappedObject) const;
413 QPen subTickPen(QCPAxis* theWrappedObject) const;
414 QColor tickLabelColor(QCPAxis* theWrappedObject) const;
415 QFont tickLabelFont(QCPAxis* theWrappedObject) const;
416 int tickLabelPadding(QCPAxis* theWrappedObject) const;
417 double tickLabelRotation(QCPAxis* theWrappedObject) const;
418 bool tickLabels(QCPAxis* theWrappedObject) const;
419 int tickLengthIn(QCPAxis* theWrappedObject) const;
420 int tickLengthOut(QCPAxis* theWrappedObject) const;
421 QPen tickPen(QCPAxis* theWrappedObject) const;
422 double tickStep(QCPAxis* theWrappedObject) const;
423 QVector<double > tickVector(QCPAxis* theWrappedObject) const;
424 QVector<QString > tickVectorLabels(QCPAxis* theWrappedObject) const;
425 bool ticks(QCPAxis* theWrappedObject) const;
426 void visibleTickBounds(QCPAxis* theWrappedObject, int& lowIndex, int& highIndex) const;
427 };
428
429
430
431
432
433 class PythonQtShell_QCPAxisRect : public QCPAxisRect
434 {
435 public:
436 PythonQtShell_QCPAxisRect(QCustomPlot* parentPlot, bool setupDefaultAxes = true):QCPAxisRect(parentPlot, setupDefaultAxes),_wrapper(NULL) { };
437
438 ~PythonQtShell_QCPAxisRect();
439
440 virtual void applyDefaultAntialiasingHint(QCPPainter* painter) const;
441 virtual void childEvent(QChildEvent* arg__1);
442 virtual QRect clipRect() const;
443 virtual void customEvent(QEvent* arg__1);
444 virtual void deselectEvent(bool* selectionStateChanged);
445 virtual void draw(QCPPainter* painter);
446 virtual QList<QCPLayoutElement* > elements(bool recursive) const;
447 virtual bool event(QEvent* arg__1);
448 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
449 virtual QSize maximumSizeHint() const;
450 virtual QSize minimumSizeHint() const;
451 virtual void mouseDoubleClickEvent(QMouseEvent* event);
452 virtual void mouseMoveEvent(QMouseEvent* event);
453 virtual void mousePressEvent(QMouseEvent* event);
454 virtual void mouseReleaseEvent(QMouseEvent* event);
455 virtual void parentPlotInitialized(QCustomPlot* parentPlot);
456 virtual void selectEvent(QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged);
457 virtual double selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const;
458 virtual void timerEvent(QTimerEvent* arg__1);
459 virtual void wheelEvent(QWheelEvent* event);
460
461 PythonQtInstanceWrapper* _wrapper;
462 };
463
464 class PythonQtPublicPromoter_QCPAxisRect : public QCPAxisRect
465 { public:
466 inline void promoted_applyDefaultAntialiasingHint(QCPPainter* painter) const { QCPAxisRect::applyDefaultAntialiasingHint(painter); }
467 inline void promoted_draw(QCPPainter* painter) { QCPAxisRect::draw(painter); }
468 inline void promoted_drawBackground(QCPPainter* painter) { QCPAxisRect::drawBackground(painter); }
469 inline QList<QCPLayoutElement* > promoted_elements(bool recursive) const { return QCPAxisRect::elements(recursive); }
470 inline void promoted_mouseMoveEvent(QMouseEvent* event) { QCPAxisRect::mouseMoveEvent(event); }
471 inline void promoted_mousePressEvent(QMouseEvent* event) { QCPAxisRect::mousePressEvent(event); }
472 inline void promoted_mouseReleaseEvent(QMouseEvent* event) { QCPAxisRect::mouseReleaseEvent(event); }
473 inline void promoted_wheelEvent(QWheelEvent* event) { QCPAxisRect::wheelEvent(event); }
474 };
475
476 class PythonQtWrapper_QCPAxisRect : public QObject
477 { Q_OBJECT
478 public:
479 public slots:
480 QCPAxisRect* new_QCPAxisRect(QCustomPlot* parentPlot, bool setupDefaultAxes = true);
481 void delete_QCPAxisRect(QCPAxisRect* obj) { delete obj; }
482 void applyDefaultAntialiasingHint(QCPAxisRect* theWrappedObject, QCPPainter* painter) const;
483 QList<QCPAxis* > axes(QCPAxisRect* theWrappedObject) const;
484 QPixmap background(QCPAxisRect* theWrappedObject) const;
485 bool backgroundScaled(QCPAxisRect* theWrappedObject) const;
486 Qt::AspectRatioMode backgroundScaledMode(QCPAxisRect* theWrappedObject) const;
487 int bottom(QCPAxisRect* theWrappedObject) const;
488 QPoint bottomLeft(QCPAxisRect* theWrappedObject) const;
489 QPoint bottomRight(QCPAxisRect* theWrappedObject) const;
490 QPoint center(QCPAxisRect* theWrappedObject) const;
491 void draw(QCPAxisRect* theWrappedObject, QCPPainter* painter);
492 void drawBackground(QCPAxisRect* theWrappedObject, QCPPainter* painter);
493 QList<QCPLayoutElement* > elements(QCPAxisRect* theWrappedObject, bool recursive) const;
494 QList<QCPGraph* > graphs(QCPAxisRect* theWrappedObject) const;
495 int height(QCPAxisRect* theWrappedObject) const;
496 QList<QCPAbstractItem* > items(QCPAxisRect* theWrappedObject) const;
497 int left(QCPAxisRect* theWrappedObject) const;
498 void mouseMoveEvent(QCPAxisRect* theWrappedObject, QMouseEvent* event);
499 void mousePressEvent(QCPAxisRect* theWrappedObject, QMouseEvent* event);
500 void mouseReleaseEvent(QCPAxisRect* theWrappedObject, QMouseEvent* event);
501 Qt::Orientations rangeDrag(QCPAxisRect* theWrappedObject) const;
502 QCPAxis* rangeDragAxis(QCPAxisRect* theWrappedObject, Qt::Orientation orientation);
503 Qt::Orientations rangeZoom(QCPAxisRect* theWrappedObject) const;
504 QCPAxis* rangeZoomAxis(QCPAxisRect* theWrappedObject, Qt::Orientation orientation);
505 double rangeZoomFactor(QCPAxisRect* theWrappedObject, Qt::Orientation orientation);
506 bool removeAxis(QCPAxisRect* theWrappedObject, QCPAxis* axis);
507 int right(QCPAxisRect* theWrappedObject) const;
508 void setBackground(QCPAxisRect* theWrappedObject, const QBrush& brush);
509 void setBackground(QCPAxisRect* theWrappedObject, const QPixmap& pm);
510 void setBackground(QCPAxisRect* theWrappedObject, const QPixmap& pm, bool scaled, Qt::AspectRatioMode mode = Qt::KeepAspectRatioByExpanding);
511 void setBackgroundScaled(QCPAxisRect* theWrappedObject, bool scaled);
512 void setBackgroundScaledMode(QCPAxisRect* theWrappedObject, Qt::AspectRatioMode mode);
513 void setRangeDrag(QCPAxisRect* theWrappedObject, Qt::Orientations orientations);
514 void setRangeDragAxes(QCPAxisRect* theWrappedObject, QCPAxis* horizontal, QCPAxis* vertical);
515 void setRangeZoom(QCPAxisRect* theWrappedObject, Qt::Orientations orientations);
516 void setRangeZoomAxes(QCPAxisRect* theWrappedObject, QCPAxis* horizontal, QCPAxis* vertical);
517 void setRangeZoomFactor(QCPAxisRect* theWrappedObject, double factor);
518 void setRangeZoomFactor(QCPAxisRect* theWrappedObject, double horizontalFactor, double verticalFactor);
519 void setupFullAxesBox(QCPAxisRect* theWrappedObject, bool connectRanges = false);
520 QSize size(QCPAxisRect* theWrappedObject) const;
521 int top(QCPAxisRect* theWrappedObject) const;
522 QPoint topLeft(QCPAxisRect* theWrappedObject) const;
523 QPoint topRight(QCPAxisRect* theWrappedObject) const;
524 void wheelEvent(QCPAxisRect* theWrappedObject, QWheelEvent* event);
525 int width(QCPAxisRect* theWrappedObject) const;
526 };
527
528
529
530
531
532 class PythonQtShell_QCPBars : public QCPBars
533 {
534 public:
535 PythonQtShell_QCPBars(QCPAxis* keyAxis, QCPAxis* valueAxis):QCPBars(keyAxis, valueAxis),_wrapper(NULL) { };
536
537 ~PythonQtShell_QCPBars();
538
539 virtual void clearData();
540 virtual void draw(QCPPainter* painter);
541 virtual void drawLegendIcon(QCPPainter* painter, const QRectF& rect) const;
542 virtual double selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const;
543
544 PythonQtInstanceWrapper* _wrapper;
545 };
546
547 class PythonQtPublicPromoter_QCPBars : public QCPBars
548 { public:
549 inline void promoted_clearData() { QCPBars::clearData(); }
550 static inline void promoted_connectBars(QCPBars* lower, QCPBars* upper) { QCPBars::connectBars(lower, upper); }
551 inline void promoted_draw(QCPPainter* painter) { QCPBars::draw(painter); }
552 inline void promoted_drawLegendIcon(QCPPainter* painter, const QRectF& rect) const { QCPBars::drawLegendIcon(painter, rect); }
553 inline QPolygonF promoted_getBarPolygon(double key, double value) const { return QCPBars::getBarPolygon(key, value); }
554 inline void promoted_getPixelWidth(double key, double& lower, double& upper) const { QCPBars::getPixelWidth(key, lower, upper); }
555 inline double promoted_getStackedBaseValue(double key, bool positive) const { return QCPBars::getStackedBaseValue(key, positive); }
556 inline double promoted_selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const { return QCPBars::selectTest(pos, onlySelectable, details); }
557 };
558
559 class PythonQtWrapper_QCPBars : public QObject
560 { Q_OBJECT
561 public:
562 public slots:
563 QCPBars* new_QCPBars(QCPAxis* keyAxis, QCPAxis* valueAxis);
564 void delete_QCPBars(QCPBars* obj) { delete obj; }
565 void addData(QCPBars* theWrappedObject, const QVector<double >& keys, const QVector<double >& values);
566 void addData(QCPBars* theWrappedObject, double key, double value);
567 QCPBars* barAbove(QCPBars* theWrappedObject) const;
568 QCPBars* barBelow(QCPBars* theWrappedObject) const;
569 double baseValue(QCPBars* theWrappedObject) const;
570 void clearData(QCPBars* theWrappedObject);
571 void static_QCPBars_connectBars(QCPBars* lower, QCPBars* upper);
572 void draw(QCPBars* theWrappedObject, QCPPainter* painter);
573 void drawLegendIcon(QCPBars* theWrappedObject, QCPPainter* painter, const QRectF& rect) const;
574 QPolygonF getBarPolygon(QCPBars* theWrappedObject, double key, double value) const;
575 void getPixelWidth(QCPBars* theWrappedObject, double key, double& lower, double& upper) const;
576 double getStackedBaseValue(QCPBars* theWrappedObject, double key, bool positive) const;
577 void moveAbove(QCPBars* theWrappedObject, QCPBars* bars);
578 void moveBelow(QCPBars* theWrappedObject, QCPBars* bars);
579 void removeData(QCPBars* theWrappedObject, double fromKey, double toKey);
580 void removeData(QCPBars* theWrappedObject, double key);
581 void removeDataAfter(QCPBars* theWrappedObject, double key);
582 void removeDataBefore(QCPBars* theWrappedObject, double key);
583 double selectTest(QCPBars* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details = 0) const;
584 void setBaseValue(QCPBars* theWrappedObject, double baseValue);
585 void setData(QCPBars* theWrappedObject, const QVector<double >& key, const QVector<double >& value);
586 void setWidth(QCPBars* theWrappedObject, double width);
587 double width(QCPBars* theWrappedObject) const;
588 };
589
590
591
592
593
594 class PythonQtShell_QCPColorMap : public QCPColorMap
595 {
596 public:
597 PythonQtShell_QCPColorMap(QCPAxis* keyAxis, QCPAxis* valueAxis):QCPColorMap(keyAxis, valueAxis),_wrapper(NULL) { };
598
599 ~PythonQtShell_QCPColorMap();
600
601 virtual void clearData();
602 virtual void draw(QCPPainter* painter);
603 virtual void drawLegendIcon(QCPPainter* painter, const QRectF& rect) const;
604 virtual double selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const;
605 virtual void updateMapImage();
606
607 PythonQtInstanceWrapper* _wrapper;
608 };
609
610 class PythonQtPublicPromoter_QCPColorMap : public QCPColorMap
611 { public:
612 inline void promoted_clearData() { QCPColorMap::clearData(); }
613 inline void promoted_draw(QCPPainter* painter) { QCPColorMap::draw(painter); }
614 inline void promoted_drawLegendIcon(QCPPainter* painter, const QRectF& rect) const { QCPColorMap::drawLegendIcon(painter, rect); }
615 inline double promoted_selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const { return QCPColorMap::selectTest(pos, onlySelectable, details); }
616 inline void promoted_updateMapImage() { QCPColorMap::updateMapImage(); }
617 };
618
619 class PythonQtWrapper_QCPColorMap : public QObject
620 { Q_OBJECT
621 public:
622 public slots:
623 QCPColorMap* new_QCPColorMap(QCPAxis* keyAxis, QCPAxis* valueAxis);
624 void delete_QCPColorMap(QCPColorMap* obj) { delete obj; }
625 void clearData(QCPColorMap* theWrappedObject);
626 QCPColorScale* colorScale(QCPColorMap* theWrappedObject) const;
627 void draw(QCPColorMap* theWrappedObject, QCPPainter* painter);
628 void drawLegendIcon(QCPColorMap* theWrappedObject, QCPPainter* painter, const QRectF& rect) const;
629 bool interpolate(QCPColorMap* theWrappedObject) const;
630 void rescaleDataRange(QCPColorMap* theWrappedObject, bool recalculateDataBounds = false);
631 double selectTest(QCPColorMap* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details = 0) const;
632 void setColorScale(QCPColorMap* theWrappedObject, QCPColorScale* colorScale);
633 void setInterpolate(QCPColorMap* theWrappedObject, bool enabled);
634 void setTightBoundary(QCPColorMap* theWrappedObject, bool enabled);
635 bool tightBoundary(QCPColorMap* theWrappedObject) const;
636 void updateLegendIcon(QCPColorMap* theWrappedObject, Qt::TransformationMode transformMode = Qt::SmoothTransformation, const QSize& thumbSize = QSize(32, 18));
637 void updateMapImage(QCPColorMap* theWrappedObject);
638 };
639
640
641
642
643
644 class PythonQtShell_QCPColorScale : public QCPColorScale
645 {
646 public:
647 PythonQtShell_QCPColorScale(QCustomPlot* parentPlot):QCPColorScale(parentPlot),_wrapper(NULL) { };
648
649 ~PythonQtShell_QCPColorScale();
650
651 virtual void applyDefaultAntialiasingHint(QCPPainter* painter) const;
652 virtual void childEvent(QChildEvent* arg__1);
653 virtual QRect clipRect() const;
654 virtual void customEvent(QEvent* arg__1);
655 virtual void deselectEvent(bool* selectionStateChanged);
656 virtual void draw(QCPPainter* painter);
657 virtual QList<QCPLayoutElement* > elements(bool recursive) const;
658 virtual bool event(QEvent* arg__1);
659 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
660 virtual QSize maximumSizeHint() const;
661 virtual QSize minimumSizeHint() const;
662 virtual void mouseDoubleClickEvent(QMouseEvent* event);
663 virtual void mouseMoveEvent(QMouseEvent* event);
664 virtual void mousePressEvent(QMouseEvent* event);
665 virtual void mouseReleaseEvent(QMouseEvent* event);
666 virtual void parentPlotInitialized(QCustomPlot* parentPlot);
667 virtual void selectEvent(QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged);
668 virtual double selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const;
669 virtual void timerEvent(QTimerEvent* arg__1);
670 virtual void wheelEvent(QWheelEvent* event);
671
672 PythonQtInstanceWrapper* _wrapper;
673 };
674
675 class PythonQtPublicPromoter_QCPColorScale : public QCPColorScale
676 { public:
677 inline void promoted_applyDefaultAntialiasingHint(QCPPainter* painter) const { QCPColorScale::applyDefaultAntialiasingHint(painter); }
678 inline void promoted_mouseMoveEvent(QMouseEvent* event) { QCPColorScale::mouseMoveEvent(event); }
679 inline void promoted_mousePressEvent(QMouseEvent* event) { QCPColorScale::mousePressEvent(event); }
680 inline void promoted_mouseReleaseEvent(QMouseEvent* event) { QCPColorScale::mouseReleaseEvent(event); }
681 inline void promoted_wheelEvent(QWheelEvent* event) { QCPColorScale::wheelEvent(event); }
682 };
683
684 class PythonQtWrapper_QCPColorScale : public QObject
685 { Q_OBJECT
686 public:
687 public slots:
688 QCPColorScale* new_QCPColorScale(QCustomPlot* parentPlot);
689 void delete_QCPColorScale(QCPColorScale* obj) { delete obj; }
690 void applyDefaultAntialiasingHint(QCPColorScale* theWrappedObject, QCPPainter* painter) const;
691 QCPAxis* axis(QCPColorScale* theWrappedObject) const;
692 int barWidth(QCPColorScale* theWrappedObject) const;
693 QList<QCPColorMap* > colorMaps(QCPColorScale* theWrappedObject) const;
694 QString label(QCPColorScale* theWrappedObject) const;
695 void mouseMoveEvent(QCPColorScale* theWrappedObject, QMouseEvent* event);
696 void mousePressEvent(QCPColorScale* theWrappedObject, QMouseEvent* event);
697 void mouseReleaseEvent(QCPColorScale* theWrappedObject, QMouseEvent* event);
698 bool rangeDrag(QCPColorScale* theWrappedObject) const;
699 bool rangeZoom(QCPColorScale* theWrappedObject) const;
700 void rescaleDataRange(QCPColorScale* theWrappedObject, bool onlyVisibleMaps);
701 void setBarWidth(QCPColorScale* theWrappedObject, int width);
702 void setLabel(QCPColorScale* theWrappedObject, const QString& str);
703 void setRangeDrag(QCPColorScale* theWrappedObject, bool enabled);
704 void setRangeZoom(QCPColorScale* theWrappedObject, bool enabled);
705 void wheelEvent(QCPColorScale* theWrappedObject, QWheelEvent* event);
706 };
707
708
709
710
711
712 class PythonQtShell_QCPGraph : public QCPGraph
713 {
714 public:
715 PythonQtShell_QCPGraph(QCPAxis* keyAxis, QCPAxis* valueAxis):QCPGraph(keyAxis, valueAxis),_wrapper(NULL) { };
716
717 ~PythonQtShell_QCPGraph();
718
719 virtual void clearData();
720 virtual void draw(QCPPainter* painter);
721 virtual void drawFill(QCPPainter* painter, QVector<QPointF >* lineData) const;
722 virtual void drawImpulsePlot(QCPPainter* painter, QVector<QPointF >* lineData) const;
723 virtual void drawLegendIcon(QCPPainter* painter, const QRectF& rect) const;
724 virtual void drawLinePlot(QCPPainter* painter, QVector<QPointF >* lineData) const;
725 virtual double selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const;
726
727 PythonQtInstanceWrapper* _wrapper;
728 };
729
730 class PythonQtPublicPromoter_QCPGraph : public QCPGraph
731 { public:
732 inline void promoted_addFillBasePoints(QVector<QPointF >* lineData) const { QCPGraph::addFillBasePoints(lineData); }
733 inline void promoted_clearData() { QCPGraph::clearData(); }
734 inline void promoted_draw(QCPPainter* painter) { QCPGraph::draw(painter); }
735 inline void promoted_drawFill(QCPPainter* painter, QVector<QPointF >* lineData) const { QCPGraph::drawFill(painter, lineData); }
736 inline void promoted_drawImpulsePlot(QCPPainter* painter, QVector<QPointF >* lineData) const { QCPGraph::drawImpulsePlot(painter, lineData); }
737 inline void promoted_drawLegendIcon(QCPPainter* painter, const QRectF& rect) const { QCPGraph::drawLegendIcon(painter, rect); }
738 inline void promoted_drawLinePlot(QCPPainter* painter, QVector<QPointF >* lineData) const { QCPGraph::drawLinePlot(painter, lineData); }
739 inline int promoted_findIndexAboveX(const QVector<QPointF >* data, double x) const { return QCPGraph::findIndexAboveX(data, x); }
740 inline int promoted_findIndexAboveY(const QVector<QPointF >* data, double y) const { return QCPGraph::findIndexAboveY(data, y); }
741 inline int promoted_findIndexBelowX(const QVector<QPointF >* data, double x) const { return QCPGraph::findIndexBelowX(data, x); }
742 inline int promoted_findIndexBelowY(const QVector<QPointF >* data, double y) const { return QCPGraph::findIndexBelowY(data, y); }
743 inline const QPolygonF promoted_getChannelFillPolygon(const QVector<QPointF >* lineData) const { return QCPGraph::getChannelFillPolygon(lineData); }
744 inline QPointF promoted_lowerFillBasePoint(double lowerKey) const { return QCPGraph::lowerFillBasePoint(lowerKey); }
745 inline double promoted_pointDistance(const QPointF& pixelPoint) const { return QCPGraph::pointDistance(pixelPoint); }
746 inline void promoted_removeFillBasePoints(QVector<QPointF >* lineData) const { QCPGraph::removeFillBasePoints(lineData); }
747 inline double promoted_selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const { return QCPGraph::selectTest(pos, onlySelectable, details); }
748 inline QPointF promoted_upperFillBasePoint(double upperKey) const { return QCPGraph::upperFillBasePoint(upperKey); }
749 };
750
751 class PythonQtWrapper_QCPGraph : public QObject
752 { Q_OBJECT
753 public:
754 public slots:
755 QCPGraph* new_QCPGraph(QCPAxis* keyAxis, QCPAxis* valueAxis);
756 void delete_QCPGraph(QCPGraph* obj) { delete obj; }
757 bool adaptiveSampling(QCPGraph* theWrappedObject) const;
758 void addData(QCPGraph* theWrappedObject, const QVector<double >& keys, const QVector<double >& values);
759 void addData(QCPGraph* theWrappedObject, double key, double value);
760 void addFillBasePoints(QCPGraph* theWrappedObject, QVector<QPointF >* lineData) const;
761 QCPGraph* channelFillGraph(QCPGraph* theWrappedObject) const;
762 void clearData(QCPGraph* theWrappedObject);
763 void draw(QCPGraph* theWrappedObject, QCPPainter* painter);
764 void drawFill(QCPGraph* theWrappedObject, QCPPainter* painter, QVector<QPointF >* lineData) const;
765 void drawImpulsePlot(QCPGraph* theWrappedObject, QCPPainter* painter, QVector<QPointF >* lineData) const;
766 void drawLegendIcon(QCPGraph* theWrappedObject, QCPPainter* painter, const QRectF& rect) const;
767 void drawLinePlot(QCPGraph* theWrappedObject, QCPPainter* painter, QVector<QPointF >* lineData) const;
768 double errorBarSize(QCPGraph* theWrappedObject) const;
769 bool errorBarSkipSymbol(QCPGraph* theWrappedObject) const;
770 QPen errorPen(QCPGraph* theWrappedObject) const;
771 int findIndexAboveX(QCPGraph* theWrappedObject, const QVector<QPointF >* data, double x) const;
772 int findIndexAboveY(QCPGraph* theWrappedObject, const QVector<QPointF >* data, double y) const;
773 int findIndexBelowX(QCPGraph* theWrappedObject, const QVector<QPointF >* data, double x) const;
774 int findIndexBelowY(QCPGraph* theWrappedObject, const QVector<QPointF >* data, double y) const;
775 const QPolygonF getChannelFillPolygon(QCPGraph* theWrappedObject, const QVector<QPointF >* lineData) const;
776 QPointF lowerFillBasePoint(QCPGraph* theWrappedObject, double lowerKey) const;
777 double pointDistance(QCPGraph* theWrappedObject, const QPointF& pixelPoint) const;
778 void removeData(QCPGraph* theWrappedObject, double fromKey, double toKey);
779 void removeData(QCPGraph* theWrappedObject, double key);
780 void removeDataAfter(QCPGraph* theWrappedObject, double key);
781 void removeDataBefore(QCPGraph* theWrappedObject, double key);
782 void removeFillBasePoints(QCPGraph* theWrappedObject, QVector<QPointF >* lineData) const;
783 void rescaleAxes(QCPGraph* theWrappedObject, bool onlyEnlarge, bool includeErrorBars) const;
784 void rescaleKeyAxis(QCPGraph* theWrappedObject, bool onlyEnlarge, bool includeErrorBars) const;
785 void rescaleValueAxis(QCPGraph* theWrappedObject, bool onlyEnlarge, bool includeErrorBars) const;
786 double selectTest(QCPGraph* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details = 0) const;
787 void setAdaptiveSampling(QCPGraph* theWrappedObject, bool enabled);
788 void setChannelFillGraph(QCPGraph* theWrappedObject, QCPGraph* targetGraph);
789 void setData(QCPGraph* theWrappedObject, const QVector<double >& key, const QVector<double >& value);
790 void setDataBothError(QCPGraph* theWrappedObject, const QVector<double >& key, const QVector<double >& value, const QVector<double >& keyError, const QVector<double >& valueError);
791 void setDataBothError(QCPGraph* theWrappedObject, const QVector<double >& key, const QVector<double >& value, const QVector<double >& keyErrorMinus, const QVector<double >& keyErrorPlus, const QVector<double >& valueErrorMinus, const QVector<double >& valueErrorPlus);
792 void setDataKeyError(QCPGraph* theWrappedObject, const QVector<double >& key, const QVector<double >& value, const QVector<double >& keyError);
793 void setDataKeyError(QCPGraph* theWrappedObject, const QVector<double >& key, const QVector<double >& value, const QVector<double >& keyErrorMinus, const QVector<double >& keyErrorPlus);
794 void setDataValueError(QCPGraph* theWrappedObject, const QVector<double >& key, const QVector<double >& value, const QVector<double >& valueError);
795 void setDataValueError(QCPGraph* theWrappedObject, const QVector<double >& key, const QVector<double >& value, const QVector<double >& valueErrorMinus, const QVector<double >& valueErrorPlus);
796 void setErrorBarSize(QCPGraph* theWrappedObject, double size);
797 void setErrorBarSkipSymbol(QCPGraph* theWrappedObject, bool enabled);
798 void setErrorPen(QCPGraph* theWrappedObject, const QPen& pen);
799 void setUseFastVectors(QCPGraph* theWrappedObject, bool useFastVectors);
800 QPointF upperFillBasePoint(QCPGraph* theWrappedObject, double upperKey) const;
801 bool useFastVectors(QCPGraph* theWrappedObject) const;
802 };
803
804
805
806
807
808 class PythonQtShell_QCPItemPosition : public QCPItemPosition
809 {
810 public:
811 PythonQtShell_QCPItemPosition(QCustomPlot* parentPlot, QCPAbstractItem* parentItem, const QString name):QCPItemPosition(parentPlot, parentItem, name),_wrapper(NULL) { };
812
813 ~PythonQtShell_QCPItemPosition();
814
815 virtual QPointF pixelPoint() const;
816 virtual QCPItemPosition* toQCPItemPosition();
817
818 PythonQtInstanceWrapper* _wrapper;
819 };
820
821 class PythonQtPublicPromoter_QCPItemPosition : public QCPItemPosition
822 { public:
823 inline QPointF promoted_pixelPoint() const { return QCPItemPosition::pixelPoint(); }
824 inline QCPItemPosition* promoted_toQCPItemPosition() { return QCPItemPosition::toQCPItemPosition(); }
825 };
826
827 class PythonQtWrapper_QCPItemPosition : public QObject
828 { Q_OBJECT
829 public:
830 public slots:
831 QCPItemPosition* new_QCPItemPosition(QCustomPlot* parentPlot, QCPAbstractItem* parentItem, const QString name);
832 void delete_QCPItemPosition(QCPItemPosition* obj) { delete obj; }
833 QCPAxisRect* axisRect(QCPItemPosition* theWrappedObject) const;
834 QPointF coords(QCPItemPosition* theWrappedObject) const;
835 double key(QCPItemPosition* theWrappedObject) const;
836 QCPAxis* keyAxis(QCPItemPosition* theWrappedObject) const;
837 QPointF pixelPoint(QCPItemPosition* theWrappedObject) const;
838 void setAxes(QCPItemPosition* theWrappedObject, QCPAxis* keyAxis, QCPAxis* valueAxis);
839 void setAxisRect(QCPItemPosition* theWrappedObject, QCPAxisRect* axisRect);
840 void setCoords(QCPItemPosition* theWrappedObject, const QPointF& coords);
841 void setCoords(QCPItemPosition* theWrappedObject, double key, double value);
842 void setPixelPoint(QCPItemPosition* theWrappedObject, const QPointF& pixelPoint);
843 QCPItemPosition* toQCPItemPosition(QCPItemPosition* theWrappedObject);
844 double value(QCPItemPosition* theWrappedObject) const;
845 QCPAxis* valueAxis(QCPItemPosition* theWrappedObject) const;
846 };
847
848
849
850
851
852 class PythonQtShell_QCPLayer : public QCPLayer
853 {
854 public:
855 PythonQtShell_QCPLayer(QCustomPlot* parentPlot, const QString& layerName):QCPLayer(parentPlot, layerName),_wrapper(NULL) { };
856
857 ~PythonQtShell_QCPLayer();
858
859 virtual void childEvent(QChildEvent* arg__1);
860 virtual void customEvent(QEvent* arg__1);
861 virtual bool event(QEvent* arg__1);
862 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
863 virtual void timerEvent(QTimerEvent* arg__1);
864
865 PythonQtInstanceWrapper* _wrapper;
866 };
867
868 class PythonQtPublicPromoter_QCPLayer : public QCPLayer
869 { public:
870 inline void promoted_addChild(QCPLayerable* layerable, bool prepend) { QCPLayer::addChild(layerable, prepend); }
871 inline void promoted_removeChild(QCPLayerable* layerable) { QCPLayer::removeChild(layerable); }
872 };
873
874 class PythonQtWrapper_QCPLayer : public QObject
875 { Q_OBJECT
876 public:
877 public slots:
878 QCPLayer* new_QCPLayer(QCustomPlot* parentPlot, const QString& layerName);
879 void delete_QCPLayer(QCPLayer* obj) { delete obj; }
880 void addChild(QCPLayer* theWrappedObject, QCPLayerable* layerable, bool prepend);
881 QList<QCPLayerable* > children(QCPLayer* theWrappedObject) const;
882 int index(QCPLayer* theWrappedObject) const;
883 QString name(QCPLayer* theWrappedObject) const;
884 QCustomPlot* parentPlot(QCPLayer* theWrappedObject) const;
885 void removeChild(QCPLayer* theWrappedObject, QCPLayerable* layerable);
886 void setVisible(QCPLayer* theWrappedObject, bool visible);
887 bool visible(QCPLayer* theWrappedObject) const;
888 };
889
890
891
892
893
894 class PythonQtShell_QCPLayerable : public QCPLayerable
895 {
896 public:
897 PythonQtShell_QCPLayerable(QCustomPlot* plot, QString targetLayer = QString(), QCPLayerable* parentLayerable = 0):QCPLayerable(plot, targetLayer, parentLayerable),_wrapper(NULL) { };
898
899 ~PythonQtShell_QCPLayerable();
900
901 virtual void applyDefaultAntialiasingHint(QCPPainter* painter) const;
902 virtual void childEvent(QChildEvent* arg__1);
903 virtual QRect clipRect() const;
904 virtual void customEvent(QEvent* arg__1);
905 virtual void deselectEvent(bool* selectionStateChanged);
906 virtual void draw(QCPPainter* painter);
907 virtual bool event(QEvent* arg__1);
908 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
909 virtual void parentPlotInitialized(QCustomPlot* parentPlot);
910 virtual void selectEvent(QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged);
911 virtual double selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const;
912 virtual void timerEvent(QTimerEvent* arg__1);
913
914 PythonQtInstanceWrapper* _wrapper;
915 };
916
917 class PythonQtPublicPromoter_QCPLayerable : public QCPLayerable
918 { public:
919 inline void promoted_applyDefaultAntialiasingHint(QCPPainter* painter) const { applyDefaultAntialiasingHint(painter); }
920 inline QRect promoted_clipRect() const { return QCPLayerable::clipRect(); }
921 inline void promoted_deselectEvent(bool* selectionStateChanged) { QCPLayerable::deselectEvent(selectionStateChanged); }
922 inline void promoted_draw(QCPPainter* painter) { draw(painter); }
923 inline void promoted_initializeParentPlot(QCustomPlot* parentPlot) { QCPLayerable::initializeParentPlot(parentPlot); }
924 inline bool promoted_moveToLayer(QCPLayer* layer, bool prepend) { return QCPLayerable::moveToLayer(layer, prepend); }
925 inline void promoted_parentPlotInitialized(QCustomPlot* parentPlot) { QCPLayerable::parentPlotInitialized(parentPlot); }
926 inline void promoted_selectEvent(QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged) { QCPLayerable::selectEvent(event, additive, details, selectionStateChanged); }
927 inline double promoted_selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const { return QCPLayerable::selectTest(pos, onlySelectable, details); }
928 inline void promoted_setParentLayerable(QCPLayerable* parentLayerable) { QCPLayerable::setParentLayerable(parentLayerable); }
929 };
930
931 class PythonQtWrapper_QCPLayerable : public QObject
932 { Q_OBJECT
933 public:
934 public slots:
935 QCPLayerable* new_QCPLayerable(QCustomPlot* plot, QString targetLayer = QString(), QCPLayerable* parentLayerable = 0);
936 void delete_QCPLayerable(QCPLayerable* obj) { delete obj; }
937 bool antialiased(QCPLayerable* theWrappedObject) const;
938 void applyDefaultAntialiasingHint(QCPLayerable* theWrappedObject, QCPPainter* painter) const;
939 QRect clipRect(QCPLayerable* theWrappedObject) const;
940 void deselectEvent(QCPLayerable* theWrappedObject, bool* selectionStateChanged);
941 void draw(QCPLayerable* theWrappedObject, QCPPainter* painter);
942 void initializeParentPlot(QCPLayerable* theWrappedObject, QCustomPlot* parentPlot);
943 QCPLayer* layer(QCPLayerable* theWrappedObject) const;
944 bool moveToLayer(QCPLayerable* theWrappedObject, QCPLayer* layer, bool prepend);
945 QCPLayerable* parentLayerable(QCPLayerable* theWrappedObject) const;
946 QCustomPlot* parentPlot(QCPLayerable* theWrappedObject) const;
947 void parentPlotInitialized(QCPLayerable* theWrappedObject, QCustomPlot* parentPlot);
948 bool realVisibility(QCPLayerable* theWrappedObject) const;
949 void selectEvent(QCPLayerable* theWrappedObject, QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged);
950 double selectTest(QCPLayerable* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details = 0) const;
951 void setAntialiased(QCPLayerable* theWrappedObject, bool enabled);
952 bool setLayer(QCPLayerable* theWrappedObject, QCPLayer* layer);
953 bool setLayer(QCPLayerable* theWrappedObject, const QString& layerName);
954 void setParentLayerable(QCPLayerable* theWrappedObject, QCPLayerable* parentLayerable);
955 void setVisible(QCPLayerable* theWrappedObject, bool on);
956 bool visible(QCPLayerable* theWrappedObject) const;
957 };
958
959
960
961
962
963 class PythonQtShell_QCPLayout : public QCPLayout
964 {
965 public:
966 PythonQtShell_QCPLayout():QCPLayout(),_wrapper(NULL) { };
967
968 ~PythonQtShell_QCPLayout();
969
970 virtual void applyDefaultAntialiasingHint(QCPPainter* painter) const;
971 virtual void childEvent(QChildEvent* arg__1);
972 virtual QRect clipRect() const;
973 virtual void customEvent(QEvent* arg__1);
974 virtual void deselectEvent(bool* selectionStateChanged);
975 virtual void draw(QCPPainter* painter);
976 virtual QCPLayoutElement* elementAt(int index) const;
977 virtual int elementCount() const;
978 virtual QList<QCPLayoutElement* > elements(bool recursive) const;
979 virtual bool event(QEvent* arg__1);
980 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
981 virtual QSize maximumSizeHint() const;
982 virtual QSize minimumSizeHint() const;
983 virtual void mouseDoubleClickEvent(QMouseEvent* event);
984 virtual void mouseMoveEvent(QMouseEvent* event);
985 virtual void mousePressEvent(QMouseEvent* event);
986 virtual void mouseReleaseEvent(QMouseEvent* event);
987 virtual void parentPlotInitialized(QCustomPlot* parentPlot);
988 virtual void selectEvent(QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged);
989 virtual double selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const;
990 virtual void simplify();
991 virtual bool take(QCPLayoutElement* element);
992 virtual QCPLayoutElement* takeAt(int index);
993 virtual void timerEvent(QTimerEvent* arg__1);
994 virtual void updateLayout();
995 virtual void wheelEvent(QWheelEvent* event);
996
997 PythonQtInstanceWrapper* _wrapper;
998 };
999
1000 class PythonQtPublicPromoter_QCPLayout : public QCPLayout
1001 { public:
1002 inline void promoted_adoptElement(QCPLayoutElement* el) { QCPLayout::adoptElement(el); }
1003 inline QCPLayoutElement* promoted_elementAt(int index) const { return elementAt(index); }
1004 inline int promoted_elementCount() const { return elementCount(); }
1005 inline QList<QCPLayoutElement* > promoted_elements(bool recursive) const { return QCPLayout::elements(recursive); }
1006 inline QVector<int > promoted_getSectionSizes(QVector<int > maxSizes, QVector<int > minSizes, QVector<double > stretchFactors, int totalSize) const { return QCPLayout::getSectionSizes(maxSizes, minSizes, stretchFactors, totalSize); }
1007 inline void promoted_releaseElement(QCPLayoutElement* el) { QCPLayout::releaseElement(el); }
1008 inline void promoted_simplify() { QCPLayout::simplify(); }
1009 inline void promoted_sizeConstraintsChanged() const { QCPLayout::sizeConstraintsChanged(); }
1010 inline bool promoted_take(QCPLayoutElement* element) { return take(element); }
1011 inline QCPLayoutElement* promoted_takeAt(int index) { return takeAt(index); }
1012 inline void promoted_updateLayout() { QCPLayout::updateLayout(); }
1013 };
1014
1015 class PythonQtWrapper_QCPLayout : public QObject
1016 { Q_OBJECT
1017 public:
1018 public slots:
1019 QCPLayout* new_QCPLayout();
1020 void delete_QCPLayout(QCPLayout* obj) { delete obj; }
1021 void adoptElement(QCPLayout* theWrappedObject, QCPLayoutElement* el);
1022 void clear(QCPLayout* theWrappedObject);
1023 QCPLayoutElement* elementAt(QCPLayout* theWrappedObject, int index) const;
1024 int elementCount(QCPLayout* theWrappedObject) const;
1025 QList<QCPLayoutElement* > elements(QCPLayout* theWrappedObject, bool recursive) const;
1026 QVector<int > getSectionSizes(QCPLayout* theWrappedObject, QVector<int > maxSizes, QVector<int > minSizes, QVector<double > stretchFactors, int totalSize) const;
1027 void releaseElement(QCPLayout* theWrappedObject, QCPLayoutElement* el);
1028 bool remove(QCPLayout* theWrappedObject, QCPLayoutElement* element);
1029 bool removeAt(QCPLayout* theWrappedObject, int index);
1030 void simplify(QCPLayout* theWrappedObject);
1031 void sizeConstraintsChanged(QCPLayout* theWrappedObject) const;
1032 bool take(QCPLayout* theWrappedObject, QCPLayoutElement* element);
1033 QCPLayoutElement* takeAt(QCPLayout* theWrappedObject, int index);
1034 void updateLayout(QCPLayout* theWrappedObject);
1035 };
1036
1037
1038
1039
1040
1041 class PythonQtShell_QCPLayoutElement : public QCPLayoutElement
1042 {
1043 public:
1044 PythonQtShell_QCPLayoutElement(QCustomPlot* parentPlot = 0):QCPLayoutElement(parentPlot),_wrapper(NULL) { };
1045
1046 ~PythonQtShell_QCPLayoutElement();
1047
1048 virtual void applyDefaultAntialiasingHint(QCPPainter* painter) const;
1049 virtual void childEvent(QChildEvent* arg__1);
1050 virtual QRect clipRect() const;
1051 virtual void customEvent(QEvent* arg__1);
1052 virtual void deselectEvent(bool* selectionStateChanged);
1053 virtual void draw(QCPPainter* painter);
1054 virtual QList<QCPLayoutElement* > elements(bool recursive) const;
1055 virtual bool event(QEvent* arg__1);
1056 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
1057 virtual QSize maximumSizeHint() const;
1058 virtual QSize minimumSizeHint() const;
1059 virtual void mouseDoubleClickEvent(QMouseEvent* event);
1060 virtual void mouseMoveEvent(QMouseEvent* event);
1061 virtual void mousePressEvent(QMouseEvent* event);
1062 virtual void mouseReleaseEvent(QMouseEvent* event);
1063 virtual void parentPlotInitialized(QCustomPlot* parentPlot);
1064 virtual void selectEvent(QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged);
1065 virtual double selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const;
1066 virtual void timerEvent(QTimerEvent* arg__1);
1067 virtual void wheelEvent(QWheelEvent* event);
1068
1069 PythonQtInstanceWrapper* _wrapper;
1070 };
1071
1072 class PythonQtPublicPromoter_QCPLayoutElement : public QCPLayoutElement
1073 { public:
1074 inline void promoted_applyDefaultAntialiasingHint(QCPPainter* painter) const { QCPLayoutElement::applyDefaultAntialiasingHint(painter); }
1075 inline void promoted_draw(QCPPainter* painter) { QCPLayoutElement::draw(painter); }
1076 inline QList<QCPLayoutElement* > promoted_elements(bool recursive) const { return QCPLayoutElement::elements(recursive); }
1077 inline QSize promoted_maximumSizeHint() const { return QCPLayoutElement::maximumSizeHint(); }
1078 inline QSize promoted_minimumSizeHint() const { return QCPLayoutElement::minimumSizeHint(); }
1079 inline void promoted_mouseDoubleClickEvent(QMouseEvent* event) { QCPLayoutElement::mouseDoubleClickEvent(event); }
1080 inline void promoted_mouseMoveEvent(QMouseEvent* event) { QCPLayoutElement::mouseMoveEvent(event); }
1081 inline void promoted_mousePressEvent(QMouseEvent* event) { QCPLayoutElement::mousePressEvent(event); }
1082 inline void promoted_mouseReleaseEvent(QMouseEvent* event) { QCPLayoutElement::mouseReleaseEvent(event); }
1083 inline void promoted_parentPlotInitialized(QCustomPlot* parentPlot) { QCPLayoutElement::parentPlotInitialized(parentPlot); }
1084 inline double promoted_selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const { return QCPLayoutElement::selectTest(pos, onlySelectable, details); }
1085 inline void promoted_wheelEvent(QWheelEvent* event) { QCPLayoutElement::wheelEvent(event); }
1086 };
1087
1088 class PythonQtWrapper_QCPLayoutElement : public QObject
1089 { Q_OBJECT
1090 public:
1091 public slots:
1092 QCPLayoutElement* new_QCPLayoutElement(QCustomPlot* parentPlot = 0);
1093 void delete_QCPLayoutElement(QCPLayoutElement* obj) { delete obj; }
1094 void applyDefaultAntialiasingHint(QCPLayoutElement* theWrappedObject, QCPPainter* painter) const;
1095 void draw(QCPLayoutElement* theWrappedObject, QCPPainter* painter);
1096 QList<QCPLayoutElement* > elements(QCPLayoutElement* theWrappedObject, bool recursive) const;
1097 QCPLayout* layout(QCPLayoutElement* theWrappedObject) const;
1098 QMargins margins(QCPLayoutElement* theWrappedObject) const;
1099 QSize maximumSize(QCPLayoutElement* theWrappedObject) const;
1100 QSize maximumSizeHint(QCPLayoutElement* theWrappedObject) const;
1101 QMargins minimumMargins(QCPLayoutElement* theWrappedObject) const;
1102 QSize minimumSize(QCPLayoutElement* theWrappedObject) const;
1103 QSize minimumSizeHint(QCPLayoutElement* theWrappedObject) const;
1104 void mouseDoubleClickEvent(QCPLayoutElement* theWrappedObject, QMouseEvent* event);
1105 void mouseMoveEvent(QCPLayoutElement* theWrappedObject, QMouseEvent* event);
1106 void mousePressEvent(QCPLayoutElement* theWrappedObject, QMouseEvent* event);
1107 void mouseReleaseEvent(QCPLayoutElement* theWrappedObject, QMouseEvent* event);
1108 QRect outerRect(QCPLayoutElement* theWrappedObject) const;
1109 void parentPlotInitialized(QCPLayoutElement* theWrappedObject, QCustomPlot* parentPlot);
1110 QRect rect(QCPLayoutElement* theWrappedObject) const;
1111 double selectTest(QCPLayoutElement* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details = 0) const;
1112 void setMargins(QCPLayoutElement* theWrappedObject, const QMargins& margins);
1113 void setMaximumSize(QCPLayoutElement* theWrappedObject, const QSize& size);
1114 void setMaximumSize(QCPLayoutElement* theWrappedObject, int width, int height);
1115 void setMinimumMargins(QCPLayoutElement* theWrappedObject, const QMargins& margins);
1116 void setMinimumSize(QCPLayoutElement* theWrappedObject, const QSize& size);
1117 void setMinimumSize(QCPLayoutElement* theWrappedObject, int width, int height);
1118 void setOuterRect(QCPLayoutElement* theWrappedObject, const QRect& rect);
1119 void wheelEvent(QCPLayoutElement* theWrappedObject, QWheelEvent* event);
1120 };
1121
1122
1123
1124
1125
1126 class PythonQtShell_QCPLegend : public QCPLegend
1127 {
1128 public:
1129 PythonQtShell_QCPLegend():QCPLegend(),_wrapper(NULL) { };
1130
1131 ~PythonQtShell_QCPLegend();
1132
1133 virtual void applyDefaultAntialiasingHint(QCPPainter* painter) const;
1134 virtual void deselectEvent(bool* selectionStateChanged);
1135 virtual void draw(QCPPainter* painter);
1136 virtual void parentPlotInitialized(QCustomPlot* parentPlot);
1137 virtual void selectEvent(QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged);
1138 virtual double selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const;
1139
1140 PythonQtInstanceWrapper* _wrapper;
1141 };
1142
1143 class PythonQtPublicPromoter_QCPLegend : public QCPLegend
1144 { public:
1145 inline void promoted_applyDefaultAntialiasingHint(QCPPainter* painter) const { QCPLegend::applyDefaultAntialiasingHint(painter); }
1146 inline void promoted_deselectEvent(bool* selectionStateChanged) { QCPLegend::deselectEvent(selectionStateChanged); }
1147 inline void promoted_draw(QCPPainter* painter) { QCPLegend::draw(painter); }
1148 inline QPen promoted_getBorderPen() const { return QCPLegend::getBorderPen(); }
1149 inline QBrush promoted_getBrush() const { return QCPLegend::getBrush(); }
1150 inline void promoted_parentPlotInitialized(QCustomPlot* parentPlot) { QCPLegend::parentPlotInitialized(parentPlot); }
1151 inline void promoted_selectEvent(QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged) { QCPLegend::selectEvent(event, additive, details, selectionStateChanged); }
1152 inline double promoted_selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const { return QCPLegend::selectTest(pos, onlySelectable, details); }
1153 };
1154
1155 class PythonQtWrapper_QCPLegend : public QObject
1156 { Q_OBJECT
1157 public:
1158 public slots:
1159 QCPLegend* new_QCPLegend();
1160 void delete_QCPLegend(QCPLegend* obj) { delete obj; }
1161 bool addItem(QCPLegend* theWrappedObject, QCPAbstractLegendItem* item);
1162 void applyDefaultAntialiasingHint(QCPLegend* theWrappedObject, QCPPainter* painter) const;
1163 QPen borderPen(QCPLegend* theWrappedObject) const;
1164 QBrush brush(QCPLegend* theWrappedObject) const;
1165 void clearItems(QCPLegend* theWrappedObject);
1166 void deselectEvent(QCPLegend* theWrappedObject, bool* selectionStateChanged);
1167 void draw(QCPLegend* theWrappedObject, QCPPainter* painter);
1168 QFont font(QCPLegend* theWrappedObject) const;
1169 QPen getBorderPen(QCPLegend* theWrappedObject) const;
1170 QBrush getBrush(QCPLegend* theWrappedObject) const;
1171 bool hasItem(QCPLegend* theWrappedObject, QCPAbstractLegendItem* item) const;
1172 QPen iconBorderPen(QCPLegend* theWrappedObject) const;
1173 QSize iconSize(QCPLegend* theWrappedObject) const;
1174 int iconTextPadding(QCPLegend* theWrappedObject) const;
1175 QCPAbstractLegendItem* item(QCPLegend* theWrappedObject, int index) const;
1176 int itemCount(QCPLegend* theWrappedObject) const;
1177 void parentPlotInitialized(QCPLegend* theWrappedObject, QCustomPlot* parentPlot);
1178 bool removeItem(QCPLegend* theWrappedObject, QCPAbstractLegendItem* item);
1179 bool removeItem(QCPLegend* theWrappedObject, int index);
1180 void selectEvent(QCPLegend* theWrappedObject, QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged);
1181 double selectTest(QCPLegend* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details = 0) const;
1182 QPen selectedBorderPen(QCPLegend* theWrappedObject) const;
1183 QBrush selectedBrush(QCPLegend* theWrappedObject) const;
1184 QFont selectedFont(QCPLegend* theWrappedObject) const;
1185 QPen selectedIconBorderPen(QCPLegend* theWrappedObject) const;
1186 QList<QCPAbstractLegendItem* > selectedItems(QCPLegend* theWrappedObject) const;
1187 QColor selectedTextColor(QCPLegend* theWrappedObject) const;
1188 void setBorderPen(QCPLegend* theWrappedObject, const QPen& pen);
1189 void setBrush(QCPLegend* theWrappedObject, const QBrush& brush);
1190 void setFont(QCPLegend* theWrappedObject, const QFont& font);
1191 void setIconBorderPen(QCPLegend* theWrappedObject, const QPen& pen);
1192 void setIconSize(QCPLegend* theWrappedObject, const QSize& size);
1193 void setIconSize(QCPLegend* theWrappedObject, int width, int height);
1194 void setIconTextPadding(QCPLegend* theWrappedObject, int padding);
1195 void setSelectedBorderPen(QCPLegend* theWrappedObject, const QPen& pen);
1196 void setSelectedBrush(QCPLegend* theWrappedObject, const QBrush& brush);
1197 void setSelectedFont(QCPLegend* theWrappedObject, const QFont& font);
1198 void setSelectedIconBorderPen(QCPLegend* theWrappedObject, const QPen& pen);
1199 void setSelectedTextColor(QCPLegend* theWrappedObject, const QColor& color);
1200 void setTextColor(QCPLegend* theWrappedObject, const QColor& color);
1201 QColor textColor(QCPLegend* theWrappedObject) const;
1202 };
1203
1204
1205
1206
1207
1208 class PythonQtShell_QCPPainter : public QCPPainter
1209 {
1210 public:
1211 PythonQtShell_QCPPainter():QCPPainter(),_wrapper(NULL) { };
1212 PythonQtShell_QCPPainter(QPaintDevice* device):QCPPainter(device),_wrapper(NULL) { };
1213
1214 ~PythonQtShell_QCPPainter();
1215
1216
1217 PythonQtInstanceWrapper* _wrapper;
1218 };
1219
1220 class PythonQtWrapper_QCPPainter : public QObject
1221 { Q_OBJECT
1222 public:
1223 public slots:
1224 QCPPainter* new_QCPPainter();
1225 QCPPainter* new_QCPPainter(QPaintDevice* device);
1226 void delete_QCPPainter(QCPPainter* obj) { delete obj; }
1227 bool antialiasing(QCPPainter* theWrappedObject) const;
1228 bool begin(QCPPainter* theWrappedObject, QPaintDevice* device);
1229 void drawLine(QCPPainter* theWrappedObject, const QLineF& line);
1230 void drawLine(QCPPainter* theWrappedObject, const QPointF& p1, const QPointF& p2);
1231 void makeNonCosmetic(QCPPainter* theWrappedObject);
1232 void restore(QCPPainter* theWrappedObject);
1233 void save(QCPPainter* theWrappedObject);
1234 void setAntialiasing(QCPPainter* theWrappedObject, bool enabled);
1235 void setPen(QCPPainter* theWrappedObject, Qt::PenStyle penStyle);
1236 void setPen(QCPPainter* theWrappedObject, const QColor& color);
1237 void setPen(QCPPainter* theWrappedObject, const QPen& pen);
1238 };
1239
1240
1241
1242
1243
1244 class PythonQtShell_QCPPlotTitle : public QCPPlotTitle
1245 {
1246 public:
1247 PythonQtShell_QCPPlotTitle(QCustomPlot* parentPlot):QCPPlotTitle(parentPlot),_wrapper(NULL) { };
1248 PythonQtShell_QCPPlotTitle(QCustomPlot* parentPlot, const QString& text):QCPPlotTitle(parentPlot, text),_wrapper(NULL) { };
1249
1250 ~PythonQtShell_QCPPlotTitle();
1251
1252 virtual void applyDefaultAntialiasingHint(QCPPainter* painter) const;
1253 virtual void childEvent(QChildEvent* arg__1);
1254 virtual QRect clipRect() const;
1255 virtual void customEvent(QEvent* arg__1);
1256 virtual void deselectEvent(bool* selectionStateChanged);
1257 virtual void draw(QCPPainter* painter);
1258 virtual QList<QCPLayoutElement* > elements(bool recursive) const;
1259 virtual bool event(QEvent* arg__1);
1260 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
1261 virtual QSize maximumSizeHint() const;
1262 virtual QSize minimumSizeHint() const;
1263 virtual void mouseDoubleClickEvent(QMouseEvent* event);
1264 virtual void mouseMoveEvent(QMouseEvent* event);
1265 virtual void mousePressEvent(QMouseEvent* event);
1266 virtual void mouseReleaseEvent(QMouseEvent* event);
1267 virtual void parentPlotInitialized(QCustomPlot* parentPlot);
1268 virtual void selectEvent(QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged);
1269 virtual double selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const;
1270 virtual void timerEvent(QTimerEvent* arg__1);
1271 virtual void wheelEvent(QWheelEvent* event);
1272
1273 PythonQtInstanceWrapper* _wrapper;
1274 };
1275
1276 class PythonQtPublicPromoter_QCPPlotTitle : public QCPPlotTitle
1277 { public:
1278 inline void promoted_applyDefaultAntialiasingHint(QCPPainter* painter) const { QCPPlotTitle::applyDefaultAntialiasingHint(painter); }
1279 inline void promoted_deselectEvent(bool* selectionStateChanged) { QCPPlotTitle::deselectEvent(selectionStateChanged); }
1280 inline void promoted_draw(QCPPainter* painter) { QCPPlotTitle::draw(painter); }
1281 inline QFont promoted_mainFont() const { return QCPPlotTitle::mainFont(); }
1282 inline QColor promoted_mainTextColor() const { return QCPPlotTitle::mainTextColor(); }
1283 inline QSize promoted_maximumSizeHint() const { return QCPPlotTitle::maximumSizeHint(); }
1284 inline QSize promoted_minimumSizeHint() const { return QCPPlotTitle::minimumSizeHint(); }
1285 inline void promoted_selectEvent(QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged) { QCPPlotTitle::selectEvent(event, additive, details, selectionStateChanged); }
1286 inline double promoted_selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const { return QCPPlotTitle::selectTest(pos, onlySelectable, details); }
1287 };
1288
1289 class PythonQtWrapper_QCPPlotTitle : public QObject
1290 { Q_OBJECT
1291 public:
1292 public slots:
1293 QCPPlotTitle* new_QCPPlotTitle(QCustomPlot* parentPlot);
1294 QCPPlotTitle* new_QCPPlotTitle(QCustomPlot* parentPlot, const QString& text);
1295 void delete_QCPPlotTitle(QCPPlotTitle* obj) { delete obj; }
1296 void applyDefaultAntialiasingHint(QCPPlotTitle* theWrappedObject, QCPPainter* painter) const;
1297 void deselectEvent(QCPPlotTitle* theWrappedObject, bool* selectionStateChanged);
1298 void draw(QCPPlotTitle* theWrappedObject, QCPPainter* painter);
1299 QFont font(QCPPlotTitle* theWrappedObject) const;
1300 QFont mainFont(QCPPlotTitle* theWrappedObject) const;
1301 QColor mainTextColor(QCPPlotTitle* theWrappedObject) const;
1302 QSize maximumSizeHint(QCPPlotTitle* theWrappedObject) const;
1303 QSize minimumSizeHint(QCPPlotTitle* theWrappedObject) const;
1304 void selectEvent(QCPPlotTitle* theWrappedObject, QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged);
1305 double selectTest(QCPPlotTitle* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details = 0) const;
1306 bool selectable(QCPPlotTitle* theWrappedObject) const;
1307 bool selected(QCPPlotTitle* theWrappedObject) const;
1308 QFont selectedFont(QCPPlotTitle* theWrappedObject) const;
1309 QColor selectedTextColor(QCPPlotTitle* theWrappedObject) const;
1310 void setFont(QCPPlotTitle* theWrappedObject, const QFont& font);
1311 void setSelectable(QCPPlotTitle* theWrappedObject, bool selectable);
1312 void setSelected(QCPPlotTitle* theWrappedObject, bool selected);
1313 void setSelectedFont(QCPPlotTitle* theWrappedObject, const QFont& font);
1314 void setSelectedTextColor(QCPPlotTitle* theWrappedObject, const QColor& color);
1315 void setText(QCPPlotTitle* theWrappedObject, const QString& text);
1316 void setTextColor(QCPPlotTitle* theWrappedObject, const QColor& color);
1317 QString text(QCPPlotTitle* theWrappedObject) const;
1318 QColor textColor(QCPPlotTitle* theWrappedObject) const;
1319 };
1320
1321
1322
1323
1324
1325 class PythonQtShell_QCustomPlot : public QCustomPlot
1326 {
1327 public:
1328 PythonQtShell_QCustomPlot(QWidget* parent = 0):QCustomPlot(parent),_wrapper(NULL) { };
1329
1330 ~PythonQtShell_QCustomPlot();
1331
1332 virtual void actionEvent(QActionEvent* arg__1);
1333 virtual void axisRemoved(QCPAxis* axis);
1334 virtual void changeEvent(QEvent* arg__1);
1335 virtual void childEvent(QChildEvent* arg__1);
1336 virtual void closeEvent(QCloseEvent* arg__1);
1337 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
1338 virtual void customEvent(QEvent* arg__1);
1339 virtual int devType() const;
1340 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
1341 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
1342 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
1343 virtual void draw(QCPPainter* painter);
1344 virtual void dropEvent(QDropEvent* arg__1);
1345 virtual void enterEvent(QEvent* arg__1);
1346 virtual bool event(QEvent* arg__1);
1347 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
1348 virtual void focusInEvent(QFocusEvent* arg__1);
1349 virtual bool focusNextPrevChild(bool next);
1350 virtual void focusOutEvent(QFocusEvent* arg__1);
1351 virtual bool hasHeightForWidth() const;
1352 virtual int heightForWidth(int arg__1) const;
1353 virtual void hideEvent(QHideEvent* arg__1);
1354 virtual void initPainter(QPainter* painter) const;
1355 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
1356 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
1357 virtual void keyPressEvent(QKeyEvent* arg__1);
1358 virtual void keyReleaseEvent(QKeyEvent* arg__1);
1359 virtual void leaveEvent(QEvent* arg__1);
1360 virtual void legendRemoved(QCPLegend* legend);
1361 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
1362 virtual QSize minimumSizeHint() const;
1363 virtual void mouseDoubleClickEvent(QMouseEvent* event);
1364 virtual void mouseMoveEvent(QMouseEvent* event);
1365 virtual void mousePressEvent(QMouseEvent* event);
1366 virtual void mouseReleaseEvent(QMouseEvent* event);
1367 virtual void moveEvent(QMoveEvent* arg__1);
1368 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
1369 virtual QPaintEngine* paintEngine() const;
1370 virtual void paintEvent(QPaintEvent* event);
1371 virtual QPaintDevice* redirected(QPoint* offset) const;
1372 virtual void resizeEvent(QResizeEvent* event);
1373 virtual QPainter* sharedPainter() const;
1374 virtual void showEvent(QShowEvent* arg__1);
1375 virtual QSize sizeHint() const;
1376 virtual void tabletEvent(QTabletEvent* arg__1);
1377 virtual void timerEvent(QTimerEvent* arg__1);
1378 virtual void wheelEvent(QWheelEvent* event);
1379
1380 PythonQtInstanceWrapper* _wrapper;
1381 };
1382
1383 class PythonQtPublicPromoter_QCustomPlot : public QCustomPlot
1384 { public:
1385 inline void promoted_axisRemoved(QCPAxis* axis) { QCustomPlot::axisRemoved(axis); }
1386 inline void promoted_draw(QCPPainter* painter) { QCustomPlot::draw(painter); }
1387 inline void promoted_drawBackground(QCPPainter* painter) { QCustomPlot::drawBackground(painter); }
1388 inline QCPLayerable* promoted_layerableAt(const QPointF& pos, bool onlySelectable, QVariant* selectionDetails = 0) const { return QCustomPlot::layerableAt(pos, onlySelectable, selectionDetails); }
1389 inline void promoted_legendRemoved(QCPLegend* legend) { QCustomPlot::legendRemoved(legend); }
1390 inline QSize promoted_minimumSizeHint() const { return QCustomPlot::minimumSizeHint(); }
1391 inline void promoted_mouseDoubleClickEvent(QMouseEvent* event) { QCustomPlot::mouseDoubleClickEvent(event); }
1392 inline void promoted_mouseMoveEvent(QMouseEvent* event) { QCustomPlot::mouseMoveEvent(event); }
1393 inline void promoted_mousePressEvent(QMouseEvent* event) { QCustomPlot::mousePressEvent(event); }
1394 inline void promoted_mouseReleaseEvent(QMouseEvent* event) { QCustomPlot::mouseReleaseEvent(event); }
1395 inline void promoted_paintEvent(QPaintEvent* event) { QCustomPlot::paintEvent(event); }
1396 inline void promoted_resizeEvent(QResizeEvent* event) { QCustomPlot::resizeEvent(event); }
1397 inline QSize promoted_sizeHint() const { return QCustomPlot::sizeHint(); }
1398 inline void promoted_updateLayerIndices() const { QCustomPlot::updateLayerIndices(); }
1399 inline void promoted_wheelEvent(QWheelEvent* event) { QCustomPlot::wheelEvent(event); }
1400 };
1401
1402 class PythonQtWrapper_QCustomPlot : public QObject
1403 { Q_OBJECT
1404 public:
1405 public slots:
1406 QCustomPlot* new_QCustomPlot(QWidget* parent = 0);
1407 void delete_QCustomPlot(QCustomPlot* obj) { delete obj; }
1408 QCPGraph* addGraph(QCustomPlot* theWrappedObject, QCPAxis* keyAxis = 0, QCPAxis* valueAxis = 0);
1409 bool addItem(QCustomPlot* theWrappedObject, QCPAbstractItem* item);
1410 bool autoAddPlottableToLegend(QCustomPlot* theWrappedObject) const;
1411 QCPAxisRect* axisRect(QCustomPlot* theWrappedObject, int index = 0) const;
1412 int axisRectCount(QCustomPlot* theWrappedObject) const;
1413 QList<QCPAxisRect* > axisRects(QCustomPlot* theWrappedObject) const;
1414 void axisRemoved(QCustomPlot* theWrappedObject, QCPAxis* axis);
1415 QPixmap background(QCustomPlot* theWrappedObject) const;
1416 bool backgroundScaled(QCustomPlot* theWrappedObject) const;
1417 Qt::AspectRatioMode backgroundScaledMode(QCustomPlot* theWrappedObject) const;
1418 int clearGraphs(QCustomPlot* theWrappedObject);
1419 int clearItems(QCustomPlot* theWrappedObject);
1420 int clearPlottables(QCustomPlot* theWrappedObject);
1421 QCPLayer* currentLayer(QCustomPlot* theWrappedObject) const;
1422 void deselectAll(QCustomPlot* theWrappedObject);
1423 void draw(QCustomPlot* theWrappedObject, QCPPainter* painter);
1424 void drawBackground(QCustomPlot* theWrappedObject, QCPPainter* painter);
1425 QCPGraph* graph(QCustomPlot* theWrappedObject) const;
1426 QCPGraph* graph(QCustomPlot* theWrappedObject, int index) const;
1427 int graphCount(QCustomPlot* theWrappedObject) const;
1428 bool hasItem(QCustomPlot* theWrappedObject, QCPAbstractItem* item) const;
1429 QCPAbstractItem* item(QCustomPlot* theWrappedObject) const;
1430 QCPAbstractItem* item(QCustomPlot* theWrappedObject, int index) const;
1431 QCPAbstractItem* itemAt(QCustomPlot* theWrappedObject, const QPointF& pos, bool onlySelectable = false) const;
1432 int itemCount(QCustomPlot* theWrappedObject) const;
1433 QCPLayer* layer(QCustomPlot* theWrappedObject, const QString& name) const;
1434 QCPLayer* layer(QCustomPlot* theWrappedObject, int index) const;
1435 int layerCount(QCustomPlot* theWrappedObject) const;
1436 QCPLayerable* layerableAt(QCustomPlot* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* selectionDetails = 0) const;
1437 QCPLayoutElement* layoutElementAt(QCustomPlot* theWrappedObject, const QPointF& pos) const;
1438 void legendRemoved(QCustomPlot* theWrappedObject, QCPLegend* legend);
1439 QSize minimumSizeHint(QCustomPlot* theWrappedObject) const;
1440 void mouseDoubleClickEvent(QCustomPlot* theWrappedObject, QMouseEvent* event);
1441 void mouseMoveEvent(QCustomPlot* theWrappedObject, QMouseEvent* event);
1442 void mousePressEvent(QCustomPlot* theWrappedObject, QMouseEvent* event);
1443 void mouseReleaseEvent(QCustomPlot* theWrappedObject, QMouseEvent* event);
1444 Qt::KeyboardModifier multiSelectModifier(QCustomPlot* theWrappedObject) const;
1445 bool noAntialiasingOnDrag(QCustomPlot* theWrappedObject) const;
1446 void paintEvent(QCustomPlot* theWrappedObject, QPaintEvent* event);
1447 int plottableCount(QCustomPlot* theWrappedObject) const;
1448 bool removeGraph(QCustomPlot* theWrappedObject, QCPGraph* graph);
1449 bool removeGraph(QCustomPlot* theWrappedObject, int index);
1450 bool removeItem(QCustomPlot* theWrappedObject, QCPAbstractItem* item);
1451 bool removeItem(QCustomPlot* theWrappedObject, int index);
1452 bool removeLayer(QCustomPlot* theWrappedObject, QCPLayer* layer);
1453 bool removePlottable(QCustomPlot* theWrappedObject, int index);
1454 void rescaleAxes(QCustomPlot* theWrappedObject, bool onlyVisiblePlottables = false);
1455 void resizeEvent(QCustomPlot* theWrappedObject, QResizeEvent* event);
1456 bool saveBmp(QCustomPlot* theWrappedObject, const QString& fileName, int width = 0, int height = 0, double scale = 1.0);
1457 bool saveJpg(QCustomPlot* theWrappedObject, const QString& fileName, int width = 0, int height = 0, double scale = 1.0, int quality = -1);
1458 bool savePdf(QCustomPlot* theWrappedObject, const QString& fileName, bool noCosmeticPen = false, int width = 0, int height = 0, const QString& pdfCreator = QString(), const QString& pdfTitle = QString());
1459 bool savePng(QCustomPlot* theWrappedObject, const QString& fileName, int width = 0, int height = 0, double scale = 1.0, int quality = -1);
1460 bool saveRastered(QCustomPlot* theWrappedObject, const QString& fileName, int width, int height, double scale, const char* format, int quality = -1);
1461 QList<QCPAxis* > selectedAxes(QCustomPlot* theWrappedObject) const;
1462 QList<QCPGraph* > selectedGraphs(QCustomPlot* theWrappedObject) const;
1463 QList<QCPAbstractItem* > selectedItems(QCustomPlot* theWrappedObject) const;
1464 QList<QCPLegend* > selectedLegends(QCustomPlot* theWrappedObject) const;
1465 int selectionTolerance(QCustomPlot* theWrappedObject) const;
1466 void setAutoAddPlottableToLegend(QCustomPlot* theWrappedObject, bool on);
1467 void setBackground(QCustomPlot* theWrappedObject, const QBrush& brush);
1468 void setBackground(QCustomPlot* theWrappedObject, const QPixmap& pm);
1469 void setBackground(QCustomPlot* theWrappedObject, const QPixmap& pm, bool scaled, Qt::AspectRatioMode mode = Qt::KeepAspectRatioByExpanding);
1470 void setBackgroundScaled(QCustomPlot* theWrappedObject, bool scaled);
1471 void setBackgroundScaledMode(QCustomPlot* theWrappedObject, Qt::AspectRatioMode mode);
1472 bool setCurrentLayer(QCustomPlot* theWrappedObject, QCPLayer* layer);
1473 bool setCurrentLayer(QCustomPlot* theWrappedObject, const QString& name);
1474 void setMultiSelectModifier(QCustomPlot* theWrappedObject, Qt::KeyboardModifier modifier);
1475 void setNoAntialiasingOnDrag(QCustomPlot* theWrappedObject, bool enabled);
1476 void setSelectionTolerance(QCustomPlot* theWrappedObject, int pixels);
1477 void setViewport(QCustomPlot* theWrappedObject, const QRect& rect);
1478 QSize sizeHint(QCustomPlot* theWrappedObject) const;
1479 void toPainter(QCustomPlot* theWrappedObject, QCPPainter* painter, int width = 0, int height = 0);
1480 QPixmap toPixmap(QCustomPlot* theWrappedObject, int width = 0, int height = 0, double scale = 1.0);
1481 void updateLayerIndices(QCustomPlot* theWrappedObject) const;
1482 QRect viewport(QCustomPlot* theWrappedObject) const;
1483 void wheelEvent(QCustomPlot* theWrappedObject, QWheelEvent* event);
1484 void py_set_legend(QCustomPlot* theWrappedObject, QCPLegend* legend){ theWrappedObject->legend = legend; }
1485 QCPLegend* py_get_legend(QCustomPlot* theWrappedObject){ return theWrappedObject->legend; }
1486 void py_set_xAxis(QCustomPlot* theWrappedObject, QCPAxis* xAxis){ theWrappedObject->xAxis = xAxis; }
1487 QCPAxis* py_get_xAxis(QCustomPlot* theWrappedObject){ return theWrappedObject->xAxis; }
1488 void py_set_xAxis2(QCustomPlot* theWrappedObject, QCPAxis* xAxis2){ theWrappedObject->xAxis2 = xAxis2; }
1489 QCPAxis* py_get_xAxis2(QCustomPlot* theWrappedObject){ return theWrappedObject->xAxis2; }
1490 void py_set_yAxis(QCustomPlot* theWrappedObject, QCPAxis* yAxis){ theWrappedObject->yAxis = yAxis; }
1491 QCPAxis* py_get_yAxis(QCustomPlot* theWrappedObject){ return theWrappedObject->yAxis; }
1492 void py_set_yAxis2(QCustomPlot* theWrappedObject, QCPAxis* yAxis2){ theWrappedObject->yAxis2 = yAxis2; }
1493 QCPAxis* py_get_yAxis2(QCustomPlot* theWrappedObject){ return theWrappedObject->yAxis2; }
1494 };
1495
1496
1497
1498
1499
1500 class PythonQtShell_QLopData : public QLopData
1501 {
1502 public:
1503 PythonQtShell_QLopData(QObject* parent = 0):QLopData(parent),_wrapper(NULL) { };
1504
1505 ~PythonQtShell_QLopData();
1506
1507 virtual void childEvent(QChildEvent* arg__1);
1508 virtual void customEvent(QEvent* arg__1);
1509 virtual bool event(QEvent* arg__1);
1510 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
1511 virtual void timerEvent(QTimerEvent* arg__1);
1512
1513 PythonQtInstanceWrapper* _wrapper;
1514 };
1515
1516 class PythonQtWrapper_QLopData : public QObject
1517 { Q_OBJECT
1518 public:
1519 public slots:
1520 QLopData* new_QLopData(QObject* parent = 0);
1521 void delete_QLopData(QLopData* obj) { delete obj; }
1522 void py_set_name(QLopData* theWrappedObject, QString name){ theWrappedObject->name = name; }
1523 QString py_get_name(QLopData* theWrappedObject){ return theWrappedObject->name; }
1524 void py_set_unit(QLopData* theWrappedObject, QString unit){ theWrappedObject->unit = unit; }
1525 QString py_get_unit(QLopData* theWrappedObject){ return theWrappedObject->unit; }
1526 };
1527
1528
1529
1530
1531
1532 class PythonQtWrapper_QLopDataList : public QObject
1533 { Q_OBJECT
1534 public:
1535 public slots:
1536 QLopDataList* new_QLopDataList();
1537 QLopDataList* new_QLopDataList(const QList<QLopData* >& l);
1538 void delete_QLopDataList(QLopDataList* obj) { delete obj; }
1539 void append(QLopDataList* theWrappedObject, QLopData* t);
1540 void append(QLopDataList* theWrappedObject, const QList<QLopData* >& t);
1541 QLopData* at(QLopDataList* theWrappedObject, int i) const;
1542 QLopData* back(QLopDataList* theWrappedObject) const;
1543 void clear(QLopDataList* theWrappedObject);
1544 bool contains(QLopDataList* theWrappedObject, QLopData* t) const;
1545 int count(QLopDataList* theWrappedObject) const;
1546 int count(QLopDataList* theWrappedObject, QLopData* t) const;
1547 void detachShared(QLopDataList* theWrappedObject);
1548 bool empty(QLopDataList* theWrappedObject) const;
1549 bool endsWith(QLopDataList* theWrappedObject, QLopData* t) const;
1550 QLopData* first(QLopDataList* theWrappedObject) const;
1551 QList<QLopData* > static_QLopDataList_fromVector(const QVector<QLopData* >& vector);
1552 QLopData* front(QLopDataList* theWrappedObject) const;
1553 int indexOf(QLopDataList* theWrappedObject, QLopData* t, int from = 0) const;
1554 bool isEmpty(QLopDataList* theWrappedObject) const;
1555 bool isSharedWith(QLopDataList* theWrappedObject, const QList<QLopData* >& other) const;
1556 QLopData* last(QLopDataList* theWrappedObject) const;
1557 int lastIndexOf(QLopDataList* theWrappedObject, QLopData* t, int from = -1) const;
1558 int length(QLopDataList* theWrappedObject) const;
1559 QList<QLopData* > mid(QLopDataList* theWrappedObject, int pos, int length = -1) const;
1560 void move(QLopDataList* theWrappedObject, int from, int to);
1561 bool __ne__(QLopDataList* theWrappedObject, const QList<QLopData* >& l) const;
1562 QList<QLopData* > __add__(QLopDataList* theWrappedObject, const QList<QLopData* >& l) const;
1563 QList<QLopData* >* __iadd__(QLopDataList* theWrappedObject, QLopData* t);
1564 QList<QLopData* >* __iadd__(QLopDataList* theWrappedObject, const QList<QLopData* >& l);
1565 QList<QLopData* >* __lshift__(QLopDataList* theWrappedObject, QLopData* t);
1566 QList<QLopData* >* __lshift__(QLopDataList* theWrappedObject, const QList<QLopData* >& l);
1567 bool __eq__(QLopDataList* theWrappedObject, const QList<QLopData* >& l) const;
1568 void pop_back(QLopDataList* theWrappedObject);
1569 void pop_front(QLopDataList* theWrappedObject);
1570 void prepend(QLopDataList* theWrappedObject, QLopData* t);
1571 void push_back(QLopDataList* theWrappedObject, QLopData* t);
1572 void push_front(QLopDataList* theWrappedObject, QLopData* t);
1573 int removeAll(QLopDataList* theWrappedObject, QLopData* t);
1574 void removeAt(QLopDataList* theWrappedObject, int i);
1575 void removeFirst(QLopDataList* theWrappedObject);
1576 void removeLast(QLopDataList* theWrappedObject);
1577 bool removeOne(QLopDataList* theWrappedObject, QLopData* t);
1578 void replace(QLopDataList* theWrappedObject, int i, QLopData* t);
1579 void reserve(QLopDataList* theWrappedObject, int size);
1580 void setSharable(QLopDataList* theWrappedObject, bool sharable);
1581 int size(QLopDataList* theWrappedObject) const;
1582 bool startsWith(QLopDataList* theWrappedObject, QLopData* t) const;
1583 void swap(QLopDataList* theWrappedObject, QList<QLopData* >& other);
1584 void swap(QLopDataList* theWrappedObject, int i, int j);
1585 QLopData* takeAt(QLopDataList* theWrappedObject, int i);
1586 QLopData* takeFirst(QLopDataList* theWrappedObject);
1587 QLopData* takeLast(QLopDataList* theWrappedObject);
1588 QVector<QLopData* > toVector(QLopDataList* theWrappedObject) const;
1589 QLopData* value(QLopDataList* theWrappedObject, int i) const;
1590 QLopData* value(QLopDataList* theWrappedObject, int i, QLopData* defaultValue) const;
1591 };
1592
1593
1594
1595
1596
42 class PythonQtShell_QLopService : public QLopService
1597 class PythonQtShell_QLopService : public QLopService
43 {
1598 {
44 public:
1599 public:
Show file before | Show file after | Hide comments
@@ -5,8 +5,29
5
5
6
6
7 void PythonQt_init_PyQLop(PyObject* module) {
7 void PythonQt_init_PyQLop(PyObject* module) {
8 PythonQt::priv()->registerClass(&FileBrowser::staticMetaObject, "PyQLop", PythonQtCreateObject<PythonQtWrapper_FileBrowser>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_FileBrowser>, module, 0);
9 PythonQt::priv()->registerClass(&QCPAbstractItem::staticMetaObject, "PyQLop", PythonQtCreateObject<PythonQtWrapper_QCPAbstractItem>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QCPAbstractItem>, module, 0);
10 PythonQt::priv()->registerClass(&QCPAbstractLegendItem::staticMetaObject, "PyQLop", PythonQtCreateObject<PythonQtWrapper_QCPAbstractLegendItem>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QCPAbstractLegendItem>, module, 0);
11 PythonQt::priv()->registerClass(&QCPAxis::staticMetaObject, "PyQLop", PythonQtCreateObject<PythonQtWrapper_QCPAxis>, NULL, module, 0);
12 PythonQt::priv()->registerClass(&QCPAxisRect::staticMetaObject, "PyQLop", PythonQtCreateObject<PythonQtWrapper_QCPAxisRect>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QCPAxisRect>, module, 0);
13 PythonQt::priv()->registerClass(&QCPBars::staticMetaObject, "PyQLop", PythonQtCreateObject<PythonQtWrapper_QCPBars>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QCPBars>, module, 0);
14 PythonQt::priv()->registerClass(&QCPColorMap::staticMetaObject, "PyQLop", PythonQtCreateObject<PythonQtWrapper_QCPColorMap>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QCPColorMap>, module, 0);
15 PythonQt::priv()->registerClass(&QCPColorScale::staticMetaObject, "PyQLop", PythonQtCreateObject<PythonQtWrapper_QCPColorScale>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QCPColorScale>, module, 0);
16 PythonQt::priv()->registerClass(&QCPGraph::staticMetaObject, "PyQLop", PythonQtCreateObject<PythonQtWrapper_QCPGraph>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QCPGraph>, module, 0);
17 PythonQt::priv()->registerCPPClass("QCPItemPosition", "", "PyQLop", PythonQtCreateObject<PythonQtWrapper_QCPItemPosition>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QCPItemPosition>, module, 0);
18 PythonQt::priv()->registerClass(&QCPLayer::staticMetaObject, "PyQLop", PythonQtCreateObject<PythonQtWrapper_QCPLayer>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QCPLayer>, module, 0);
19 PythonQt::priv()->registerClass(&QCPLayerable::staticMetaObject, "PyQLop", PythonQtCreateObject<PythonQtWrapper_QCPLayerable>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QCPLayerable>, module, 0);
20 PythonQt::priv()->registerClass(&QCPLayout::staticMetaObject, "PyQLop", PythonQtCreateObject<PythonQtWrapper_QCPLayout>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QCPLayout>, module, 0);
21 PythonQt::priv()->registerClass(&QCPLayoutElement::staticMetaObject, "PyQLop", PythonQtCreateObject<PythonQtWrapper_QCPLayoutElement>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QCPLayoutElement>, module, 0);
22 PythonQt::priv()->registerClass(&QCPLegend::staticMetaObject, "PyQLop", PythonQtCreateObject<PythonQtWrapper_QCPLegend>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QCPLegend>, module, 0);
23 PythonQt::priv()->registerCPPClass("QCPPainter", "QPainter", "PyQLop", PythonQtCreateObject<PythonQtWrapper_QCPPainter>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QCPPainter>, module, 0);
24 PythonQt::priv()->registerClass(&QCPPlotTitle::staticMetaObject, "PyQLop", PythonQtCreateObject<PythonQtWrapper_QCPPlotTitle>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QCPPlotTitle>, module, 0);
25 PythonQt::priv()->registerClass(&QCustomPlot::staticMetaObject, "PyQLop", PythonQtCreateObject<PythonQtWrapper_QCustomPlot>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QCustomPlot>, module, 0);
26 PythonQt::priv()->registerClass(&QLopData::staticMetaObject, "PyQLop", PythonQtCreateObject<PythonQtWrapper_QLopData>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QLopData>, module, 0);
27 PythonQt::priv()->registerCPPClass("QLopDataList", "", "PyQLop", PythonQtCreateObject<PythonQtWrapper_QLopDataList>, NULL, module, PythonQt::Type_Add|PythonQt::Type_InplaceAdd|PythonQt::Type_RichCompare);
8 PythonQt::priv()->registerClass(&QLopService::staticMetaObject, "PyQLop", PythonQtCreateObject<PythonQtWrapper_QLopService>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QLopService>, module, 0);
28 PythonQt::priv()->registerClass(&QLopService::staticMetaObject, "PyQLop", PythonQtCreateObject<PythonQtWrapper_QLopService>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QLopService>, module, 0);
9 PythonQt::priv()->registerClass(&SocExplorerPlot::staticMetaObject, "PyQLop", PythonQtCreateObject<PythonQtWrapper_SocExplorerPlot>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_SocExplorerPlot>, module, 0);
29 PythonQt::priv()->registerClass(&SocExplorerPlot::staticMetaObject, "PyQLop", PythonQtCreateObject<PythonQtWrapper_SocExplorerPlot>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_SocExplorerPlot>, module, 0);
10
30
11
31
32 PythonQtRegisterListTemplateConverterForKnownClass(QVector, QString);
12 }
33 }
Show file before | Show file after | Hide comments
@@ -4,7 +4,28
4 <load-typesystem name=":/trolltech/generator/typesystem_network.txt" generate="no" />
4 <load-typesystem name=":/trolltech/generator/typesystem_network.txt" generate="no" />
5
5
6 <interface-type name="QLopService"/>
6 <interface-type name="QLopService"/>
7 <object-type name="SocExplorerPlot" />
7 <object-type name="SocExplorerPlot"/>
8 <object-type name="QLopData"/>
9 <object-type name="QLopDataList"/>
10 <object-type name="FileBrowser"/>
11
12 <object-type name="QCPPainter"/>;
13 <object-type name="QCustomPlot"/>;
14 <object-type name="QCPLayerable"/>;
15 <object-type name="QCPLayoutElement"/>;
16 <object-type name="QCPLayout"/>;
17 <object-type name="QCPAxis"/>;
18 <object-type name="QCPAxisRect"/>;
19 <object-type name="QCPGraph"/>;
20 <interface-type name="QCPAbstractItem"/>;
21 <object-type name="QCPItemPosition"/>;
22 <object-type name="QCPLayer"/>;
23 <object-type name="QCPPlotTitle"/>;
24 <object-type name="QCPLegend"/>;
25 <interface-type name="QCPAbstractLegendItem"/>;
26 <object-type name="QCPColorMap"/>;
27 <object-type name="QCPColorScale"/>;
28 <object-type name="QCPBars"/>;
8
29
9 </typesystem>
30 </typesystem>
10
31
Show file before | Show file after | Hide comments
@@ -3,4 +3,4
3 #export QTDIR=/usr/include
3 #export QTDIR=/usr/include
4 #export QTDIR=/usr/include/qt5
4 #export QTDIR=/usr/include/qt5
5
5
6 pythonqt_generator --include-paths=../:./Widgets:./:/usr/include/qt5:/usr/include/qt5/QtCore:/usr/include/qt5/QtWidgets --output-directory=pythonQtOut pyqlop.h pythonQtgeneratorCfg.txt
6 pythonqt_generator --include-paths=../QCustomPlot:../:./Widgets:./:/usr/include/qt5:/usr/include/qt5/QtCore:/usr/include/qt5/QtWidgets --output-directory=pythonQtOut pyqlop.h pythonQtgeneratorCfg.txt
Show file before | Show file after | Hide comments
@@ -74,13 +74,15 void SocExplorerPlot::exportToSVG(const
74
74
75 void SocExplorerPlot::exportToPDF(const QString &fileName)
75 void SocExplorerPlot::exportToPDF(const QString &fileName)
76 {
76 {
77 // QPrinter printer;
77 QPrinter printer(QPrinter::HighResolution);
78 // printer.setOutputFormat(QPrinter::PdfFormat);
78 printer.setOutputFormat(QPrinter::PdfFormat);
79 // printer.setOutputFileName(fileName);
79 printer.setOrientation(QPrinter::Landscape);
80 // QCPPainter qcpPainter;
80 printer.setOutputFileName(fileName);
81 // qcpPainter.begin(&printer);
81 printer.setFullPage(true);
82 // m_plot->toPainter(&qcpPainter, m_plot->width(), m_plot->height());
82 QCPPainter qcpPainter;
83 // qcpPainter.end();
83 qcpPainter.begin(&printer);
84 m_plot->toPainter(&qcpPainter, printer.width(), printer.height());
85 qcpPainter.end();
84 }
86 }
85
87
86 void SocExplorerPlot::setTitle(QString title)
88 void SocExplorerPlot::setTitle(QString title)
@@ -90,7 +92,8 void SocExplorerPlot::setTitle(QString t
90 /*!
92 /*!
91 @todo Function borcken fixe this!
93 @todo Function borcken fixe this!
92 */
94 */
93 this->repaint();
95 emit titleChanged(title);
96 this->repaint();
94 }
97 }
95
98
96 void SocExplorerPlot::setXaxisLabel(QString label)
99 void SocExplorerPlot::setXaxisLabel(QString label)
Show file before | Show file after | Hide comments
@@ -64,7 +64,7 public:
64 void exportToSVG(const QString& fileName);
64 void exportToSVG(const QString& fileName);
65 void exportToPDF(const QString& fileName);
65 void exportToPDF(const QString& fileName);
66 signals:
66 signals:
67
67 void titleChanged(const QString& newTitle);
68 public slots:
68 public slots:
69
69
70 protected:
70 protected:
Show file before | Show file after | Hide comments
@@ -45,8 +45,8 MainWindow::MainWindow(int OMP_THREADS,
45 this->OMP_THREADS = OMP_THREADS;
45 this->OMP_THREADS = OMP_THREADS;
46 ui->setupUi(this);
46 ui->setupUi(this);
47
47
48 QLopPlots::getPlot()->setXaxisTickLabelType(QCPAxis::ltDateTime);
48 // QLopPlots::getPlot()->setXaxisTickLabelType(QCPAxis::ltDateTime);
49 QLopPlots::getPlot()->setXaxisDateTimeFormat("hh:mm:ss.zzz");
49 // QLopPlots::getPlot()->setXaxisDateTimeFormat("hh:mm:ss.zzz");
50 this->progressWidget = new QWidget();
50 this->progressWidget = new QWidget();
51 this->progressLayout = new QVBoxLayout(this->progressWidget);
51 this->progressLayout = new QVBoxLayout(this->progressWidget);
52 this->progressWidget->setLayout(this->progressLayout);
52 this->progressWidget->setLayout(this->progressLayout);
General Comments 0
You need to be logged in to leave comments. Login now