1 /*
2  * Interface wrapper code.
3  *
4  * Generated by SIP 4.19.16
5  *
6  *     Copyright: (c) 2018 by Total Control Software
7  *     License:   wxWindows License
8  */
9 
10 #include "sipAPI_core.h"
11 
12         #include <wx/vscroll.h>
13 
14         #include <wx/window.h>
15         #include <wx/gdicmn.h>
16         #include <wx/gdicmn.h>
17         #include <wx/window.h>
18         #include <wx/event.h>
19         #include <wx/validate.h>
20         #include <wx/event.h>
21     #include <wx/setup.h>
22     #include <wxPython/wxpy_api.h>
23         #include <wx/event.h>
24         #include <wx/cursor.h>
25         #include <wx/caret.h>
26         #include <wx/layout.h>
27         #include <wx/sizer.h>
28         #include <wx/dnd.h>
29         #include <wx/access.h>
30         #include <wx/accel.h>
31         #include <wx/menu.h>
32         #include <wx/tooltip.h>
33         #include <wx/event.h>
34         #include <wx/gdicmn.h>
35         #include <wx/event.h>
36         #include <wx/event.h>
37         #include <wx/palette.h>
38         #include <wx/colour.h>
39         #include <wx/font.h>
40         #include <wx/region.h>
41 
42         #include <wx/eventfilter.h>
43         #include <wx/object.h>
44         #include <wx/object.h>
45         #include <wx/object.h>
46         #include <wx/position.h>
47 
48 
49 class sipwxHVScrolledWindow : public  ::wxHVScrolledWindow
50 {
51 public:
52     sipwxHVScrolledWindow();
53     sipwxHVScrolledWindow( ::wxWindow*, ::wxWindowID,const  ::wxPoint&,const  ::wxSize&,long,const  ::wxString&);
54     virtual ~sipwxHVScrolledWindow();
55 
56     /*
57      * There is a public method for every protected method visible from
58      * this class.
59      */
60      ::wxCoord sipProtectVirt_EstimateTotalWidth(bool) const;
61     void sipProtectVirt_OnGetColumnsWidthHint(bool,size_t,size_t) const;
62      ::wxCoord sipProtect_OnGetColumnWidth(size_t) const;
63     void sipProtectVirt_OnGetRowsHeightHint(bool,size_t,size_t) const;
64      ::wxCoord sipProtectVirt_EstimateTotalHeight(bool) const;
65      ::wxCoord sipProtect_OnGetRowHeight(size_t) const;
66     void sipProtect_SendDestroyEvent();
67     bool sipProtectVirt_ProcessEvent(bool, ::wxEvent&);
68     void sipProtectVirt_DoEnable(bool,bool);
69     void sipProtectVirt_DoGetPosition(bool,int*,int*) const;
70     void sipProtectVirt_DoGetSize(bool,int*,int*) const;
71     void sipProtectVirt_DoGetClientSize(bool,int*,int*) const;
72      ::wxSize sipProtectVirt_DoGetBestSize(bool) const;
73      ::wxSize sipProtectVirt_DoGetBestClientSize(bool) const;
74     void sipProtectVirt_DoSetSize(bool,int,int,int,int,int);
75     void sipProtectVirt_DoSetClientSize(bool,int,int);
76     void sipProtectVirt_DoSetSizeHints(bool,int,int,int,int,int,int);
77      ::wxSize sipProtectVirt_DoGetBorderSize(bool) const;
78     void sipProtectVirt_DoMoveWindow(bool,int,int,int,int);
79     void sipProtectVirt_DoSetWindowVariant(bool, ::wxWindowVariant);
80      ::wxBorder sipProtectVirt_GetDefaultBorder(bool) const;
81      ::wxBorder sipProtectVirt_GetDefaultBorderForControl(bool) const;
82     void sipProtectVirt_DoFreeze(bool);
83     void sipProtectVirt_DoThaw(bool);
84     bool sipProtectVirt_HasTransparentBackground(bool);
85     bool sipProtectVirt_TryBefore(bool, ::wxEvent&);
86     bool sipProtectVirt_TryAfter(bool, ::wxEvent&);
87 
88     /*
89      * There is a protected method for every virtual method visible from
90      * this class.
91      */
92 protected:
93      ::wxCoord OnGetRowHeight(size_t) const SIP_OVERRIDE;
94      ::wxCoord EstimateTotalHeight() const SIP_OVERRIDE;
95     void OnGetRowsHeightHint(size_t,size_t) const SIP_OVERRIDE;
96     bool ScrollRows(int) SIP_OVERRIDE;
97     bool ScrollRowPages(int) SIP_OVERRIDE;
98     void RefreshRows(size_t,size_t) SIP_OVERRIDE;
99     void RefreshRow(size_t) SIP_OVERRIDE;
100      ::wxCoord OnGetColumnWidth(size_t) const SIP_OVERRIDE;
101     void OnGetColumnsWidthHint(size_t,size_t) const SIP_OVERRIDE;
102      ::wxCoord EstimateTotalWidth() const SIP_OVERRIDE;
103     bool ScrollColumns(int) SIP_OVERRIDE;
104     bool ScrollColumnPages(int) SIP_OVERRIDE;
105     void RefreshColumns(size_t,size_t) SIP_OVERRIDE;
106     void RefreshColumn(size_t) SIP_OVERRIDE;
107     void RefreshRowColumn(size_t,size_t) SIP_OVERRIDE;
108     void RefreshRowColumn(const  ::wxPosition&) SIP_OVERRIDE;
109     void RefreshRowsColumns(size_t,size_t,size_t,size_t) SIP_OVERRIDE;
110     void RefreshRowsColumns(const  ::wxPosition&,const  ::wxPosition&) SIP_OVERRIDE;
111      ::wxSize DoGetBestClientSize() const SIP_OVERRIDE;
112      ::wxSize DoGetBestSize() const SIP_OVERRIDE;
113     void DoThaw() SIP_OVERRIDE;
114     void DoFreeze() SIP_OVERRIDE;
115      ::wxBorder GetDefaultBorderForControl() const SIP_OVERRIDE;
116      ::wxBorder GetDefaultBorder() const SIP_OVERRIDE;
117     void DoSetWindowVariant( ::wxWindowVariant) SIP_OVERRIDE;
118     void DoMoveWindow(int,int,int,int) SIP_OVERRIDE;
119      ::wxSize DoGetBorderSize() const SIP_OVERRIDE;
120     void DoSetSizeHints(int,int,int,int,int,int) SIP_OVERRIDE;
121     void DoSetClientSize(int,int) SIP_OVERRIDE;
122     void DoSetSize(int,int,int,int,int) SIP_OVERRIDE;
123     void DoGetClientSize(int*,int*) const SIP_OVERRIDE;
124     void DoGetSize(int*,int*) const SIP_OVERRIDE;
125     void DoGetPosition(int*,int*) const SIP_OVERRIDE;
126     void DoEnable(bool) SIP_OVERRIDE;
127      ::wxWindow* GetMainWindowOfCompositeControl() SIP_OVERRIDE;
128     void OnInternalIdle() SIP_OVERRIDE;
129     void InitDialog() SIP_OVERRIDE;
130     void InheritAttributes() SIP_OVERRIDE;
131     bool Destroy() SIP_OVERRIDE;
132     bool Validate() SIP_OVERRIDE;
133     bool TransferDataToWindow() SIP_OVERRIDE;
134     bool TransferDataFromWindow() SIP_OVERRIDE;
135     void SetValidator(const  ::wxValidator&) SIP_OVERRIDE;
136      ::wxValidator* GetValidator() SIP_OVERRIDE;
137     bool ShouldInheritColours() const SIP_OVERRIDE;
138     bool HasTransparentBackground() SIP_OVERRIDE;
139      ::wxPoint GetClientAreaOrigin() const SIP_OVERRIDE;
140     bool InformFirstDirection(int,int,int) SIP_OVERRIDE;
141     void SetCanFocus(bool) SIP_OVERRIDE;
142     bool AcceptsFocusRecursively() const SIP_OVERRIDE;
143     bool AcceptsFocusFromKeyboard() const SIP_OVERRIDE;
144     bool AcceptsFocus() const SIP_OVERRIDE;
145     bool TryAfter( ::wxEvent&) SIP_OVERRIDE;
146     bool TryBefore( ::wxEvent&) SIP_OVERRIDE;
147     bool ProcessEvent( ::wxEvent&) SIP_OVERRIDE;
148     void AddChild( ::wxWindowBase*) SIP_OVERRIDE;
149     void RemoveChild( ::wxWindowBase*) SIP_OVERRIDE;
150 
151 public:
152     sipSimpleWrapper *sipPySelf;
153 
154 private:
155     sipwxHVScrolledWindow(const sipwxHVScrolledWindow &);
156     sipwxHVScrolledWindow &operator = (const sipwxHVScrolledWindow &);
157 
158     char sipPyMethods[57];
159 };
160 
sipwxHVScrolledWindow()161 sipwxHVScrolledWindow::sipwxHVScrolledWindow():  ::wxHVScrolledWindow(), sipPySelf(SIP_NULLPTR)
162 {
163     memset(sipPyMethods, 0, sizeof (sipPyMethods));
164 }
165 
sipwxHVScrolledWindow(::wxWindow * parent,::wxWindowID id,const::wxPoint & pos,const::wxSize & size,long style,const::wxString & name)166 sipwxHVScrolledWindow::sipwxHVScrolledWindow( ::wxWindow*parent, ::wxWindowID id,const  ::wxPoint& pos,const  ::wxSize& size,long style,const  ::wxString& name):  ::wxHVScrolledWindow(parent,id,pos,size,style,name), sipPySelf(SIP_NULLPTR)
167 {
168     memset(sipPyMethods, 0, sizeof (sipPyMethods));
169 }
170 
~sipwxHVScrolledWindow()171 sipwxHVScrolledWindow::~sipwxHVScrolledWindow()
172 {
173     sipInstanceDestroyedEx(&sipPySelf);
174 }
175 
OnGetRowHeight(size_t row) const176  ::wxCoord sipwxHVScrolledWindow::OnGetRowHeight(size_t row) const
177 {
178     sip_gilstate_t sipGILState;
179     PyObject *sipMeth;
180 
181     sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[0]),sipPySelf,sipName_HVScrolledWindow,sipName_OnGetRowHeight);
182 
183     if (!sipMeth)
184         return 0;
185 
186     extern  ::wxCoord sipVH__core_130(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, size_t);
187 
188     return sipVH__core_130(sipGILState, 0, sipPySelf, sipMeth, row);
189 }
190 
EstimateTotalHeight() const191  ::wxCoord sipwxHVScrolledWindow::EstimateTotalHeight() const
192 {
193     sip_gilstate_t sipGILState;
194     PyObject *sipMeth;
195 
196     sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[1]),sipPySelf,SIP_NULLPTR,sipName_EstimateTotalHeight);
197 
198     if (!sipMeth)
199         return  ::wxHVScrolledWindow::EstimateTotalHeight();
200 
201     extern  ::wxCoord sipVH__core_97(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);
202 
203     return sipVH__core_97(sipGILState, 0, sipPySelf, sipMeth);
204 }
205 
OnGetRowsHeightHint(size_t rowMin,size_t rowMax) const206 void sipwxHVScrolledWindow::OnGetRowsHeightHint(size_t rowMin,size_t rowMax) const
207 {
208     sip_gilstate_t sipGILState;
209     PyObject *sipMeth;
210 
211     sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[2]),sipPySelf,SIP_NULLPTR,sipName_OnGetRowsHeightHint);
212 
213     if (!sipMeth)
214     {
215          ::wxHVScrolledWindow::OnGetRowsHeightHint(rowMin,rowMax);
216         return;
217     }
218 
219     extern void sipVH__core_129(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, size_t,size_t);
220 
221     sipVH__core_129(sipGILState, 0, sipPySelf, sipMeth, rowMin, rowMax);
222 }
223 
ScrollRows(int rows)224 bool sipwxHVScrolledWindow::ScrollRows(int rows)
225 {
226     sip_gilstate_t sipGILState;
227     PyObject *sipMeth;
228 
229     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[3],sipPySelf,SIP_NULLPTR,sipName_ScrollRows);
230 
231     if (!sipMeth)
232         return  ::wxHVScrolledWindow::ScrollRows(rows);
233 
234     extern bool sipVH__core_132(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int);
235 
236     return sipVH__core_132(sipGILState, 0, sipPySelf, sipMeth, rows);
237 }
238 
ScrollRowPages(int pages)239 bool sipwxHVScrolledWindow::ScrollRowPages(int pages)
240 {
241     sip_gilstate_t sipGILState;
242     PyObject *sipMeth;
243 
244     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[4],sipPySelf,SIP_NULLPTR,sipName_ScrollRowPages);
245 
246     if (!sipMeth)
247         return  ::wxHVScrolledWindow::ScrollRowPages(pages);
248 
249     extern bool sipVH__core_132(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int);
250 
251     return sipVH__core_132(sipGILState, 0, sipPySelf, sipMeth, pages);
252 }
253 
RefreshRows(size_t from_,size_t to_)254 void sipwxHVScrolledWindow::RefreshRows(size_t from_,size_t to_)
255 {
256     sip_gilstate_t sipGILState;
257     PyObject *sipMeth;
258 
259     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[5],sipPySelf,SIP_NULLPTR,sipName_RefreshRows);
260 
261     if (!sipMeth)
262     {
263          ::wxHVScrolledWindow::RefreshRows(from_,to_);
264         return;
265     }
266 
267     extern void sipVH__core_129(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, size_t,size_t);
268 
269     sipVH__core_129(sipGILState, 0, sipPySelf, sipMeth, from_, to_);
270 }
271 
RefreshRow(size_t row)272 void sipwxHVScrolledWindow::RefreshRow(size_t row)
273 {
274     sip_gilstate_t sipGILState;
275     PyObject *sipMeth;
276 
277     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[6],sipPySelf,SIP_NULLPTR,sipName_RefreshRow);
278 
279     if (!sipMeth)
280     {
281          ::wxHVScrolledWindow::RefreshRow(row);
282         return;
283     }
284 
285     extern void sipVH__core_131(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, size_t);
286 
287     sipVH__core_131(sipGILState, 0, sipPySelf, sipMeth, row);
288 }
289 
OnGetColumnWidth(size_t column) const290  ::wxCoord sipwxHVScrolledWindow::OnGetColumnWidth(size_t column) const
291 {
292     sip_gilstate_t sipGILState;
293     PyObject *sipMeth;
294 
295     sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[7]),sipPySelf,sipName_HVScrolledWindow,sipName_OnGetColumnWidth);
296 
297     if (!sipMeth)
298         return 0;
299 
300     extern  ::wxCoord sipVH__core_130(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, size_t);
301 
302     return sipVH__core_130(sipGILState, 0, sipPySelf, sipMeth, column);
303 }
304 
OnGetColumnsWidthHint(size_t columnMin,size_t columnMax) const305 void sipwxHVScrolledWindow::OnGetColumnsWidthHint(size_t columnMin,size_t columnMax) const
306 {
307     sip_gilstate_t sipGILState;
308     PyObject *sipMeth;
309 
310     sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[8]),sipPySelf,SIP_NULLPTR,sipName_OnGetColumnsWidthHint);
311 
312     if (!sipMeth)
313     {
314          ::wxHVScrolledWindow::OnGetColumnsWidthHint(columnMin,columnMax);
315         return;
316     }
317 
318     extern void sipVH__core_129(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, size_t,size_t);
319 
320     sipVH__core_129(sipGILState, 0, sipPySelf, sipMeth, columnMin, columnMax);
321 }
322 
EstimateTotalWidth() const323  ::wxCoord sipwxHVScrolledWindow::EstimateTotalWidth() const
324 {
325     sip_gilstate_t sipGILState;
326     PyObject *sipMeth;
327 
328     sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[9]),sipPySelf,SIP_NULLPTR,sipName_EstimateTotalWidth);
329 
330     if (!sipMeth)
331         return  ::wxHVScrolledWindow::EstimateTotalWidth();
332 
333     extern  ::wxCoord sipVH__core_97(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);
334 
335     return sipVH__core_97(sipGILState, 0, sipPySelf, sipMeth);
336 }
337 
ScrollColumns(int columns)338 bool sipwxHVScrolledWindow::ScrollColumns(int columns)
339 {
340     sip_gilstate_t sipGILState;
341     PyObject *sipMeth;
342 
343     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[10],sipPySelf,SIP_NULLPTR,sipName_ScrollColumns);
344 
345     if (!sipMeth)
346         return  ::wxHVScrolledWindow::ScrollColumns(columns);
347 
348     extern bool sipVH__core_132(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int);
349 
350     return sipVH__core_132(sipGILState, 0, sipPySelf, sipMeth, columns);
351 }
352 
ScrollColumnPages(int pages)353 bool sipwxHVScrolledWindow::ScrollColumnPages(int pages)
354 {
355     sip_gilstate_t sipGILState;
356     PyObject *sipMeth;
357 
358     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[11],sipPySelf,SIP_NULLPTR,sipName_ScrollColumnPages);
359 
360     if (!sipMeth)
361         return  ::wxHVScrolledWindow::ScrollColumnPages(pages);
362 
363     extern bool sipVH__core_132(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int);
364 
365     return sipVH__core_132(sipGILState, 0, sipPySelf, sipMeth, pages);
366 }
367 
RefreshColumns(size_t from_,size_t to_)368 void sipwxHVScrolledWindow::RefreshColumns(size_t from_,size_t to_)
369 {
370     sip_gilstate_t sipGILState;
371     PyObject *sipMeth;
372 
373     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[12],sipPySelf,SIP_NULLPTR,sipName_RefreshColumns);
374 
375     if (!sipMeth)
376     {
377          ::wxHVScrolledWindow::RefreshColumns(from_,to_);
378         return;
379     }
380 
381     extern void sipVH__core_129(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, size_t,size_t);
382 
383     sipVH__core_129(sipGILState, 0, sipPySelf, sipMeth, from_, to_);
384 }
385 
RefreshColumn(size_t column)386 void sipwxHVScrolledWindow::RefreshColumn(size_t column)
387 {
388     sip_gilstate_t sipGILState;
389     PyObject *sipMeth;
390 
391     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[13],sipPySelf,SIP_NULLPTR,sipName_RefreshColumn);
392 
393     if (!sipMeth)
394     {
395          ::wxHVScrolledWindow::RefreshColumn(column);
396         return;
397     }
398 
399     extern void sipVH__core_131(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, size_t);
400 
401     sipVH__core_131(sipGILState, 0, sipPySelf, sipMeth, column);
402 }
403 
RefreshRowColumn(size_t row,size_t column)404 void sipwxHVScrolledWindow::RefreshRowColumn(size_t row,size_t column)
405 {
406     sip_gilstate_t sipGILState;
407     PyObject *sipMeth;
408 
409     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[14],sipPySelf,SIP_NULLPTR,sipName_RefreshRowColumn);
410 
411     if (!sipMeth)
412     {
413          ::wxHVScrolledWindow::RefreshRowColumn(row,column);
414         return;
415     }
416 
417     extern void sipVH__core_129(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, size_t,size_t);
418 
419     sipVH__core_129(sipGILState, 0, sipPySelf, sipMeth, row, column);
420 }
421 
RefreshRowColumn(const::wxPosition & pos)422 void sipwxHVScrolledWindow::RefreshRowColumn(const  ::wxPosition& pos)
423 {
424     sip_gilstate_t sipGILState;
425     PyObject *sipMeth;
426 
427     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[15],sipPySelf,SIP_NULLPTR,sipName_RefreshRowColumn);
428 
429     if (!sipMeth)
430     {
431          ::wxHVScrolledWindow::RefreshRowColumn(pos);
432         return;
433     }
434 
435     extern void sipVH__core_133(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::wxPosition&);
436 
437     sipVH__core_133(sipGILState, 0, sipPySelf, sipMeth, pos);
438 }
439 
RefreshRowsColumns(size_t fromRow,size_t toRow,size_t fromColumn,size_t toColumn)440 void sipwxHVScrolledWindow::RefreshRowsColumns(size_t fromRow,size_t toRow,size_t fromColumn,size_t toColumn)
441 {
442     sip_gilstate_t sipGILState;
443     PyObject *sipMeth;
444 
445     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[16],sipPySelf,SIP_NULLPTR,sipName_RefreshRowsColumns);
446 
447     if (!sipMeth)
448     {
449          ::wxHVScrolledWindow::RefreshRowsColumns(fromRow,toRow,fromColumn,toColumn);
450         return;
451     }
452 
453     extern void sipVH__core_134(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, size_t,size_t,size_t,size_t);
454 
455     sipVH__core_134(sipGILState, 0, sipPySelf, sipMeth, fromRow, toRow, fromColumn, toColumn);
456 }
457 
RefreshRowsColumns(const::wxPosition & from,const::wxPosition & to)458 void sipwxHVScrolledWindow::RefreshRowsColumns(const  ::wxPosition& from,const  ::wxPosition& to)
459 {
460     sip_gilstate_t sipGILState;
461     PyObject *sipMeth;
462 
463     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[17],sipPySelf,SIP_NULLPTR,sipName_RefreshRowsColumns);
464 
465     if (!sipMeth)
466     {
467          ::wxHVScrolledWindow::RefreshRowsColumns(from,to);
468         return;
469     }
470 
471     extern void sipVH__core_135(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::wxPosition&,const  ::wxPosition&);
472 
473     sipVH__core_135(sipGILState, 0, sipPySelf, sipMeth, from, to);
474 }
475 
DoGetBestClientSize() const476  ::wxSize sipwxHVScrolledWindow::DoGetBestClientSize() const
477 {
478     sip_gilstate_t sipGILState;
479     PyObject *sipMeth;
480 
481     sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[18]),sipPySelf,SIP_NULLPTR,sipName_DoGetBestClientSize);
482 
483     if (!sipMeth)
484         return  ::wxHVScrolledWindow::DoGetBestClientSize();
485 
486     extern  ::wxSize sipVH__core_93(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);
487 
488     return sipVH__core_93(sipGILState, 0, sipPySelf, sipMeth);
489 }
490 
DoGetBestSize() const491  ::wxSize sipwxHVScrolledWindow::DoGetBestSize() const
492 {
493     sip_gilstate_t sipGILState;
494     PyObject *sipMeth;
495 
496     sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[19]),sipPySelf,SIP_NULLPTR,sipName_DoGetBestSize);
497 
498     if (!sipMeth)
499         return  ::wxHVScrolledWindow::DoGetBestSize();
500 
501     extern  ::wxSize sipVH__core_93(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);
502 
503     return sipVH__core_93(sipGILState, 0, sipPySelf, sipMeth);
504 }
505 
DoThaw()506 void sipwxHVScrolledWindow::DoThaw()
507 {
508     sip_gilstate_t sipGILState;
509     PyObject *sipMeth;
510 
511     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[20],sipPySelf,SIP_NULLPTR,sipName_DoThaw);
512 
513     if (!sipMeth)
514     {
515          ::wxHVScrolledWindow::DoThaw();
516         return;
517     }
518 
519     extern void sipVH__core_45(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);
520 
521     sipVH__core_45(sipGILState, 0, sipPySelf, sipMeth);
522 }
523 
DoFreeze()524 void sipwxHVScrolledWindow::DoFreeze()
525 {
526     sip_gilstate_t sipGILState;
527     PyObject *sipMeth;
528 
529     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[21],sipPySelf,SIP_NULLPTR,sipName_DoFreeze);
530 
531     if (!sipMeth)
532     {
533          ::wxHVScrolledWindow::DoFreeze();
534         return;
535     }
536 
537     extern void sipVH__core_45(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);
538 
539     sipVH__core_45(sipGILState, 0, sipPySelf, sipMeth);
540 }
541 
GetDefaultBorderForControl() const542  ::wxBorder sipwxHVScrolledWindow::GetDefaultBorderForControl() const
543 {
544     sip_gilstate_t sipGILState;
545     PyObject *sipMeth;
546 
547     sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[22]),sipPySelf,SIP_NULLPTR,sipName_GetDefaultBorderForControl);
548 
549     if (!sipMeth)
550         return  ::wxHVScrolledWindow::GetDefaultBorderForControl();
551 
552     extern  ::wxBorder sipVH__core_122(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);
553 
554     return sipVH__core_122(sipGILState, 0, sipPySelf, sipMeth);
555 }
556 
GetDefaultBorder() const557  ::wxBorder sipwxHVScrolledWindow::GetDefaultBorder() const
558 {
559     sip_gilstate_t sipGILState;
560     PyObject *sipMeth;
561 
562     sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[23]),sipPySelf,SIP_NULLPTR,sipName_GetDefaultBorder);
563 
564     if (!sipMeth)
565         return  ::wxHVScrolledWindow::GetDefaultBorder();
566 
567     extern  ::wxBorder sipVH__core_122(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);
568 
569     return sipVH__core_122(sipGILState, 0, sipPySelf, sipMeth);
570 }
571 
DoSetWindowVariant(::wxWindowVariant variant)572 void sipwxHVScrolledWindow::DoSetWindowVariant( ::wxWindowVariant variant)
573 {
574     sip_gilstate_t sipGILState;
575     PyObject *sipMeth;
576 
577     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[24],sipPySelf,SIP_NULLPTR,sipName_DoSetWindowVariant);
578 
579     if (!sipMeth)
580     {
581          ::wxHVScrolledWindow::DoSetWindowVariant(variant);
582         return;
583     }
584 
585     extern void sipVH__core_121(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::wxWindowVariant);
586 
587     sipVH__core_121(sipGILState, 0, sipPySelf, sipMeth, variant);
588 }
589 
DoMoveWindow(int x,int y,int width,int height)590 void sipwxHVScrolledWindow::DoMoveWindow(int x,int y,int width,int height)
591 {
592     sip_gilstate_t sipGILState;
593     PyObject *sipMeth;
594 
595     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[25],sipPySelf,SIP_NULLPTR,sipName_DoMoveWindow);
596 
597     if (!sipMeth)
598     {
599          ::wxHVScrolledWindow::DoMoveWindow(x,y,width,height);
600         return;
601     }
602 
603     extern void sipVH__core_120(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,int,int,int);
604 
605     sipVH__core_120(sipGILState, 0, sipPySelf, sipMeth, x, y, width, height);
606 }
607 
DoGetBorderSize() const608  ::wxSize sipwxHVScrolledWindow::DoGetBorderSize() const
609 {
610     sip_gilstate_t sipGILState;
611     PyObject *sipMeth;
612 
613     sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[26]),sipPySelf,SIP_NULLPTR,sipName_DoGetBorderSize);
614 
615     if (!sipMeth)
616         return  ::wxHVScrolledWindow::DoGetBorderSize();
617 
618     extern  ::wxSize sipVH__core_93(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);
619 
620     return sipVH__core_93(sipGILState, 0, sipPySelf, sipMeth);
621 }
622 
DoSetSizeHints(int minW,int minH,int maxW,int maxH,int incW,int incH)623 void sipwxHVScrolledWindow::DoSetSizeHints(int minW,int minH,int maxW,int maxH,int incW,int incH)
624 {
625     sip_gilstate_t sipGILState;
626     PyObject *sipMeth;
627 
628     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[27],sipPySelf,SIP_NULLPTR,sipName_DoSetSizeHints);
629 
630     if (!sipMeth)
631     {
632          ::wxHVScrolledWindow::DoSetSizeHints(minW,minH,maxW,maxH,incW,incH);
633         return;
634     }
635 
636     extern void sipVH__core_119(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,int,int,int,int,int);
637 
638     sipVH__core_119(sipGILState, 0, sipPySelf, sipMeth, minW, minH, maxW, maxH, incW, incH);
639 }
640 
DoSetClientSize(int width,int height)641 void sipwxHVScrolledWindow::DoSetClientSize(int width,int height)
642 {
643     sip_gilstate_t sipGILState;
644     PyObject *sipMeth;
645 
646     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[28],sipPySelf,SIP_NULLPTR,sipName_DoSetClientSize);
647 
648     if (!sipMeth)
649     {
650          ::wxHVScrolledWindow::DoSetClientSize(width,height);
651         return;
652     }
653 
654     extern void sipVH__core_118(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,int);
655 
656     sipVH__core_118(sipGILState, 0, sipPySelf, sipMeth, width, height);
657 }
658 
DoSetSize(int x,int y,int width,int height,int sizeFlags)659 void sipwxHVScrolledWindow::DoSetSize(int x,int y,int width,int height,int sizeFlags)
660 {
661     sip_gilstate_t sipGILState;
662     PyObject *sipMeth;
663 
664     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[29],sipPySelf,SIP_NULLPTR,sipName_DoSetSize);
665 
666     if (!sipMeth)
667     {
668          ::wxHVScrolledWindow::DoSetSize(x,y,width,height,sizeFlags);
669         return;
670     }
671 
672     extern void sipVH__core_117(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,int,int,int,int);
673 
674     sipVH__core_117(sipGILState, 0, sipPySelf, sipMeth, x, y, width, height, sizeFlags);
675 }
676 
DoGetClientSize(int * width,int * height) const677 void sipwxHVScrolledWindow::DoGetClientSize(int*width,int*height) const
678 {
679     sip_gilstate_t sipGILState;
680     PyObject *sipMeth;
681 
682     sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[30]),sipPySelf,SIP_NULLPTR,sipName_DoGetClientSize);
683 
684     if (!sipMeth)
685     {
686          ::wxHVScrolledWindow::DoGetClientSize(width,height);
687         return;
688     }
689 
690     extern void sipVH__core_116(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int*,int*);
691 
692     sipVH__core_116(sipGILState, 0, sipPySelf, sipMeth, width, height);
693 }
694 
DoGetSize(int * width,int * height) const695 void sipwxHVScrolledWindow::DoGetSize(int*width,int*height) const
696 {
697     sip_gilstate_t sipGILState;
698     PyObject *sipMeth;
699 
700     sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[31]),sipPySelf,SIP_NULLPTR,sipName_DoGetSize);
701 
702     if (!sipMeth)
703     {
704          ::wxHVScrolledWindow::DoGetSize(width,height);
705         return;
706     }
707 
708     extern void sipVH__core_116(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int*,int*);
709 
710     sipVH__core_116(sipGILState, 0, sipPySelf, sipMeth, width, height);
711 }
712 
DoGetPosition(int * x,int * y) const713 void sipwxHVScrolledWindow::DoGetPosition(int*x,int*y) const
714 {
715     sip_gilstate_t sipGILState;
716     PyObject *sipMeth;
717 
718     sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[32]),sipPySelf,SIP_NULLPTR,sipName_DoGetPosition);
719 
720     if (!sipMeth)
721     {
722          ::wxHVScrolledWindow::DoGetPosition(x,y);
723         return;
724     }
725 
726     extern void sipVH__core_116(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int*,int*);
727 
728     sipVH__core_116(sipGILState, 0, sipPySelf, sipMeth, x, y);
729 }
730 
DoEnable(bool enable)731 void sipwxHVScrolledWindow::DoEnable(bool enable)
732 {
733     sip_gilstate_t sipGILState;
734     PyObject *sipMeth;
735 
736     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[33],sipPySelf,SIP_NULLPTR,sipName_DoEnable);
737 
738     if (!sipMeth)
739     {
740          ::wxHVScrolledWindow::DoEnable(enable);
741         return;
742     }
743 
744     extern void sipVH__core_84(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, bool);
745 
746     sipVH__core_84(sipGILState, 0, sipPySelf, sipMeth, enable);
747 }
748 
GetMainWindowOfCompositeControl()749  ::wxWindow* sipwxHVScrolledWindow::GetMainWindowOfCompositeControl()
750 {
751     sip_gilstate_t sipGILState;
752     PyObject *sipMeth;
753 
754     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[34],sipPySelf,SIP_NULLPTR,sipName_GetMainWindowOfCompositeControl);
755 
756     if (!sipMeth)
757         return  ::wxHVScrolledWindow::GetMainWindowOfCompositeControl();
758 
759     extern  ::wxWindow* sipVH__core_115(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);
760 
761     return sipVH__core_115(sipGILState, 0, sipPySelf, sipMeth);
762 }
763 
OnInternalIdle()764 void sipwxHVScrolledWindow::OnInternalIdle()
765 {
766     sip_gilstate_t sipGILState;
767     PyObject *sipMeth;
768 
769     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[35],sipPySelf,SIP_NULLPTR,sipName_OnInternalIdle);
770 
771     if (!sipMeth)
772     {
773          ::wxHVScrolledWindow::OnInternalIdle();
774         return;
775     }
776 
777     extern void sipVH__core_45(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);
778 
779     sipVH__core_45(sipGILState, 0, sipPySelf, sipMeth);
780 }
781 
InitDialog()782 void sipwxHVScrolledWindow::InitDialog()
783 {
784     sip_gilstate_t sipGILState;
785     PyObject *sipMeth;
786 
787     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[36],sipPySelf,SIP_NULLPTR,sipName_InitDialog);
788 
789     if (!sipMeth)
790     {
791          ::wxHVScrolledWindow::InitDialog();
792         return;
793     }
794 
795     extern void sipVH__core_45(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);
796 
797     sipVH__core_45(sipGILState, 0, sipPySelf, sipMeth);
798 }
799 
InheritAttributes()800 void sipwxHVScrolledWindow::InheritAttributes()
801 {
802     sip_gilstate_t sipGILState;
803     PyObject *sipMeth;
804 
805     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[37],sipPySelf,SIP_NULLPTR,sipName_InheritAttributes);
806 
807     if (!sipMeth)
808     {
809          ::wxHVScrolledWindow::InheritAttributes();
810         return;
811     }
812 
813     extern void sipVH__core_45(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);
814 
815     sipVH__core_45(sipGILState, 0, sipPySelf, sipMeth);
816 }
817 
Destroy()818 bool sipwxHVScrolledWindow::Destroy()
819 {
820     sip_gilstate_t sipGILState;
821     PyObject *sipMeth;
822 
823     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[38],sipPySelf,SIP_NULLPTR,sipName_Destroy);
824 
825     if (!sipMeth)
826         return  ::wxHVScrolledWindow::Destroy();
827 
828     extern bool sipVH__core_6(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);
829 
830     return sipVH__core_6(sipGILState, 0, sipPySelf, sipMeth);
831 }
832 
Validate()833 bool sipwxHVScrolledWindow::Validate()
834 {
835     sip_gilstate_t sipGILState;
836     PyObject *sipMeth;
837 
838     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[39],sipPySelf,SIP_NULLPTR,sipName_Validate);
839 
840     if (!sipMeth)
841         return  ::wxHVScrolledWindow::Validate();
842 
843     extern bool sipVH__core_6(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);
844 
845     return sipVH__core_6(sipGILState, 0, sipPySelf, sipMeth);
846 }
847 
TransferDataToWindow()848 bool sipwxHVScrolledWindow::TransferDataToWindow()
849 {
850     sip_gilstate_t sipGILState;
851     PyObject *sipMeth;
852 
853     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[40],sipPySelf,SIP_NULLPTR,sipName_TransferDataToWindow);
854 
855     if (!sipMeth)
856         return  ::wxHVScrolledWindow::TransferDataToWindow();
857 
858     extern bool sipVH__core_6(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);
859 
860     return sipVH__core_6(sipGILState, 0, sipPySelf, sipMeth);
861 }
862 
TransferDataFromWindow()863 bool sipwxHVScrolledWindow::TransferDataFromWindow()
864 {
865     sip_gilstate_t sipGILState;
866     PyObject *sipMeth;
867 
868     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[41],sipPySelf,SIP_NULLPTR,sipName_TransferDataFromWindow);
869 
870     if (!sipMeth)
871         return  ::wxHVScrolledWindow::TransferDataFromWindow();
872 
873     extern bool sipVH__core_6(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);
874 
875     return sipVH__core_6(sipGILState, 0, sipPySelf, sipMeth);
876 }
877 
SetValidator(const::wxValidator & validator)878 void sipwxHVScrolledWindow::SetValidator(const  ::wxValidator& validator)
879 {
880     sip_gilstate_t sipGILState;
881     PyObject *sipMeth;
882 
883     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[42],sipPySelf,SIP_NULLPTR,sipName_SetValidator);
884 
885     if (!sipMeth)
886     {
887          ::wxHVScrolledWindow::SetValidator(validator);
888         return;
889     }
890 
891     extern void sipVH__core_114(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::wxValidator&);
892 
893     sipVH__core_114(sipGILState, 0, sipPySelf, sipMeth, validator);
894 }
895 
GetValidator()896  ::wxValidator* sipwxHVScrolledWindow::GetValidator()
897 {
898     sip_gilstate_t sipGILState;
899     PyObject *sipMeth;
900 
901     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[43],sipPySelf,SIP_NULLPTR,sipName_GetValidator);
902 
903     if (!sipMeth)
904         return  ::wxHVScrolledWindow::GetValidator();
905 
906     extern  ::wxValidator* sipVH__core_113(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);
907 
908     return sipVH__core_113(sipGILState, 0, sipPySelf, sipMeth);
909 }
910 
ShouldInheritColours() const911 bool sipwxHVScrolledWindow::ShouldInheritColours() const
912 {
913     sip_gilstate_t sipGILState;
914     PyObject *sipMeth;
915 
916     sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[44]),sipPySelf,SIP_NULLPTR,sipName_ShouldInheritColours);
917 
918     if (!sipMeth)
919         return  ::wxHVScrolledWindow::ShouldInheritColours();
920 
921     extern bool sipVH__core_6(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);
922 
923     return sipVH__core_6(sipGILState, 0, sipPySelf, sipMeth);
924 }
925 
HasTransparentBackground()926 bool sipwxHVScrolledWindow::HasTransparentBackground()
927 {
928     sip_gilstate_t sipGILState;
929     PyObject *sipMeth;
930 
931     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[45],sipPySelf,SIP_NULLPTR,sipName_HasTransparentBackground);
932 
933     if (!sipMeth)
934         return  ::wxHVScrolledWindow::HasTransparentBackground();
935 
936     extern bool sipVH__core_6(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);
937 
938     return sipVH__core_6(sipGILState, 0, sipPySelf, sipMeth);
939 }
940 
GetClientAreaOrigin() const941  ::wxPoint sipwxHVScrolledWindow::GetClientAreaOrigin() const
942 {
943     sip_gilstate_t sipGILState;
944     PyObject *sipMeth;
945 
946     sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[46]),sipPySelf,SIP_NULLPTR,sipName_GetClientAreaOrigin);
947 
948     if (!sipMeth)
949         return  ::wxHVScrolledWindow::GetClientAreaOrigin();
950 
951     extern  ::wxPoint sipVH__core_112(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);
952 
953     return sipVH__core_112(sipGILState, 0, sipPySelf, sipMeth);
954 }
955 
InformFirstDirection(int direction,int size,int availableOtherDir)956 bool sipwxHVScrolledWindow::InformFirstDirection(int direction,int size,int availableOtherDir)
957 {
958     sip_gilstate_t sipGILState;
959     PyObject *sipMeth;
960 
961     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[47],sipPySelf,SIP_NULLPTR,sipName_InformFirstDirection);
962 
963     if (!sipMeth)
964         return  ::wxHVScrolledWindow::InformFirstDirection(direction,size,availableOtherDir);
965 
966     extern bool sipVH__core_111(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,int,int);
967 
968     return sipVH__core_111(sipGILState, 0, sipPySelf, sipMeth, direction, size, availableOtherDir);
969 }
970 
SetCanFocus(bool canFocus)971 void sipwxHVScrolledWindow::SetCanFocus(bool canFocus)
972 {
973     sip_gilstate_t sipGILState;
974     PyObject *sipMeth;
975 
976     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[48],sipPySelf,SIP_NULLPTR,sipName_SetCanFocus);
977 
978     if (!sipMeth)
979     {
980          ::wxHVScrolledWindow::SetCanFocus(canFocus);
981         return;
982     }
983 
984     extern void sipVH__core_84(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, bool);
985 
986     sipVH__core_84(sipGILState, 0, sipPySelf, sipMeth, canFocus);
987 }
988 
AcceptsFocusRecursively() const989 bool sipwxHVScrolledWindow::AcceptsFocusRecursively() const
990 {
991     sip_gilstate_t sipGILState;
992     PyObject *sipMeth;
993 
994     sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[49]),sipPySelf,SIP_NULLPTR,sipName_AcceptsFocusRecursively);
995 
996     if (!sipMeth)
997         return  ::wxHVScrolledWindow::AcceptsFocusRecursively();
998 
999     extern bool sipVH__core_6(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);
1000 
1001     return sipVH__core_6(sipGILState, 0, sipPySelf, sipMeth);
1002 }
1003 
AcceptsFocusFromKeyboard() const1004 bool sipwxHVScrolledWindow::AcceptsFocusFromKeyboard() const
1005 {
1006     sip_gilstate_t sipGILState;
1007     PyObject *sipMeth;
1008 
1009     sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[50]),sipPySelf,SIP_NULLPTR,sipName_AcceptsFocusFromKeyboard);
1010 
1011     if (!sipMeth)
1012         return  ::wxHVScrolledWindow::AcceptsFocusFromKeyboard();
1013 
1014     extern bool sipVH__core_6(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);
1015 
1016     return sipVH__core_6(sipGILState, 0, sipPySelf, sipMeth);
1017 }
1018 
AcceptsFocus() const1019 bool sipwxHVScrolledWindow::AcceptsFocus() const
1020 {
1021     sip_gilstate_t sipGILState;
1022     PyObject *sipMeth;
1023 
1024     sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[51]),sipPySelf,SIP_NULLPTR,sipName_AcceptsFocus);
1025 
1026     if (!sipMeth)
1027         return  ::wxHVScrolledWindow::AcceptsFocus();
1028 
1029     extern bool sipVH__core_6(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);
1030 
1031     return sipVH__core_6(sipGILState, 0, sipPySelf, sipMeth);
1032 }
1033 
TryAfter(::wxEvent & event)1034 bool sipwxHVScrolledWindow::TryAfter( ::wxEvent& event)
1035 {
1036     sip_gilstate_t sipGILState;
1037     PyObject *sipMeth;
1038 
1039     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[52],sipPySelf,SIP_NULLPTR,sipName_TryAfter);
1040 
1041     if (!sipMeth)
1042         return  ::wxHVScrolledWindow::TryAfter(event);
1043 
1044     extern bool sipVH__core_90(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::wxEvent&);
1045 
1046     return sipVH__core_90(sipGILState, 0, sipPySelf, sipMeth, event);
1047 }
1048 
TryBefore(::wxEvent & event)1049 bool sipwxHVScrolledWindow::TryBefore( ::wxEvent& event)
1050 {
1051     sip_gilstate_t sipGILState;
1052     PyObject *sipMeth;
1053 
1054     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[53],sipPySelf,SIP_NULLPTR,sipName_TryBefore);
1055 
1056     if (!sipMeth)
1057         return  ::wxHVScrolledWindow::TryBefore(event);
1058 
1059     extern bool sipVH__core_90(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::wxEvent&);
1060 
1061     return sipVH__core_90(sipGILState, 0, sipPySelf, sipMeth, event);
1062 }
1063 
ProcessEvent(::wxEvent & event)1064 bool sipwxHVScrolledWindow::ProcessEvent( ::wxEvent& event)
1065 {
1066     sip_gilstate_t sipGILState;
1067     PyObject *sipMeth;
1068 
1069     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[54],sipPySelf,SIP_NULLPTR,sipName_ProcessEvent);
1070 
1071     if (!sipMeth)
1072         return  ::wxHVScrolledWindow::ProcessEvent(event);
1073 
1074     extern bool sipVH__core_90(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::wxEvent&);
1075 
1076     return sipVH__core_90(sipGILState, 0, sipPySelf, sipMeth, event);
1077 }
1078 
AddChild(::wxWindowBase * child)1079 void sipwxHVScrolledWindow::AddChild( ::wxWindowBase*child)
1080 {
1081     sip_gilstate_t sipGILState;
1082     PyObject *sipMeth;
1083 
1084     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[55],sipPySelf,SIP_NULLPTR,sipName_AddChild);
1085 
1086     if (!sipMeth)
1087     {
1088          ::wxHVScrolledWindow::AddChild(child);
1089         return;
1090     }
1091 
1092     extern void sipVH__core_110(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::wxWindowBase*);
1093 
1094     sipVH__core_110(sipGILState, 0, sipPySelf, sipMeth, child);
1095 }
1096 
RemoveChild(::wxWindowBase * child)1097 void sipwxHVScrolledWindow::RemoveChild( ::wxWindowBase*child)
1098 {
1099     sip_gilstate_t sipGILState;
1100     PyObject *sipMeth;
1101 
1102     sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[56],sipPySelf,SIP_NULLPTR,sipName_RemoveChild);
1103 
1104     if (!sipMeth)
1105     {
1106          ::wxHVScrolledWindow::RemoveChild(child);
1107         return;
1108     }
1109 
1110     extern void sipVH__core_110(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::wxWindowBase*);
1111 
1112     sipVH__core_110(sipGILState, 0, sipPySelf, sipMeth, child);
1113 }
1114 
sipProtectVirt_EstimateTotalWidth(bool sipSelfWasArg) const1115  ::wxCoord sipwxHVScrolledWindow::sipProtectVirt_EstimateTotalWidth(bool sipSelfWasArg) const
1116 {
1117     return (sipSelfWasArg ?  ::wxVarHScrollHelper::EstimateTotalWidth() : EstimateTotalWidth());
1118 }
1119 
sipProtectVirt_OnGetColumnsWidthHint(bool sipSelfWasArg,size_t columnMin,size_t columnMax) const1120 void sipwxHVScrolledWindow::sipProtectVirt_OnGetColumnsWidthHint(bool sipSelfWasArg,size_t columnMin,size_t columnMax) const
1121 {
1122     (sipSelfWasArg ?  ::wxVarHScrollHelper::OnGetColumnsWidthHint(columnMin,columnMax) : OnGetColumnsWidthHint(columnMin,columnMax));
1123 }
1124 
sipProtect_OnGetColumnWidth(size_t column) const1125  ::wxCoord sipwxHVScrolledWindow::sipProtect_OnGetColumnWidth(size_t column) const
1126 {
1127     return OnGetColumnWidth(column);
1128 }
1129 
sipProtectVirt_OnGetRowsHeightHint(bool sipSelfWasArg,size_t rowMin,size_t rowMax) const1130 void sipwxHVScrolledWindow::sipProtectVirt_OnGetRowsHeightHint(bool sipSelfWasArg,size_t rowMin,size_t rowMax) const
1131 {
1132     (sipSelfWasArg ?  ::wxVarVScrollHelper::OnGetRowsHeightHint(rowMin,rowMax) : OnGetRowsHeightHint(rowMin,rowMax));
1133 }
1134 
sipProtectVirt_EstimateTotalHeight(bool sipSelfWasArg) const1135  ::wxCoord sipwxHVScrolledWindow::sipProtectVirt_EstimateTotalHeight(bool sipSelfWasArg) const
1136 {
1137     return (sipSelfWasArg ?  ::wxVarVScrollHelper::EstimateTotalHeight() : EstimateTotalHeight());
1138 }
1139 
sipProtect_OnGetRowHeight(size_t row) const1140  ::wxCoord sipwxHVScrolledWindow::sipProtect_OnGetRowHeight(size_t row) const
1141 {
1142     return OnGetRowHeight(row);
1143 }
1144 
sipProtect_SendDestroyEvent()1145 void sipwxHVScrolledWindow::sipProtect_SendDestroyEvent()
1146 {
1147      ::wxWindow::SendDestroyEvent();
1148 }
1149 
sipProtectVirt_ProcessEvent(bool sipSelfWasArg,::wxEvent & event)1150 bool sipwxHVScrolledWindow::sipProtectVirt_ProcessEvent(bool sipSelfWasArg, ::wxEvent& event)
1151 {
1152     return (sipSelfWasArg ?  ::wxHVScrolledWindow::ProcessEvent(event) : ProcessEvent(event));
1153 }
1154 
sipProtectVirt_DoEnable(bool sipSelfWasArg,bool enable)1155 void sipwxHVScrolledWindow::sipProtectVirt_DoEnable(bool sipSelfWasArg,bool enable)
1156 {
1157     (sipSelfWasArg ?  ::wxHVScrolledWindow::DoEnable(enable) : DoEnable(enable));
1158 }
1159 
sipProtectVirt_DoGetPosition(bool sipSelfWasArg,int * x,int * y) const1160 void sipwxHVScrolledWindow::sipProtectVirt_DoGetPosition(bool sipSelfWasArg,int*x,int*y) const
1161 {
1162     (sipSelfWasArg ?  ::wxHVScrolledWindow::DoGetPosition(x,y) : DoGetPosition(x,y));
1163 }
1164 
sipProtectVirt_DoGetSize(bool sipSelfWasArg,int * width,int * height) const1165 void sipwxHVScrolledWindow::sipProtectVirt_DoGetSize(bool sipSelfWasArg,int*width,int*height) const
1166 {
1167     (sipSelfWasArg ?  ::wxHVScrolledWindow::DoGetSize(width,height) : DoGetSize(width,height));
1168 }
1169 
sipProtectVirt_DoGetClientSize(bool sipSelfWasArg,int * width,int * height) const1170 void sipwxHVScrolledWindow::sipProtectVirt_DoGetClientSize(bool sipSelfWasArg,int*width,int*height) const
1171 {
1172     (sipSelfWasArg ?  ::wxHVScrolledWindow::DoGetClientSize(width,height) : DoGetClientSize(width,height));
1173 }
1174 
sipProtectVirt_DoGetBestSize(bool sipSelfWasArg) const1175  ::wxSize sipwxHVScrolledWindow::sipProtectVirt_DoGetBestSize(bool sipSelfWasArg) const
1176 {
1177     return (sipSelfWasArg ?  ::wxHVScrolledWindow::DoGetBestSize() : DoGetBestSize());
1178 }
1179 
sipProtectVirt_DoGetBestClientSize(bool sipSelfWasArg) const1180  ::wxSize sipwxHVScrolledWindow::sipProtectVirt_DoGetBestClientSize(bool sipSelfWasArg) const
1181 {
1182     return (sipSelfWasArg ?  ::wxHVScrolledWindow::DoGetBestClientSize() : DoGetBestClientSize());
1183 }
1184 
sipProtectVirt_DoSetSize(bool sipSelfWasArg,int x,int y,int width,int height,int sizeFlags)1185 void sipwxHVScrolledWindow::sipProtectVirt_DoSetSize(bool sipSelfWasArg,int x,int y,int width,int height,int sizeFlags)
1186 {
1187     (sipSelfWasArg ?  ::wxHVScrolledWindow::DoSetSize(x,y,width,height,sizeFlags) : DoSetSize(x,y,width,height,sizeFlags));
1188 }
1189 
sipProtectVirt_DoSetClientSize(bool sipSelfWasArg,int width,int height)1190 void sipwxHVScrolledWindow::sipProtectVirt_DoSetClientSize(bool sipSelfWasArg,int width,int height)
1191 {
1192     (sipSelfWasArg ?  ::wxHVScrolledWindow::DoSetClientSize(width,height) : DoSetClientSize(width,height));
1193 }
1194 
sipProtectVirt_DoSetSizeHints(bool sipSelfWasArg,int minW,int minH,int maxW,int maxH,int incW,int incH)1195 void sipwxHVScrolledWindow::sipProtectVirt_DoSetSizeHints(bool sipSelfWasArg,int minW,int minH,int maxW,int maxH,int incW,int incH)
1196 {
1197     (sipSelfWasArg ?  ::wxHVScrolledWindow::DoSetSizeHints(minW,minH,maxW,maxH,incW,incH) : DoSetSizeHints(minW,minH,maxW,maxH,incW,incH));
1198 }
1199 
sipProtectVirt_DoGetBorderSize(bool sipSelfWasArg) const1200  ::wxSize sipwxHVScrolledWindow::sipProtectVirt_DoGetBorderSize(bool sipSelfWasArg) const
1201 {
1202     return (sipSelfWasArg ?  ::wxHVScrolledWindow::DoGetBorderSize() : DoGetBorderSize());
1203 }
1204 
sipProtectVirt_DoMoveWindow(bool sipSelfWasArg,int x,int y,int width,int height)1205 void sipwxHVScrolledWindow::sipProtectVirt_DoMoveWindow(bool sipSelfWasArg,int x,int y,int width,int height)
1206 {
1207     (sipSelfWasArg ?  ::wxHVScrolledWindow::DoMoveWindow(x,y,width,height) : DoMoveWindow(x,y,width,height));
1208 }
1209 
sipProtectVirt_DoSetWindowVariant(bool sipSelfWasArg,::wxWindowVariant variant)1210 void sipwxHVScrolledWindow::sipProtectVirt_DoSetWindowVariant(bool sipSelfWasArg, ::wxWindowVariant variant)
1211 {
1212     (sipSelfWasArg ?  ::wxHVScrolledWindow::DoSetWindowVariant(variant) : DoSetWindowVariant(variant));
1213 }
1214 
sipProtectVirt_GetDefaultBorder(bool sipSelfWasArg) const1215  ::wxBorder sipwxHVScrolledWindow::sipProtectVirt_GetDefaultBorder(bool sipSelfWasArg) const
1216 {
1217     return (sipSelfWasArg ?  ::wxHVScrolledWindow::GetDefaultBorder() : GetDefaultBorder());
1218 }
1219 
sipProtectVirt_GetDefaultBorderForControl(bool sipSelfWasArg) const1220  ::wxBorder sipwxHVScrolledWindow::sipProtectVirt_GetDefaultBorderForControl(bool sipSelfWasArg) const
1221 {
1222     return (sipSelfWasArg ?  ::wxHVScrolledWindow::GetDefaultBorderForControl() : GetDefaultBorderForControl());
1223 }
1224 
sipProtectVirt_DoFreeze(bool sipSelfWasArg)1225 void sipwxHVScrolledWindow::sipProtectVirt_DoFreeze(bool sipSelfWasArg)
1226 {
1227     (sipSelfWasArg ?  ::wxHVScrolledWindow::DoFreeze() : DoFreeze());
1228 }
1229 
sipProtectVirt_DoThaw(bool sipSelfWasArg)1230 void sipwxHVScrolledWindow::sipProtectVirt_DoThaw(bool sipSelfWasArg)
1231 {
1232     (sipSelfWasArg ?  ::wxHVScrolledWindow::DoThaw() : DoThaw());
1233 }
1234 
sipProtectVirt_HasTransparentBackground(bool sipSelfWasArg)1235 bool sipwxHVScrolledWindow::sipProtectVirt_HasTransparentBackground(bool sipSelfWasArg)
1236 {
1237     return (sipSelfWasArg ?  ::wxHVScrolledWindow::HasTransparentBackground() : HasTransparentBackground());
1238 }
1239 
sipProtectVirt_TryBefore(bool sipSelfWasArg,::wxEvent & event)1240 bool sipwxHVScrolledWindow::sipProtectVirt_TryBefore(bool sipSelfWasArg, ::wxEvent& event)
1241 {
1242     return (sipSelfWasArg ?  ::wxHVScrolledWindow::TryBefore(event) : TryBefore(event));
1243 }
1244 
sipProtectVirt_TryAfter(bool sipSelfWasArg,::wxEvent & event)1245 bool sipwxHVScrolledWindow::sipProtectVirt_TryAfter(bool sipSelfWasArg, ::wxEvent& event)
1246 {
1247     return (sipSelfWasArg ?  ::wxHVScrolledWindow::TryAfter(event) : TryAfter(event));
1248 }
1249 
1250 
1251 PyDoc_STRVAR(doc_wxHVScrolledWindow_EstimateTotalWidth, "EstimateTotalWidth() -> Coord\n"
1252 "\n"
1253 "This class forwards calls from EstimateTotalSize() to this function so\n"
1254 "derived classes can override either just the height or the width\n"
1255 "estimation, or just estimate both differently if desired in any\n"
1256 "wxHVScrolledWindow derived class.");
1257 
1258 extern "C" {static PyObject *meth_wxHVScrolledWindow_EstimateTotalWidth(PyObject *, PyObject *);}
meth_wxHVScrolledWindow_EstimateTotalWidth(PyObject * sipSelf,PyObject * sipArgs)1259 static PyObject *meth_wxHVScrolledWindow_EstimateTotalWidth(PyObject *sipSelf, PyObject *sipArgs)
1260 {
1261     PyObject *sipParseErr = SIP_NULLPTR;
1262     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
1263 
1264     {
1265         const sipwxHVScrolledWindow *sipCpp;
1266 
1267         if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp))
1268         {
1269              ::wxCoord sipRes;
1270 
1271             PyErr_Clear();
1272 
1273             Py_BEGIN_ALLOW_THREADS
1274             sipRes = sipCpp->sipProtectVirt_EstimateTotalWidth(sipSelfWasArg);
1275             Py_END_ALLOW_THREADS
1276 
1277             if (PyErr_Occurred())
1278                 return 0;
1279 
1280             return SIPLong_FromLong(sipRes);
1281         }
1282     }
1283 
1284     /* Raise an exception if the arguments couldn't be parsed. */
1285     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_EstimateTotalWidth, SIP_NULLPTR);
1286 
1287     return SIP_NULLPTR;
1288 }
1289 
1290 
1291 PyDoc_STRVAR(doc_wxHVScrolledWindow_OnGetColumnsWidthHint, "OnGetColumnsWidthHint(columnMin, columnMax)\n"
1292 "\n"
1293 "This function doesn't have to be overridden but it may be useful to do\n"
1294 "so if calculating the columns' sizes is a relatively expensive\n"
1295 "operation as it gives your code a chance to calculate several of them\n"
1296 "at once and cache the result if necessary.");
1297 
1298 extern "C" {static PyObject *meth_wxHVScrolledWindow_OnGetColumnsWidthHint(PyObject *, PyObject *, PyObject *);}
meth_wxHVScrolledWindow_OnGetColumnsWidthHint(PyObject * sipSelf,PyObject * sipArgs,PyObject * sipKwds)1299 static PyObject *meth_wxHVScrolledWindow_OnGetColumnsWidthHint(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
1300 {
1301     PyObject *sipParseErr = SIP_NULLPTR;
1302     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
1303 
1304     {
1305         size_t columnMin;
1306         size_t columnMax;
1307         const sipwxHVScrolledWindow *sipCpp;
1308 
1309         static const char *sipKwdList[] = {
1310             sipName_columnMin,
1311             sipName_columnMax,
1312         };
1313 
1314         if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "B==", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp, &columnMin, &columnMax))
1315         {
1316             PyErr_Clear();
1317 
1318             Py_BEGIN_ALLOW_THREADS
1319             sipCpp->sipProtectVirt_OnGetColumnsWidthHint(sipSelfWasArg,columnMin,columnMax);
1320             Py_END_ALLOW_THREADS
1321 
1322             if (PyErr_Occurred())
1323                 return 0;
1324 
1325             Py_INCREF(Py_None);
1326             return Py_None;
1327         }
1328     }
1329 
1330     /* Raise an exception if the arguments couldn't be parsed. */
1331     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_OnGetColumnsWidthHint, SIP_NULLPTR);
1332 
1333     return SIP_NULLPTR;
1334 }
1335 
1336 
1337 PyDoc_STRVAR(doc_wxHVScrolledWindow_OnGetColumnWidth, "OnGetColumnWidth(column) -> Coord\n"
1338 "\n"
1339 "This function must be overridden in the derived class, and should\n"
1340 "return the width of the given column in pixels.");
1341 
1342 extern "C" {static PyObject *meth_wxHVScrolledWindow_OnGetColumnWidth(PyObject *, PyObject *, PyObject *);}
meth_wxHVScrolledWindow_OnGetColumnWidth(PyObject * sipSelf,PyObject * sipArgs,PyObject * sipKwds)1343 static PyObject *meth_wxHVScrolledWindow_OnGetColumnWidth(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
1344 {
1345     PyObject *sipParseErr = SIP_NULLPTR;
1346     PyObject *sipOrigSelf = sipSelf;
1347 
1348     {
1349         size_t column;
1350         const sipwxHVScrolledWindow *sipCpp;
1351 
1352         static const char *sipKwdList[] = {
1353             sipName_column,
1354         };
1355 
1356         if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "B=", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp, &column))
1357         {
1358              ::wxCoord sipRes;
1359 
1360             if (!sipOrigSelf)
1361             {
1362                 sipAbstractMethod(sipName_HVScrolledWindow, sipName_OnGetColumnWidth);
1363                 return SIP_NULLPTR;
1364             }
1365 
1366             PyErr_Clear();
1367 
1368             Py_BEGIN_ALLOW_THREADS
1369             sipRes = sipCpp->sipProtect_OnGetColumnWidth(column);
1370             Py_END_ALLOW_THREADS
1371 
1372             if (PyErr_Occurred())
1373                 return 0;
1374 
1375             return SIPLong_FromLong(sipRes);
1376         }
1377     }
1378 
1379     /* Raise an exception if the arguments couldn't be parsed. */
1380     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_OnGetColumnWidth, SIP_NULLPTR);
1381 
1382     return SIP_NULLPTR;
1383 }
1384 
1385 
1386 PyDoc_STRVAR(doc_wxHVScrolledWindow_OnGetRowsHeightHint, "OnGetRowsHeightHint(rowMin, rowMax)\n"
1387 "\n"
1388 "This function doesn't have to be overridden but it may be useful to do\n"
1389 "so if calculating the rows' sizes is a relatively expensive operation\n"
1390 "as it gives your code a chance to calculate several of them at once\n"
1391 "and cache the result if necessary.");
1392 
1393 extern "C" {static PyObject *meth_wxHVScrolledWindow_OnGetRowsHeightHint(PyObject *, PyObject *, PyObject *);}
meth_wxHVScrolledWindow_OnGetRowsHeightHint(PyObject * sipSelf,PyObject * sipArgs,PyObject * sipKwds)1394 static PyObject *meth_wxHVScrolledWindow_OnGetRowsHeightHint(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
1395 {
1396     PyObject *sipParseErr = SIP_NULLPTR;
1397     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
1398 
1399     {
1400         size_t rowMin;
1401         size_t rowMax;
1402         const sipwxHVScrolledWindow *sipCpp;
1403 
1404         static const char *sipKwdList[] = {
1405             sipName_rowMin,
1406             sipName_rowMax,
1407         };
1408 
1409         if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "B==", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp, &rowMin, &rowMax))
1410         {
1411             PyErr_Clear();
1412 
1413             Py_BEGIN_ALLOW_THREADS
1414             sipCpp->sipProtectVirt_OnGetRowsHeightHint(sipSelfWasArg,rowMin,rowMax);
1415             Py_END_ALLOW_THREADS
1416 
1417             if (PyErr_Occurred())
1418                 return 0;
1419 
1420             Py_INCREF(Py_None);
1421             return Py_None;
1422         }
1423     }
1424 
1425     /* Raise an exception if the arguments couldn't be parsed. */
1426     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_OnGetRowsHeightHint, SIP_NULLPTR);
1427 
1428     return SIP_NULLPTR;
1429 }
1430 
1431 
1432 PyDoc_STRVAR(doc_wxHVScrolledWindow_EstimateTotalHeight, "EstimateTotalHeight() -> Coord\n"
1433 "\n"
1434 "This class forwards calls from EstimateTotalSize() to this function so\n"
1435 "derived classes can override either just the height or the width\n"
1436 "estimation, or just estimate both differently if desired in any\n"
1437 "wxHVScrolledWindow derived class.");
1438 
1439 extern "C" {static PyObject *meth_wxHVScrolledWindow_EstimateTotalHeight(PyObject *, PyObject *);}
meth_wxHVScrolledWindow_EstimateTotalHeight(PyObject * sipSelf,PyObject * sipArgs)1440 static PyObject *meth_wxHVScrolledWindow_EstimateTotalHeight(PyObject *sipSelf, PyObject *sipArgs)
1441 {
1442     PyObject *sipParseErr = SIP_NULLPTR;
1443     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
1444 
1445     {
1446         const sipwxHVScrolledWindow *sipCpp;
1447 
1448         if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp))
1449         {
1450              ::wxCoord sipRes;
1451 
1452             PyErr_Clear();
1453 
1454             Py_BEGIN_ALLOW_THREADS
1455             sipRes = sipCpp->sipProtectVirt_EstimateTotalHeight(sipSelfWasArg);
1456             Py_END_ALLOW_THREADS
1457 
1458             if (PyErr_Occurred())
1459                 return 0;
1460 
1461             return SIPLong_FromLong(sipRes);
1462         }
1463     }
1464 
1465     /* Raise an exception if the arguments couldn't be parsed. */
1466     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_EstimateTotalHeight, SIP_NULLPTR);
1467 
1468     return SIP_NULLPTR;
1469 }
1470 
1471 
1472 PyDoc_STRVAR(doc_wxHVScrolledWindow_OnGetRowHeight, "OnGetRowHeight(row) -> Coord\n"
1473 "\n"
1474 "This function must be overridden in the derived class, and should\n"
1475 "return the height of the given row in pixels.");
1476 
1477 extern "C" {static PyObject *meth_wxHVScrolledWindow_OnGetRowHeight(PyObject *, PyObject *, PyObject *);}
meth_wxHVScrolledWindow_OnGetRowHeight(PyObject * sipSelf,PyObject * sipArgs,PyObject * sipKwds)1478 static PyObject *meth_wxHVScrolledWindow_OnGetRowHeight(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
1479 {
1480     PyObject *sipParseErr = SIP_NULLPTR;
1481     PyObject *sipOrigSelf = sipSelf;
1482 
1483     {
1484         size_t row;
1485         const sipwxHVScrolledWindow *sipCpp;
1486 
1487         static const char *sipKwdList[] = {
1488             sipName_row,
1489         };
1490 
1491         if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "B=", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp, &row))
1492         {
1493              ::wxCoord sipRes;
1494 
1495             if (!sipOrigSelf)
1496             {
1497                 sipAbstractMethod(sipName_HVScrolledWindow, sipName_OnGetRowHeight);
1498                 return SIP_NULLPTR;
1499             }
1500 
1501             PyErr_Clear();
1502 
1503             Py_BEGIN_ALLOW_THREADS
1504             sipRes = sipCpp->sipProtect_OnGetRowHeight(row);
1505             Py_END_ALLOW_THREADS
1506 
1507             if (PyErr_Occurred())
1508                 return 0;
1509 
1510             return SIPLong_FromLong(sipRes);
1511         }
1512     }
1513 
1514     /* Raise an exception if the arguments couldn't be parsed. */
1515     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_OnGetRowHeight, SIP_NULLPTR);
1516 
1517     return SIP_NULLPTR;
1518 }
1519 
1520 
1521 PyDoc_STRVAR(doc_wxHVScrolledWindow_SendDestroyEvent, "SendDestroyEvent()\n"
1522 "\n"
1523 "Generate wxWindowDestroyEvent for this window.");
1524 
1525 extern "C" {static PyObject *meth_wxHVScrolledWindow_SendDestroyEvent(PyObject *, PyObject *);}
meth_wxHVScrolledWindow_SendDestroyEvent(PyObject * sipSelf,PyObject * sipArgs)1526 static PyObject *meth_wxHVScrolledWindow_SendDestroyEvent(PyObject *sipSelf, PyObject *sipArgs)
1527 {
1528     PyObject *sipParseErr = SIP_NULLPTR;
1529 
1530     {
1531         sipwxHVScrolledWindow *sipCpp;
1532 
1533         if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp))
1534         {
1535             PyErr_Clear();
1536 
1537             Py_BEGIN_ALLOW_THREADS
1538             sipCpp->sipProtect_SendDestroyEvent();
1539             Py_END_ALLOW_THREADS
1540 
1541             if (PyErr_Occurred())
1542                 return 0;
1543 
1544             Py_INCREF(Py_None);
1545             return Py_None;
1546         }
1547     }
1548 
1549     /* Raise an exception if the arguments couldn't be parsed. */
1550     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_SendDestroyEvent, SIP_NULLPTR);
1551 
1552     return SIP_NULLPTR;
1553 }
1554 
1555 
1556 PyDoc_STRVAR(doc_wxHVScrolledWindow_Create, "Create(parent, id=ID_ANY, pos=DefaultPosition, size=DefaultSize, style=0, name=PanelNameStr) -> bool\n"
1557 "\n"
1558 "Same as the non-default constructor, but returns a status code: true\n"
1559 "if ok, false if the window couldn't be created.");
1560 
1561 extern "C" {static PyObject *meth_wxHVScrolledWindow_Create(PyObject *, PyObject *, PyObject *);}
meth_wxHVScrolledWindow_Create(PyObject * sipSelf,PyObject * sipArgs,PyObject * sipKwds)1562 static PyObject *meth_wxHVScrolledWindow_Create(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
1563 {
1564     PyObject *sipParseErr = SIP_NULLPTR;
1565 
1566     {
1567          ::wxWindow* parent;
1568          ::wxWindowID id = wxID_ANY;
1569         const  ::wxPoint& posdef = wxDefaultPosition;
1570         const  ::wxPoint* pos = &posdef;
1571         int posState = 0;
1572         const  ::wxSize& sizedef = wxDefaultSize;
1573         const  ::wxSize* size = &sizedef;
1574         int sizeState = 0;
1575         long style = 0;
1576         const  ::wxString& namedef = wxPanelNameStr;
1577         const  ::wxString* name = &namedef;
1578         int nameState = 0;
1579         sipWrapper *sipOwner = SIP_NULLPTR;
1580          ::wxHVScrolledWindow *sipCpp;
1581 
1582         static const char *sipKwdList[] = {
1583             sipName_parent,
1584             sipName_id,
1585             sipName_pos,
1586             sipName_size,
1587             sipName_style,
1588             sipName_name,
1589         };
1590 
1591         if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJH|iJ1J1lJ1", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp, sipType_wxWindow, &parent, &sipOwner, &id, sipType_wxPoint, &pos, &posState, sipType_wxSize, &size, &sizeState, &style, sipType_wxString,&name, &nameState))
1592         {
1593             bool sipRes;
1594 
1595             PyErr_Clear();
1596 
1597             Py_BEGIN_ALLOW_THREADS
1598             sipRes = sipCpp->Create(parent,id,*pos,*size,style,*name);
1599             Py_END_ALLOW_THREADS
1600 
1601             if (sipOwner)
1602                 sipTransferTo(sipSelf, (PyObject *)sipOwner);
1603             else
1604                 sipTransferBack(sipSelf);
1605             sipReleaseType(const_cast< ::wxPoint *>(pos),sipType_wxPoint,posState);
1606             sipReleaseType(const_cast< ::wxSize *>(size),sipType_wxSize,sizeState);
1607             sipReleaseType(const_cast< ::wxString *>(name),sipType_wxString,nameState);
1608 
1609             if (PyErr_Occurred())
1610                 return 0;
1611 
1612             return PyBool_FromLong(sipRes);
1613         }
1614     }
1615 
1616     /* Raise an exception if the arguments couldn't be parsed. */
1617     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_Create, SIP_NULLPTR);
1618 
1619     return SIP_NULLPTR;
1620 }
1621 
1622 
1623 PyDoc_STRVAR(doc_wxHVScrolledWindow_GetClientAreaOrigin, "GetClientAreaOrigin(self) -> Point");
1624 
1625 extern "C" {static PyObject *meth_wxHVScrolledWindow_GetClientAreaOrigin(PyObject *, PyObject *);}
meth_wxHVScrolledWindow_GetClientAreaOrigin(PyObject * sipSelf,PyObject * sipArgs)1626 static PyObject *meth_wxHVScrolledWindow_GetClientAreaOrigin(PyObject *sipSelf, PyObject *sipArgs)
1627 {
1628     PyObject *sipParseErr = SIP_NULLPTR;
1629     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
1630 
1631     {
1632         const  ::wxHVScrolledWindow *sipCpp;
1633 
1634         if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp))
1635         {
1636              ::wxPoint*sipRes;
1637 
1638             PyErr_Clear();
1639 
1640             Py_BEGIN_ALLOW_THREADS
1641             sipRes = new  ::wxPoint((sipSelfWasArg ? sipCpp-> ::wxHVScrolledWindow::GetClientAreaOrigin() : sipCpp->GetClientAreaOrigin()));
1642             Py_END_ALLOW_THREADS
1643 
1644             if (PyErr_Occurred())
1645                 return 0;
1646 
1647             return sipConvertFromNewType(sipRes,sipType_wxPoint,SIP_NULLPTR);
1648         }
1649     }
1650 
1651     /* Raise an exception if the arguments couldn't be parsed. */
1652     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_GetClientAreaOrigin, doc_wxHVScrolledWindow_GetClientAreaOrigin);
1653 
1654     return SIP_NULLPTR;
1655 }
1656 
1657 
1658 PyDoc_STRVAR(doc_wxHVScrolledWindow_Validate, "Validate(self) -> bool");
1659 
1660 extern "C" {static PyObject *meth_wxHVScrolledWindow_Validate(PyObject *, PyObject *);}
meth_wxHVScrolledWindow_Validate(PyObject * sipSelf,PyObject * sipArgs)1661 static PyObject *meth_wxHVScrolledWindow_Validate(PyObject *sipSelf, PyObject *sipArgs)
1662 {
1663     PyObject *sipParseErr = SIP_NULLPTR;
1664     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
1665 
1666     {
1667          ::wxHVScrolledWindow *sipCpp;
1668 
1669         if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp))
1670         {
1671             bool sipRes;
1672 
1673             PyErr_Clear();
1674 
1675             Py_BEGIN_ALLOW_THREADS
1676             sipRes = (sipSelfWasArg ? sipCpp-> ::wxHVScrolledWindow::Validate() : sipCpp->Validate());
1677             Py_END_ALLOW_THREADS
1678 
1679             if (PyErr_Occurred())
1680                 return 0;
1681 
1682             return PyBool_FromLong(sipRes);
1683         }
1684     }
1685 
1686     /* Raise an exception if the arguments couldn't be parsed. */
1687     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_Validate, doc_wxHVScrolledWindow_Validate);
1688 
1689     return SIP_NULLPTR;
1690 }
1691 
1692 
1693 PyDoc_STRVAR(doc_wxHVScrolledWindow_TransferDataToWindow, "TransferDataToWindow(self) -> bool");
1694 
1695 extern "C" {static PyObject *meth_wxHVScrolledWindow_TransferDataToWindow(PyObject *, PyObject *);}
meth_wxHVScrolledWindow_TransferDataToWindow(PyObject * sipSelf,PyObject * sipArgs)1696 static PyObject *meth_wxHVScrolledWindow_TransferDataToWindow(PyObject *sipSelf, PyObject *sipArgs)
1697 {
1698     PyObject *sipParseErr = SIP_NULLPTR;
1699     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
1700 
1701     {
1702          ::wxHVScrolledWindow *sipCpp;
1703 
1704         if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp))
1705         {
1706             bool sipRes;
1707 
1708             PyErr_Clear();
1709 
1710             Py_BEGIN_ALLOW_THREADS
1711             sipRes = (sipSelfWasArg ? sipCpp-> ::wxHVScrolledWindow::TransferDataToWindow() : sipCpp->TransferDataToWindow());
1712             Py_END_ALLOW_THREADS
1713 
1714             if (PyErr_Occurred())
1715                 return 0;
1716 
1717             return PyBool_FromLong(sipRes);
1718         }
1719     }
1720 
1721     /* Raise an exception if the arguments couldn't be parsed. */
1722     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_TransferDataToWindow, doc_wxHVScrolledWindow_TransferDataToWindow);
1723 
1724     return SIP_NULLPTR;
1725 }
1726 
1727 
1728 PyDoc_STRVAR(doc_wxHVScrolledWindow_TransferDataFromWindow, "TransferDataFromWindow(self) -> bool");
1729 
1730 extern "C" {static PyObject *meth_wxHVScrolledWindow_TransferDataFromWindow(PyObject *, PyObject *);}
meth_wxHVScrolledWindow_TransferDataFromWindow(PyObject * sipSelf,PyObject * sipArgs)1731 static PyObject *meth_wxHVScrolledWindow_TransferDataFromWindow(PyObject *sipSelf, PyObject *sipArgs)
1732 {
1733     PyObject *sipParseErr = SIP_NULLPTR;
1734     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
1735 
1736     {
1737          ::wxHVScrolledWindow *sipCpp;
1738 
1739         if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp))
1740         {
1741             bool sipRes;
1742 
1743             PyErr_Clear();
1744 
1745             Py_BEGIN_ALLOW_THREADS
1746             sipRes = (sipSelfWasArg ? sipCpp-> ::wxHVScrolledWindow::TransferDataFromWindow() : sipCpp->TransferDataFromWindow());
1747             Py_END_ALLOW_THREADS
1748 
1749             if (PyErr_Occurred())
1750                 return 0;
1751 
1752             return PyBool_FromLong(sipRes);
1753         }
1754     }
1755 
1756     /* Raise an exception if the arguments couldn't be parsed. */
1757     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_TransferDataFromWindow, doc_wxHVScrolledWindow_TransferDataFromWindow);
1758 
1759     return SIP_NULLPTR;
1760 }
1761 
1762 
1763 PyDoc_STRVAR(doc_wxHVScrolledWindow_InitDialog, "InitDialog(self)");
1764 
1765 extern "C" {static PyObject *meth_wxHVScrolledWindow_InitDialog(PyObject *, PyObject *);}
meth_wxHVScrolledWindow_InitDialog(PyObject * sipSelf,PyObject * sipArgs)1766 static PyObject *meth_wxHVScrolledWindow_InitDialog(PyObject *sipSelf, PyObject *sipArgs)
1767 {
1768     PyObject *sipParseErr = SIP_NULLPTR;
1769     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
1770 
1771     {
1772          ::wxHVScrolledWindow *sipCpp;
1773 
1774         if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp))
1775         {
1776             PyErr_Clear();
1777 
1778             Py_BEGIN_ALLOW_THREADS
1779             (sipSelfWasArg ? sipCpp-> ::wxHVScrolledWindow::InitDialog() : sipCpp->InitDialog());
1780             Py_END_ALLOW_THREADS
1781 
1782             if (PyErr_Occurred())
1783                 return 0;
1784 
1785             Py_INCREF(Py_None);
1786             return Py_None;
1787         }
1788     }
1789 
1790     /* Raise an exception if the arguments couldn't be parsed. */
1791     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_InitDialog, doc_wxHVScrolledWindow_InitDialog);
1792 
1793     return SIP_NULLPTR;
1794 }
1795 
1796 
1797 PyDoc_STRVAR(doc_wxHVScrolledWindow_AcceptsFocus, "AcceptsFocus(self) -> bool");
1798 
1799 extern "C" {static PyObject *meth_wxHVScrolledWindow_AcceptsFocus(PyObject *, PyObject *);}
meth_wxHVScrolledWindow_AcceptsFocus(PyObject * sipSelf,PyObject * sipArgs)1800 static PyObject *meth_wxHVScrolledWindow_AcceptsFocus(PyObject *sipSelf, PyObject *sipArgs)
1801 {
1802     PyObject *sipParseErr = SIP_NULLPTR;
1803     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
1804 
1805     {
1806         const  ::wxHVScrolledWindow *sipCpp;
1807 
1808         if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp))
1809         {
1810             bool sipRes;
1811 
1812             PyErr_Clear();
1813 
1814             Py_BEGIN_ALLOW_THREADS
1815             sipRes = (sipSelfWasArg ? sipCpp-> ::wxHVScrolledWindow::AcceptsFocus() : sipCpp->AcceptsFocus());
1816             Py_END_ALLOW_THREADS
1817 
1818             if (PyErr_Occurred())
1819                 return 0;
1820 
1821             return PyBool_FromLong(sipRes);
1822         }
1823     }
1824 
1825     /* Raise an exception if the arguments couldn't be parsed. */
1826     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_AcceptsFocus, doc_wxHVScrolledWindow_AcceptsFocus);
1827 
1828     return SIP_NULLPTR;
1829 }
1830 
1831 
1832 PyDoc_STRVAR(doc_wxHVScrolledWindow_AcceptsFocusRecursively, "AcceptsFocusRecursively(self) -> bool");
1833 
1834 extern "C" {static PyObject *meth_wxHVScrolledWindow_AcceptsFocusRecursively(PyObject *, PyObject *);}
meth_wxHVScrolledWindow_AcceptsFocusRecursively(PyObject * sipSelf,PyObject * sipArgs)1835 static PyObject *meth_wxHVScrolledWindow_AcceptsFocusRecursively(PyObject *sipSelf, PyObject *sipArgs)
1836 {
1837     PyObject *sipParseErr = SIP_NULLPTR;
1838     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
1839 
1840     {
1841         const  ::wxHVScrolledWindow *sipCpp;
1842 
1843         if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp))
1844         {
1845             bool sipRes;
1846 
1847             PyErr_Clear();
1848 
1849             Py_BEGIN_ALLOW_THREADS
1850             sipRes = (sipSelfWasArg ? sipCpp-> ::wxHVScrolledWindow::AcceptsFocusRecursively() : sipCpp->AcceptsFocusRecursively());
1851             Py_END_ALLOW_THREADS
1852 
1853             if (PyErr_Occurred())
1854                 return 0;
1855 
1856             return PyBool_FromLong(sipRes);
1857         }
1858     }
1859 
1860     /* Raise an exception if the arguments couldn't be parsed. */
1861     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_AcceptsFocusRecursively, doc_wxHVScrolledWindow_AcceptsFocusRecursively);
1862 
1863     return SIP_NULLPTR;
1864 }
1865 
1866 
1867 PyDoc_STRVAR(doc_wxHVScrolledWindow_AcceptsFocusFromKeyboard, "AcceptsFocusFromKeyboard(self) -> bool");
1868 
1869 extern "C" {static PyObject *meth_wxHVScrolledWindow_AcceptsFocusFromKeyboard(PyObject *, PyObject *);}
meth_wxHVScrolledWindow_AcceptsFocusFromKeyboard(PyObject * sipSelf,PyObject * sipArgs)1870 static PyObject *meth_wxHVScrolledWindow_AcceptsFocusFromKeyboard(PyObject *sipSelf, PyObject *sipArgs)
1871 {
1872     PyObject *sipParseErr = SIP_NULLPTR;
1873     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
1874 
1875     {
1876         const  ::wxHVScrolledWindow *sipCpp;
1877 
1878         if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp))
1879         {
1880             bool sipRes;
1881 
1882             PyErr_Clear();
1883 
1884             Py_BEGIN_ALLOW_THREADS
1885             sipRes = (sipSelfWasArg ? sipCpp-> ::wxHVScrolledWindow::AcceptsFocusFromKeyboard() : sipCpp->AcceptsFocusFromKeyboard());
1886             Py_END_ALLOW_THREADS
1887 
1888             if (PyErr_Occurred())
1889                 return 0;
1890 
1891             return PyBool_FromLong(sipRes);
1892         }
1893     }
1894 
1895     /* Raise an exception if the arguments couldn't be parsed. */
1896     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_AcceptsFocusFromKeyboard, doc_wxHVScrolledWindow_AcceptsFocusFromKeyboard);
1897 
1898     return SIP_NULLPTR;
1899 }
1900 
1901 
1902 PyDoc_STRVAR(doc_wxHVScrolledWindow_AddChild, "AddChild(self, child: WindowBase)");
1903 
1904 extern "C" {static PyObject *meth_wxHVScrolledWindow_AddChild(PyObject *, PyObject *, PyObject *);}
meth_wxHVScrolledWindow_AddChild(PyObject * sipSelf,PyObject * sipArgs,PyObject * sipKwds)1905 static PyObject *meth_wxHVScrolledWindow_AddChild(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
1906 {
1907     PyObject *sipParseErr = SIP_NULLPTR;
1908     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
1909 
1910     {
1911          ::wxWindowBase* child;
1912          ::wxHVScrolledWindow *sipCpp;
1913 
1914         static const char *sipKwdList[] = {
1915             sipName_child,
1916         };
1917 
1918         if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ8", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp, sipType_wxWindowBase, &child))
1919         {
1920             PyErr_Clear();
1921 
1922             Py_BEGIN_ALLOW_THREADS
1923             (sipSelfWasArg ? sipCpp-> ::wxHVScrolledWindow::AddChild(child) : sipCpp->AddChild(child));
1924             Py_END_ALLOW_THREADS
1925 
1926             if (PyErr_Occurred())
1927                 return 0;
1928 
1929             Py_INCREF(Py_None);
1930             return Py_None;
1931         }
1932     }
1933 
1934     /* Raise an exception if the arguments couldn't be parsed. */
1935     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_AddChild, doc_wxHVScrolledWindow_AddChild);
1936 
1937     return SIP_NULLPTR;
1938 }
1939 
1940 
1941 PyDoc_STRVAR(doc_wxHVScrolledWindow_RemoveChild, "RemoveChild(self, child: WindowBase)");
1942 
1943 extern "C" {static PyObject *meth_wxHVScrolledWindow_RemoveChild(PyObject *, PyObject *, PyObject *);}
meth_wxHVScrolledWindow_RemoveChild(PyObject * sipSelf,PyObject * sipArgs,PyObject * sipKwds)1944 static PyObject *meth_wxHVScrolledWindow_RemoveChild(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
1945 {
1946     PyObject *sipParseErr = SIP_NULLPTR;
1947     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
1948 
1949     {
1950          ::wxWindowBase* child;
1951          ::wxHVScrolledWindow *sipCpp;
1952 
1953         static const char *sipKwdList[] = {
1954             sipName_child,
1955         };
1956 
1957         if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ8", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp, sipType_wxWindowBase, &child))
1958         {
1959             PyErr_Clear();
1960 
1961             Py_BEGIN_ALLOW_THREADS
1962             (sipSelfWasArg ? sipCpp-> ::wxHVScrolledWindow::RemoveChild(child) : sipCpp->RemoveChild(child));
1963             Py_END_ALLOW_THREADS
1964 
1965             if (PyErr_Occurred())
1966                 return 0;
1967 
1968             Py_INCREF(Py_None);
1969             return Py_None;
1970         }
1971     }
1972 
1973     /* Raise an exception if the arguments couldn't be parsed. */
1974     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_RemoveChild, doc_wxHVScrolledWindow_RemoveChild);
1975 
1976     return SIP_NULLPTR;
1977 }
1978 
1979 
1980 PyDoc_STRVAR(doc_wxHVScrolledWindow_InheritAttributes, "InheritAttributes(self)");
1981 
1982 extern "C" {static PyObject *meth_wxHVScrolledWindow_InheritAttributes(PyObject *, PyObject *);}
meth_wxHVScrolledWindow_InheritAttributes(PyObject * sipSelf,PyObject * sipArgs)1983 static PyObject *meth_wxHVScrolledWindow_InheritAttributes(PyObject *sipSelf, PyObject *sipArgs)
1984 {
1985     PyObject *sipParseErr = SIP_NULLPTR;
1986     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
1987 
1988     {
1989          ::wxHVScrolledWindow *sipCpp;
1990 
1991         if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp))
1992         {
1993             PyErr_Clear();
1994 
1995             Py_BEGIN_ALLOW_THREADS
1996             (sipSelfWasArg ? sipCpp-> ::wxHVScrolledWindow::InheritAttributes() : sipCpp->InheritAttributes());
1997             Py_END_ALLOW_THREADS
1998 
1999             if (PyErr_Occurred())
2000                 return 0;
2001 
2002             Py_INCREF(Py_None);
2003             return Py_None;
2004         }
2005     }
2006 
2007     /* Raise an exception if the arguments couldn't be parsed. */
2008     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_InheritAttributes, doc_wxHVScrolledWindow_InheritAttributes);
2009 
2010     return SIP_NULLPTR;
2011 }
2012 
2013 
2014 PyDoc_STRVAR(doc_wxHVScrolledWindow_ShouldInheritColours, "ShouldInheritColours(self) -> bool");
2015 
2016 extern "C" {static PyObject *meth_wxHVScrolledWindow_ShouldInheritColours(PyObject *, PyObject *);}
meth_wxHVScrolledWindow_ShouldInheritColours(PyObject * sipSelf,PyObject * sipArgs)2017 static PyObject *meth_wxHVScrolledWindow_ShouldInheritColours(PyObject *sipSelf, PyObject *sipArgs)
2018 {
2019     PyObject *sipParseErr = SIP_NULLPTR;
2020     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
2021 
2022     {
2023         const  ::wxHVScrolledWindow *sipCpp;
2024 
2025         if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp))
2026         {
2027             bool sipRes;
2028 
2029             PyErr_Clear();
2030 
2031             Py_BEGIN_ALLOW_THREADS
2032             sipRes = (sipSelfWasArg ? sipCpp-> ::wxHVScrolledWindow::ShouldInheritColours() : sipCpp->ShouldInheritColours());
2033             Py_END_ALLOW_THREADS
2034 
2035             if (PyErr_Occurred())
2036                 return 0;
2037 
2038             return PyBool_FromLong(sipRes);
2039         }
2040     }
2041 
2042     /* Raise an exception if the arguments couldn't be parsed. */
2043     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_ShouldInheritColours, doc_wxHVScrolledWindow_ShouldInheritColours);
2044 
2045     return SIP_NULLPTR;
2046 }
2047 
2048 
2049 PyDoc_STRVAR(doc_wxHVScrolledWindow_OnInternalIdle, "OnInternalIdle(self)");
2050 
2051 extern "C" {static PyObject *meth_wxHVScrolledWindow_OnInternalIdle(PyObject *, PyObject *);}
meth_wxHVScrolledWindow_OnInternalIdle(PyObject * sipSelf,PyObject * sipArgs)2052 static PyObject *meth_wxHVScrolledWindow_OnInternalIdle(PyObject *sipSelf, PyObject *sipArgs)
2053 {
2054     PyObject *sipParseErr = SIP_NULLPTR;
2055     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
2056 
2057     {
2058          ::wxHVScrolledWindow *sipCpp;
2059 
2060         if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp))
2061         {
2062             PyErr_Clear();
2063 
2064             Py_BEGIN_ALLOW_THREADS
2065             (sipSelfWasArg ? sipCpp-> ::wxHVScrolledWindow::OnInternalIdle() : sipCpp->OnInternalIdle());
2066             Py_END_ALLOW_THREADS
2067 
2068             if (PyErr_Occurred())
2069                 return 0;
2070 
2071             Py_INCREF(Py_None);
2072             return Py_None;
2073         }
2074     }
2075 
2076     /* Raise an exception if the arguments couldn't be parsed. */
2077     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_OnInternalIdle, doc_wxHVScrolledWindow_OnInternalIdle);
2078 
2079     return SIP_NULLPTR;
2080 }
2081 
2082 
2083 PyDoc_STRVAR(doc_wxHVScrolledWindow_GetMainWindowOfCompositeControl, "GetMainWindowOfCompositeControl(self) -> Window");
2084 
2085 extern "C" {static PyObject *meth_wxHVScrolledWindow_GetMainWindowOfCompositeControl(PyObject *, PyObject *);}
meth_wxHVScrolledWindow_GetMainWindowOfCompositeControl(PyObject * sipSelf,PyObject * sipArgs)2086 static PyObject *meth_wxHVScrolledWindow_GetMainWindowOfCompositeControl(PyObject *sipSelf, PyObject *sipArgs)
2087 {
2088     PyObject *sipParseErr = SIP_NULLPTR;
2089     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
2090 
2091     {
2092          ::wxHVScrolledWindow *sipCpp;
2093 
2094         if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp))
2095         {
2096              ::wxWindow*sipRes;
2097 
2098             PyErr_Clear();
2099 
2100             Py_BEGIN_ALLOW_THREADS
2101             sipRes = (sipSelfWasArg ? sipCpp-> ::wxHVScrolledWindow::GetMainWindowOfCompositeControl() : sipCpp->GetMainWindowOfCompositeControl());
2102             Py_END_ALLOW_THREADS
2103 
2104             if (PyErr_Occurred())
2105                 return 0;
2106 
2107             return sipConvertFromType(sipRes,sipType_wxWindow,SIP_NULLPTR);
2108         }
2109     }
2110 
2111     /* Raise an exception if the arguments couldn't be parsed. */
2112     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_GetMainWindowOfCompositeControl, doc_wxHVScrolledWindow_GetMainWindowOfCompositeControl);
2113 
2114     return SIP_NULLPTR;
2115 }
2116 
2117 
2118 PyDoc_STRVAR(doc_wxHVScrolledWindow_InformFirstDirection, "InformFirstDirection(self, direction: int, size: int, availableOtherDir: int) -> bool");
2119 
2120 extern "C" {static PyObject *meth_wxHVScrolledWindow_InformFirstDirection(PyObject *, PyObject *, PyObject *);}
meth_wxHVScrolledWindow_InformFirstDirection(PyObject * sipSelf,PyObject * sipArgs,PyObject * sipKwds)2121 static PyObject *meth_wxHVScrolledWindow_InformFirstDirection(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
2122 {
2123     PyObject *sipParseErr = SIP_NULLPTR;
2124     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
2125 
2126     {
2127         int direction;
2128         int size;
2129         int availableOtherDir;
2130          ::wxHVScrolledWindow *sipCpp;
2131 
2132         static const char *sipKwdList[] = {
2133             sipName_direction,
2134             sipName_size,
2135             sipName_availableOtherDir,
2136         };
2137 
2138         if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "Biii", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp, &direction, &size, &availableOtherDir))
2139         {
2140             bool sipRes;
2141 
2142             PyErr_Clear();
2143 
2144             Py_BEGIN_ALLOW_THREADS
2145             sipRes = (sipSelfWasArg ? sipCpp-> ::wxHVScrolledWindow::InformFirstDirection(direction,size,availableOtherDir) : sipCpp->InformFirstDirection(direction,size,availableOtherDir));
2146             Py_END_ALLOW_THREADS
2147 
2148             if (PyErr_Occurred())
2149                 return 0;
2150 
2151             return PyBool_FromLong(sipRes);
2152         }
2153     }
2154 
2155     /* Raise an exception if the arguments couldn't be parsed. */
2156     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_InformFirstDirection, doc_wxHVScrolledWindow_InformFirstDirection);
2157 
2158     return SIP_NULLPTR;
2159 }
2160 
2161 
2162 PyDoc_STRVAR(doc_wxHVScrolledWindow_SetCanFocus, "SetCanFocus(self, canFocus: bool)");
2163 
2164 extern "C" {static PyObject *meth_wxHVScrolledWindow_SetCanFocus(PyObject *, PyObject *, PyObject *);}
meth_wxHVScrolledWindow_SetCanFocus(PyObject * sipSelf,PyObject * sipArgs,PyObject * sipKwds)2165 static PyObject *meth_wxHVScrolledWindow_SetCanFocus(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
2166 {
2167     PyObject *sipParseErr = SIP_NULLPTR;
2168     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
2169 
2170     {
2171         bool canFocus;
2172          ::wxHVScrolledWindow *sipCpp;
2173 
2174         static const char *sipKwdList[] = {
2175             sipName_canFocus,
2176         };
2177 
2178         if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "Bb", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp, &canFocus))
2179         {
2180             PyErr_Clear();
2181 
2182             Py_BEGIN_ALLOW_THREADS
2183             (sipSelfWasArg ? sipCpp-> ::wxHVScrolledWindow::SetCanFocus(canFocus) : sipCpp->SetCanFocus(canFocus));
2184             Py_END_ALLOW_THREADS
2185 
2186             if (PyErr_Occurred())
2187                 return 0;
2188 
2189             Py_INCREF(Py_None);
2190             return Py_None;
2191         }
2192     }
2193 
2194     /* Raise an exception if the arguments couldn't be parsed. */
2195     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_SetCanFocus, doc_wxHVScrolledWindow_SetCanFocus);
2196 
2197     return SIP_NULLPTR;
2198 }
2199 
2200 
2201 PyDoc_STRVAR(doc_wxHVScrolledWindow_Destroy, "Destroy(self) -> bool");
2202 
2203 extern "C" {static PyObject *meth_wxHVScrolledWindow_Destroy(PyObject *, PyObject *);}
meth_wxHVScrolledWindow_Destroy(PyObject * sipSelf,PyObject * sipArgs)2204 static PyObject *meth_wxHVScrolledWindow_Destroy(PyObject *sipSelf, PyObject *sipArgs)
2205 {
2206     PyObject *sipParseErr = SIP_NULLPTR;
2207     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
2208 
2209     {
2210          ::wxHVScrolledWindow *sipCpp;
2211 
2212         if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp))
2213         {
2214             bool sipRes;
2215 
2216             PyErr_Clear();
2217 
2218             Py_BEGIN_ALLOW_THREADS
2219             sipRes = (sipSelfWasArg ? sipCpp-> ::wxHVScrolledWindow::Destroy() : sipCpp->Destroy());
2220             Py_END_ALLOW_THREADS
2221 
2222             if (PyErr_Occurred())
2223                 return 0;
2224 
2225             return PyBool_FromLong(sipRes);
2226         }
2227     }
2228 
2229     /* Raise an exception if the arguments couldn't be parsed. */
2230     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_Destroy, doc_wxHVScrolledWindow_Destroy);
2231 
2232     return SIP_NULLPTR;
2233 }
2234 
2235 
2236 PyDoc_STRVAR(doc_wxHVScrolledWindow_SetValidator, "SetValidator(self, validator: Validator)");
2237 
2238 extern "C" {static PyObject *meth_wxHVScrolledWindow_SetValidator(PyObject *, PyObject *, PyObject *);}
meth_wxHVScrolledWindow_SetValidator(PyObject * sipSelf,PyObject * sipArgs,PyObject * sipKwds)2239 static PyObject *meth_wxHVScrolledWindow_SetValidator(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
2240 {
2241     PyObject *sipParseErr = SIP_NULLPTR;
2242     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
2243 
2244     {
2245         const  ::wxValidator* validator;
2246          ::wxHVScrolledWindow *sipCpp;
2247 
2248         static const char *sipKwdList[] = {
2249             sipName_validator,
2250         };
2251 
2252         if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ9", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp, sipType_wxValidator, &validator))
2253         {
2254             PyErr_Clear();
2255 
2256             Py_BEGIN_ALLOW_THREADS
2257             (sipSelfWasArg ? sipCpp-> ::wxHVScrolledWindow::SetValidator(*validator) : sipCpp->SetValidator(*validator));
2258             Py_END_ALLOW_THREADS
2259 
2260             if (PyErr_Occurred())
2261                 return 0;
2262 
2263             Py_INCREF(Py_None);
2264             return Py_None;
2265         }
2266     }
2267 
2268     /* Raise an exception if the arguments couldn't be parsed. */
2269     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_SetValidator, doc_wxHVScrolledWindow_SetValidator);
2270 
2271     return SIP_NULLPTR;
2272 }
2273 
2274 
2275 PyDoc_STRVAR(doc_wxHVScrolledWindow_GetValidator, "GetValidator(self) -> Validator");
2276 
2277 extern "C" {static PyObject *meth_wxHVScrolledWindow_GetValidator(PyObject *, PyObject *);}
meth_wxHVScrolledWindow_GetValidator(PyObject * sipSelf,PyObject * sipArgs)2278 static PyObject *meth_wxHVScrolledWindow_GetValidator(PyObject *sipSelf, PyObject *sipArgs)
2279 {
2280     PyObject *sipParseErr = SIP_NULLPTR;
2281     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
2282 
2283     {
2284          ::wxHVScrolledWindow *sipCpp;
2285 
2286         if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp))
2287         {
2288              ::wxValidator*sipRes;
2289 
2290             PyErr_Clear();
2291 
2292             Py_BEGIN_ALLOW_THREADS
2293             sipRes = (sipSelfWasArg ? sipCpp-> ::wxHVScrolledWindow::GetValidator() : sipCpp->GetValidator());
2294             Py_END_ALLOW_THREADS
2295 
2296             if (PyErr_Occurred())
2297                 return 0;
2298 
2299             return sipConvertFromType(sipRes,sipType_wxValidator,SIP_NULLPTR);
2300         }
2301     }
2302 
2303     /* Raise an exception if the arguments couldn't be parsed. */
2304     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_GetValidator, doc_wxHVScrolledWindow_GetValidator);
2305 
2306     return SIP_NULLPTR;
2307 }
2308 
2309 
2310 PyDoc_STRVAR(doc_wxHVScrolledWindow_ProcessEvent, "ProcessEvent(self, event: Event) -> bool");
2311 
2312 extern "C" {static PyObject *meth_wxHVScrolledWindow_ProcessEvent(PyObject *, PyObject *, PyObject *);}
meth_wxHVScrolledWindow_ProcessEvent(PyObject * sipSelf,PyObject * sipArgs,PyObject * sipKwds)2313 static PyObject *meth_wxHVScrolledWindow_ProcessEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
2314 {
2315     PyObject *sipParseErr = SIP_NULLPTR;
2316     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
2317 
2318     {
2319          ::wxEvent* event;
2320         sipwxHVScrolledWindow *sipCpp;
2321 
2322         static const char *sipKwdList[] = {
2323             sipName_event,
2324         };
2325 
2326         if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ9", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp, sipType_wxEvent, &event))
2327         {
2328             bool sipRes;
2329 
2330             PyErr_Clear();
2331 
2332             Py_BEGIN_ALLOW_THREADS
2333             sipRes = sipCpp->sipProtectVirt_ProcessEvent(sipSelfWasArg,*event);
2334             Py_END_ALLOW_THREADS
2335 
2336             if (PyErr_Occurred())
2337                 return 0;
2338 
2339             return PyBool_FromLong(sipRes);
2340         }
2341     }
2342 
2343     /* Raise an exception if the arguments couldn't be parsed. */
2344     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_ProcessEvent, doc_wxHVScrolledWindow_ProcessEvent);
2345 
2346     return SIP_NULLPTR;
2347 }
2348 
2349 
2350 PyDoc_STRVAR(doc_wxHVScrolledWindow_DoEnable, "DoEnable(self, enable: bool)");
2351 
2352 extern "C" {static PyObject *meth_wxHVScrolledWindow_DoEnable(PyObject *, PyObject *, PyObject *);}
meth_wxHVScrolledWindow_DoEnable(PyObject * sipSelf,PyObject * sipArgs,PyObject * sipKwds)2353 static PyObject *meth_wxHVScrolledWindow_DoEnable(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
2354 {
2355     PyObject *sipParseErr = SIP_NULLPTR;
2356     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
2357 
2358     {
2359         bool enable;
2360         sipwxHVScrolledWindow *sipCpp;
2361 
2362         static const char *sipKwdList[] = {
2363             sipName_enable,
2364         };
2365 
2366         if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "Bb", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp, &enable))
2367         {
2368             PyErr_Clear();
2369 
2370             Py_BEGIN_ALLOW_THREADS
2371             sipCpp->sipProtectVirt_DoEnable(sipSelfWasArg,enable);
2372             Py_END_ALLOW_THREADS
2373 
2374             if (PyErr_Occurred())
2375                 return 0;
2376 
2377             Py_INCREF(Py_None);
2378             return Py_None;
2379         }
2380     }
2381 
2382     /* Raise an exception if the arguments couldn't be parsed. */
2383     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_DoEnable, doc_wxHVScrolledWindow_DoEnable);
2384 
2385     return SIP_NULLPTR;
2386 }
2387 
2388 
2389 PyDoc_STRVAR(doc_wxHVScrolledWindow_DoGetPosition, "DoGetPosition(self) -> Tuple[int, int]");
2390 
2391 extern "C" {static PyObject *meth_wxHVScrolledWindow_DoGetPosition(PyObject *, PyObject *, PyObject *);}
meth_wxHVScrolledWindow_DoGetPosition(PyObject * sipSelf,PyObject * sipArgs,PyObject * sipKwds)2392 static PyObject *meth_wxHVScrolledWindow_DoGetPosition(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
2393 {
2394     PyObject *sipParseErr = SIP_NULLPTR;
2395     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
2396 
2397     {
2398         int x;
2399         int y;
2400         const sipwxHVScrolledWindow *sipCpp;
2401 
2402         if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, SIP_NULLPTR, SIP_NULLPTR, "B", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp))
2403         {
2404             PyErr_Clear();
2405 
2406             Py_BEGIN_ALLOW_THREADS
2407             sipCpp->sipProtectVirt_DoGetPosition(sipSelfWasArg,&x,&y);
2408             Py_END_ALLOW_THREADS
2409 
2410             if (PyErr_Occurred())
2411                 return 0;
2412 
2413             return sipBuildResult(0,"(ii)",x,y);
2414         }
2415     }
2416 
2417     /* Raise an exception if the arguments couldn't be parsed. */
2418     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_DoGetPosition, doc_wxHVScrolledWindow_DoGetPosition);
2419 
2420     return SIP_NULLPTR;
2421 }
2422 
2423 
2424 PyDoc_STRVAR(doc_wxHVScrolledWindow_DoGetSize, "DoGetSize(self) -> Tuple[int, int]");
2425 
2426 extern "C" {static PyObject *meth_wxHVScrolledWindow_DoGetSize(PyObject *, PyObject *, PyObject *);}
meth_wxHVScrolledWindow_DoGetSize(PyObject * sipSelf,PyObject * sipArgs,PyObject * sipKwds)2427 static PyObject *meth_wxHVScrolledWindow_DoGetSize(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
2428 {
2429     PyObject *sipParseErr = SIP_NULLPTR;
2430     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
2431 
2432     {
2433         int width;
2434         int height;
2435         const sipwxHVScrolledWindow *sipCpp;
2436 
2437         if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, SIP_NULLPTR, SIP_NULLPTR, "B", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp))
2438         {
2439             PyErr_Clear();
2440 
2441             Py_BEGIN_ALLOW_THREADS
2442             sipCpp->sipProtectVirt_DoGetSize(sipSelfWasArg,&width,&height);
2443             Py_END_ALLOW_THREADS
2444 
2445             if (PyErr_Occurred())
2446                 return 0;
2447 
2448             return sipBuildResult(0,"(ii)",width,height);
2449         }
2450     }
2451 
2452     /* Raise an exception if the arguments couldn't be parsed. */
2453     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_DoGetSize, doc_wxHVScrolledWindow_DoGetSize);
2454 
2455     return SIP_NULLPTR;
2456 }
2457 
2458 
2459 PyDoc_STRVAR(doc_wxHVScrolledWindow_DoGetClientSize, "DoGetClientSize(self) -> Tuple[int, int]");
2460 
2461 extern "C" {static PyObject *meth_wxHVScrolledWindow_DoGetClientSize(PyObject *, PyObject *, PyObject *);}
meth_wxHVScrolledWindow_DoGetClientSize(PyObject * sipSelf,PyObject * sipArgs,PyObject * sipKwds)2462 static PyObject *meth_wxHVScrolledWindow_DoGetClientSize(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
2463 {
2464     PyObject *sipParseErr = SIP_NULLPTR;
2465     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
2466 
2467     {
2468         int width;
2469         int height;
2470         const sipwxHVScrolledWindow *sipCpp;
2471 
2472         if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, SIP_NULLPTR, SIP_NULLPTR, "B", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp))
2473         {
2474             PyErr_Clear();
2475 
2476             Py_BEGIN_ALLOW_THREADS
2477             sipCpp->sipProtectVirt_DoGetClientSize(sipSelfWasArg,&width,&height);
2478             Py_END_ALLOW_THREADS
2479 
2480             if (PyErr_Occurred())
2481                 return 0;
2482 
2483             return sipBuildResult(0,"(ii)",width,height);
2484         }
2485     }
2486 
2487     /* Raise an exception if the arguments couldn't be parsed. */
2488     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_DoGetClientSize, doc_wxHVScrolledWindow_DoGetClientSize);
2489 
2490     return SIP_NULLPTR;
2491 }
2492 
2493 
2494 PyDoc_STRVAR(doc_wxHVScrolledWindow_DoGetBestSize, "DoGetBestSize(self) -> Size");
2495 
2496 extern "C" {static PyObject *meth_wxHVScrolledWindow_DoGetBestSize(PyObject *, PyObject *);}
meth_wxHVScrolledWindow_DoGetBestSize(PyObject * sipSelf,PyObject * sipArgs)2497 static PyObject *meth_wxHVScrolledWindow_DoGetBestSize(PyObject *sipSelf, PyObject *sipArgs)
2498 {
2499     PyObject *sipParseErr = SIP_NULLPTR;
2500     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
2501 
2502     {
2503         const sipwxHVScrolledWindow *sipCpp;
2504 
2505         if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp))
2506         {
2507              ::wxSize*sipRes;
2508 
2509             PyErr_Clear();
2510 
2511             Py_BEGIN_ALLOW_THREADS
2512             sipRes = new  ::wxSize(sipCpp->sipProtectVirt_DoGetBestSize(sipSelfWasArg));
2513             Py_END_ALLOW_THREADS
2514 
2515             if (PyErr_Occurred())
2516                 return 0;
2517 
2518             return sipConvertFromNewType(sipRes,sipType_wxSize,SIP_NULLPTR);
2519         }
2520     }
2521 
2522     /* Raise an exception if the arguments couldn't be parsed. */
2523     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_DoGetBestSize, doc_wxHVScrolledWindow_DoGetBestSize);
2524 
2525     return SIP_NULLPTR;
2526 }
2527 
2528 
2529 PyDoc_STRVAR(doc_wxHVScrolledWindow_DoGetBestClientSize, "DoGetBestClientSize(self) -> Size");
2530 
2531 extern "C" {static PyObject *meth_wxHVScrolledWindow_DoGetBestClientSize(PyObject *, PyObject *);}
meth_wxHVScrolledWindow_DoGetBestClientSize(PyObject * sipSelf,PyObject * sipArgs)2532 static PyObject *meth_wxHVScrolledWindow_DoGetBestClientSize(PyObject *sipSelf, PyObject *sipArgs)
2533 {
2534     PyObject *sipParseErr = SIP_NULLPTR;
2535     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
2536 
2537     {
2538         const sipwxHVScrolledWindow *sipCpp;
2539 
2540         if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp))
2541         {
2542              ::wxSize*sipRes;
2543 
2544             PyErr_Clear();
2545 
2546             Py_BEGIN_ALLOW_THREADS
2547             sipRes = new  ::wxSize(sipCpp->sipProtectVirt_DoGetBestClientSize(sipSelfWasArg));
2548             Py_END_ALLOW_THREADS
2549 
2550             if (PyErr_Occurred())
2551                 return 0;
2552 
2553             return sipConvertFromNewType(sipRes,sipType_wxSize,SIP_NULLPTR);
2554         }
2555     }
2556 
2557     /* Raise an exception if the arguments couldn't be parsed. */
2558     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_DoGetBestClientSize, doc_wxHVScrolledWindow_DoGetBestClientSize);
2559 
2560     return SIP_NULLPTR;
2561 }
2562 
2563 
2564 PyDoc_STRVAR(doc_wxHVScrolledWindow_DoSetSize, "DoSetSize(self, x: int, y: int, width: int, height: int, sizeFlags: int)");
2565 
2566 extern "C" {static PyObject *meth_wxHVScrolledWindow_DoSetSize(PyObject *, PyObject *, PyObject *);}
meth_wxHVScrolledWindow_DoSetSize(PyObject * sipSelf,PyObject * sipArgs,PyObject * sipKwds)2567 static PyObject *meth_wxHVScrolledWindow_DoSetSize(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
2568 {
2569     PyObject *sipParseErr = SIP_NULLPTR;
2570     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
2571 
2572     {
2573         int x;
2574         int y;
2575         int width;
2576         int height;
2577         int sizeFlags;
2578         sipwxHVScrolledWindow *sipCpp;
2579 
2580         static const char *sipKwdList[] = {
2581             sipName_x,
2582             sipName_y,
2583             sipName_width,
2584             sipName_height,
2585             sipName_sizeFlags,
2586         };
2587 
2588         if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "Biiiii", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp, &x, &y, &width, &height, &sizeFlags))
2589         {
2590             PyErr_Clear();
2591 
2592             Py_BEGIN_ALLOW_THREADS
2593             sipCpp->sipProtectVirt_DoSetSize(sipSelfWasArg,x,y,width,height,sizeFlags);
2594             Py_END_ALLOW_THREADS
2595 
2596             if (PyErr_Occurred())
2597                 return 0;
2598 
2599             Py_INCREF(Py_None);
2600             return Py_None;
2601         }
2602     }
2603 
2604     /* Raise an exception if the arguments couldn't be parsed. */
2605     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_DoSetSize, doc_wxHVScrolledWindow_DoSetSize);
2606 
2607     return SIP_NULLPTR;
2608 }
2609 
2610 
2611 PyDoc_STRVAR(doc_wxHVScrolledWindow_DoSetClientSize, "DoSetClientSize(self, width: int, height: int)");
2612 
2613 extern "C" {static PyObject *meth_wxHVScrolledWindow_DoSetClientSize(PyObject *, PyObject *, PyObject *);}
meth_wxHVScrolledWindow_DoSetClientSize(PyObject * sipSelf,PyObject * sipArgs,PyObject * sipKwds)2614 static PyObject *meth_wxHVScrolledWindow_DoSetClientSize(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
2615 {
2616     PyObject *sipParseErr = SIP_NULLPTR;
2617     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
2618 
2619     {
2620         int width;
2621         int height;
2622         sipwxHVScrolledWindow *sipCpp;
2623 
2624         static const char *sipKwdList[] = {
2625             sipName_width,
2626             sipName_height,
2627         };
2628 
2629         if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "Bii", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp, &width, &height))
2630         {
2631             PyErr_Clear();
2632 
2633             Py_BEGIN_ALLOW_THREADS
2634             sipCpp->sipProtectVirt_DoSetClientSize(sipSelfWasArg,width,height);
2635             Py_END_ALLOW_THREADS
2636 
2637             if (PyErr_Occurred())
2638                 return 0;
2639 
2640             Py_INCREF(Py_None);
2641             return Py_None;
2642         }
2643     }
2644 
2645     /* Raise an exception if the arguments couldn't be parsed. */
2646     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_DoSetClientSize, doc_wxHVScrolledWindow_DoSetClientSize);
2647 
2648     return SIP_NULLPTR;
2649 }
2650 
2651 
2652 PyDoc_STRVAR(doc_wxHVScrolledWindow_DoSetSizeHints, "DoSetSizeHints(self, minW: int, minH: int, maxW: int, maxH: int, incW: int, incH: int)");
2653 
2654 extern "C" {static PyObject *meth_wxHVScrolledWindow_DoSetSizeHints(PyObject *, PyObject *, PyObject *);}
meth_wxHVScrolledWindow_DoSetSizeHints(PyObject * sipSelf,PyObject * sipArgs,PyObject * sipKwds)2655 static PyObject *meth_wxHVScrolledWindow_DoSetSizeHints(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
2656 {
2657     PyObject *sipParseErr = SIP_NULLPTR;
2658     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
2659 
2660     {
2661         int minW;
2662         int minH;
2663         int maxW;
2664         int maxH;
2665         int incW;
2666         int incH;
2667         sipwxHVScrolledWindow *sipCpp;
2668 
2669         static const char *sipKwdList[] = {
2670             sipName_minW,
2671             sipName_minH,
2672             sipName_maxW,
2673             sipName_maxH,
2674             sipName_incW,
2675             sipName_incH,
2676         };
2677 
2678         if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "Biiiiii", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp, &minW, &minH, &maxW, &maxH, &incW, &incH))
2679         {
2680             PyErr_Clear();
2681 
2682             Py_BEGIN_ALLOW_THREADS
2683             sipCpp->sipProtectVirt_DoSetSizeHints(sipSelfWasArg,minW,minH,maxW,maxH,incW,incH);
2684             Py_END_ALLOW_THREADS
2685 
2686             if (PyErr_Occurred())
2687                 return 0;
2688 
2689             Py_INCREF(Py_None);
2690             return Py_None;
2691         }
2692     }
2693 
2694     /* Raise an exception if the arguments couldn't be parsed. */
2695     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_DoSetSizeHints, doc_wxHVScrolledWindow_DoSetSizeHints);
2696 
2697     return SIP_NULLPTR;
2698 }
2699 
2700 
2701 PyDoc_STRVAR(doc_wxHVScrolledWindow_DoGetBorderSize, "DoGetBorderSize(self) -> Size");
2702 
2703 extern "C" {static PyObject *meth_wxHVScrolledWindow_DoGetBorderSize(PyObject *, PyObject *);}
meth_wxHVScrolledWindow_DoGetBorderSize(PyObject * sipSelf,PyObject * sipArgs)2704 static PyObject *meth_wxHVScrolledWindow_DoGetBorderSize(PyObject *sipSelf, PyObject *sipArgs)
2705 {
2706     PyObject *sipParseErr = SIP_NULLPTR;
2707     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
2708 
2709     {
2710         const sipwxHVScrolledWindow *sipCpp;
2711 
2712         if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp))
2713         {
2714              ::wxSize*sipRes;
2715 
2716             PyErr_Clear();
2717 
2718             Py_BEGIN_ALLOW_THREADS
2719             sipRes = new  ::wxSize(sipCpp->sipProtectVirt_DoGetBorderSize(sipSelfWasArg));
2720             Py_END_ALLOW_THREADS
2721 
2722             if (PyErr_Occurred())
2723                 return 0;
2724 
2725             return sipConvertFromNewType(sipRes,sipType_wxSize,SIP_NULLPTR);
2726         }
2727     }
2728 
2729     /* Raise an exception if the arguments couldn't be parsed. */
2730     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_DoGetBorderSize, doc_wxHVScrolledWindow_DoGetBorderSize);
2731 
2732     return SIP_NULLPTR;
2733 }
2734 
2735 
2736 PyDoc_STRVAR(doc_wxHVScrolledWindow_DoMoveWindow, "DoMoveWindow(self, x: int, y: int, width: int, height: int)");
2737 
2738 extern "C" {static PyObject *meth_wxHVScrolledWindow_DoMoveWindow(PyObject *, PyObject *, PyObject *);}
meth_wxHVScrolledWindow_DoMoveWindow(PyObject * sipSelf,PyObject * sipArgs,PyObject * sipKwds)2739 static PyObject *meth_wxHVScrolledWindow_DoMoveWindow(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
2740 {
2741     PyObject *sipParseErr = SIP_NULLPTR;
2742     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
2743 
2744     {
2745         int x;
2746         int y;
2747         int width;
2748         int height;
2749         sipwxHVScrolledWindow *sipCpp;
2750 
2751         static const char *sipKwdList[] = {
2752             sipName_x,
2753             sipName_y,
2754             sipName_width,
2755             sipName_height,
2756         };
2757 
2758         if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "Biiii", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp, &x, &y, &width, &height))
2759         {
2760             PyErr_Clear();
2761 
2762             Py_BEGIN_ALLOW_THREADS
2763             sipCpp->sipProtectVirt_DoMoveWindow(sipSelfWasArg,x,y,width,height);
2764             Py_END_ALLOW_THREADS
2765 
2766             if (PyErr_Occurred())
2767                 return 0;
2768 
2769             Py_INCREF(Py_None);
2770             return Py_None;
2771         }
2772     }
2773 
2774     /* Raise an exception if the arguments couldn't be parsed. */
2775     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_DoMoveWindow, doc_wxHVScrolledWindow_DoMoveWindow);
2776 
2777     return SIP_NULLPTR;
2778 }
2779 
2780 
2781 PyDoc_STRVAR(doc_wxHVScrolledWindow_DoSetWindowVariant, "DoSetWindowVariant(self, variant: WindowVariant)");
2782 
2783 extern "C" {static PyObject *meth_wxHVScrolledWindow_DoSetWindowVariant(PyObject *, PyObject *, PyObject *);}
meth_wxHVScrolledWindow_DoSetWindowVariant(PyObject * sipSelf,PyObject * sipArgs,PyObject * sipKwds)2784 static PyObject *meth_wxHVScrolledWindow_DoSetWindowVariant(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
2785 {
2786     PyObject *sipParseErr = SIP_NULLPTR;
2787     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
2788 
2789     {
2790          ::wxWindowVariant variant;
2791         sipwxHVScrolledWindow *sipCpp;
2792 
2793         static const char *sipKwdList[] = {
2794             sipName_variant,
2795         };
2796 
2797         if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BE", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp, sipType_wxWindowVariant, &variant))
2798         {
2799             PyErr_Clear();
2800 
2801             Py_BEGIN_ALLOW_THREADS
2802             sipCpp->sipProtectVirt_DoSetWindowVariant(sipSelfWasArg,variant);
2803             Py_END_ALLOW_THREADS
2804 
2805             if (PyErr_Occurred())
2806                 return 0;
2807 
2808             Py_INCREF(Py_None);
2809             return Py_None;
2810         }
2811     }
2812 
2813     /* Raise an exception if the arguments couldn't be parsed. */
2814     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_DoSetWindowVariant, doc_wxHVScrolledWindow_DoSetWindowVariant);
2815 
2816     return SIP_NULLPTR;
2817 }
2818 
2819 
2820 PyDoc_STRVAR(doc_wxHVScrolledWindow_GetDefaultBorder, "GetDefaultBorder(self) -> Border");
2821 
2822 extern "C" {static PyObject *meth_wxHVScrolledWindow_GetDefaultBorder(PyObject *, PyObject *);}
meth_wxHVScrolledWindow_GetDefaultBorder(PyObject * sipSelf,PyObject * sipArgs)2823 static PyObject *meth_wxHVScrolledWindow_GetDefaultBorder(PyObject *sipSelf, PyObject *sipArgs)
2824 {
2825     PyObject *sipParseErr = SIP_NULLPTR;
2826     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
2827 
2828     {
2829         const sipwxHVScrolledWindow *sipCpp;
2830 
2831         if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp))
2832         {
2833              ::wxBorder sipRes;
2834 
2835             PyErr_Clear();
2836 
2837             Py_BEGIN_ALLOW_THREADS
2838             sipRes = sipCpp->sipProtectVirt_GetDefaultBorder(sipSelfWasArg);
2839             Py_END_ALLOW_THREADS
2840 
2841             if (PyErr_Occurred())
2842                 return 0;
2843 
2844             return sipConvertFromEnum(static_cast<int>(sipRes), sipType_wxBorder);
2845         }
2846     }
2847 
2848     /* Raise an exception if the arguments couldn't be parsed. */
2849     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_GetDefaultBorder, doc_wxHVScrolledWindow_GetDefaultBorder);
2850 
2851     return SIP_NULLPTR;
2852 }
2853 
2854 
2855 PyDoc_STRVAR(doc_wxHVScrolledWindow_GetDefaultBorderForControl, "GetDefaultBorderForControl(self) -> Border");
2856 
2857 extern "C" {static PyObject *meth_wxHVScrolledWindow_GetDefaultBorderForControl(PyObject *, PyObject *);}
meth_wxHVScrolledWindow_GetDefaultBorderForControl(PyObject * sipSelf,PyObject * sipArgs)2858 static PyObject *meth_wxHVScrolledWindow_GetDefaultBorderForControl(PyObject *sipSelf, PyObject *sipArgs)
2859 {
2860     PyObject *sipParseErr = SIP_NULLPTR;
2861     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
2862 
2863     {
2864         const sipwxHVScrolledWindow *sipCpp;
2865 
2866         if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp))
2867         {
2868              ::wxBorder sipRes;
2869 
2870             PyErr_Clear();
2871 
2872             Py_BEGIN_ALLOW_THREADS
2873             sipRes = sipCpp->sipProtectVirt_GetDefaultBorderForControl(sipSelfWasArg);
2874             Py_END_ALLOW_THREADS
2875 
2876             if (PyErr_Occurred())
2877                 return 0;
2878 
2879             return sipConvertFromEnum(static_cast<int>(sipRes), sipType_wxBorder);
2880         }
2881     }
2882 
2883     /* Raise an exception if the arguments couldn't be parsed. */
2884     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_GetDefaultBorderForControl, doc_wxHVScrolledWindow_GetDefaultBorderForControl);
2885 
2886     return SIP_NULLPTR;
2887 }
2888 
2889 
2890 PyDoc_STRVAR(doc_wxHVScrolledWindow_DoFreeze, "DoFreeze(self)");
2891 
2892 extern "C" {static PyObject *meth_wxHVScrolledWindow_DoFreeze(PyObject *, PyObject *);}
meth_wxHVScrolledWindow_DoFreeze(PyObject * sipSelf,PyObject * sipArgs)2893 static PyObject *meth_wxHVScrolledWindow_DoFreeze(PyObject *sipSelf, PyObject *sipArgs)
2894 {
2895     PyObject *sipParseErr = SIP_NULLPTR;
2896     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
2897 
2898     {
2899         sipwxHVScrolledWindow *sipCpp;
2900 
2901         if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp))
2902         {
2903             PyErr_Clear();
2904 
2905             Py_BEGIN_ALLOW_THREADS
2906             sipCpp->sipProtectVirt_DoFreeze(sipSelfWasArg);
2907             Py_END_ALLOW_THREADS
2908 
2909             if (PyErr_Occurred())
2910                 return 0;
2911 
2912             Py_INCREF(Py_None);
2913             return Py_None;
2914         }
2915     }
2916 
2917     /* Raise an exception if the arguments couldn't be parsed. */
2918     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_DoFreeze, doc_wxHVScrolledWindow_DoFreeze);
2919 
2920     return SIP_NULLPTR;
2921 }
2922 
2923 
2924 PyDoc_STRVAR(doc_wxHVScrolledWindow_DoThaw, "DoThaw(self)");
2925 
2926 extern "C" {static PyObject *meth_wxHVScrolledWindow_DoThaw(PyObject *, PyObject *);}
meth_wxHVScrolledWindow_DoThaw(PyObject * sipSelf,PyObject * sipArgs)2927 static PyObject *meth_wxHVScrolledWindow_DoThaw(PyObject *sipSelf, PyObject *sipArgs)
2928 {
2929     PyObject *sipParseErr = SIP_NULLPTR;
2930     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
2931 
2932     {
2933         sipwxHVScrolledWindow *sipCpp;
2934 
2935         if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp))
2936         {
2937             PyErr_Clear();
2938 
2939             Py_BEGIN_ALLOW_THREADS
2940             sipCpp->sipProtectVirt_DoThaw(sipSelfWasArg);
2941             Py_END_ALLOW_THREADS
2942 
2943             if (PyErr_Occurred())
2944                 return 0;
2945 
2946             Py_INCREF(Py_None);
2947             return Py_None;
2948         }
2949     }
2950 
2951     /* Raise an exception if the arguments couldn't be parsed. */
2952     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_DoThaw, doc_wxHVScrolledWindow_DoThaw);
2953 
2954     return SIP_NULLPTR;
2955 }
2956 
2957 
2958 PyDoc_STRVAR(doc_wxHVScrolledWindow_HasTransparentBackground, "HasTransparentBackground(self) -> bool");
2959 
2960 extern "C" {static PyObject *meth_wxHVScrolledWindow_HasTransparentBackground(PyObject *, PyObject *);}
meth_wxHVScrolledWindow_HasTransparentBackground(PyObject * sipSelf,PyObject * sipArgs)2961 static PyObject *meth_wxHVScrolledWindow_HasTransparentBackground(PyObject *sipSelf, PyObject *sipArgs)
2962 {
2963     PyObject *sipParseErr = SIP_NULLPTR;
2964     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
2965 
2966     {
2967         sipwxHVScrolledWindow *sipCpp;
2968 
2969         if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp))
2970         {
2971             bool sipRes;
2972 
2973             PyErr_Clear();
2974 
2975             Py_BEGIN_ALLOW_THREADS
2976             sipRes = sipCpp->sipProtectVirt_HasTransparentBackground(sipSelfWasArg);
2977             Py_END_ALLOW_THREADS
2978 
2979             if (PyErr_Occurred())
2980                 return 0;
2981 
2982             return PyBool_FromLong(sipRes);
2983         }
2984     }
2985 
2986     /* Raise an exception if the arguments couldn't be parsed. */
2987     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_HasTransparentBackground, doc_wxHVScrolledWindow_HasTransparentBackground);
2988 
2989     return SIP_NULLPTR;
2990 }
2991 
2992 
2993 PyDoc_STRVAR(doc_wxHVScrolledWindow_TryBefore, "TryBefore(self, event: Event) -> bool");
2994 
2995 extern "C" {static PyObject *meth_wxHVScrolledWindow_TryBefore(PyObject *, PyObject *, PyObject *);}
meth_wxHVScrolledWindow_TryBefore(PyObject * sipSelf,PyObject * sipArgs,PyObject * sipKwds)2996 static PyObject *meth_wxHVScrolledWindow_TryBefore(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
2997 {
2998     PyObject *sipParseErr = SIP_NULLPTR;
2999     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
3000 
3001     {
3002          ::wxEvent* event;
3003         sipwxHVScrolledWindow *sipCpp;
3004 
3005         static const char *sipKwdList[] = {
3006             sipName_event,
3007         };
3008 
3009         if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ9", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp, sipType_wxEvent, &event))
3010         {
3011             bool sipRes;
3012 
3013             PyErr_Clear();
3014 
3015             Py_BEGIN_ALLOW_THREADS
3016             sipRes = sipCpp->sipProtectVirt_TryBefore(sipSelfWasArg,*event);
3017             Py_END_ALLOW_THREADS
3018 
3019             if (PyErr_Occurred())
3020                 return 0;
3021 
3022             return PyBool_FromLong(sipRes);
3023         }
3024     }
3025 
3026     /* Raise an exception if the arguments couldn't be parsed. */
3027     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_TryBefore, doc_wxHVScrolledWindow_TryBefore);
3028 
3029     return SIP_NULLPTR;
3030 }
3031 
3032 
3033 PyDoc_STRVAR(doc_wxHVScrolledWindow_TryAfter, "TryAfter(self, event: Event) -> bool");
3034 
3035 extern "C" {static PyObject *meth_wxHVScrolledWindow_TryAfter(PyObject *, PyObject *, PyObject *);}
meth_wxHVScrolledWindow_TryAfter(PyObject * sipSelf,PyObject * sipArgs,PyObject * sipKwds)3036 static PyObject *meth_wxHVScrolledWindow_TryAfter(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
3037 {
3038     PyObject *sipParseErr = SIP_NULLPTR;
3039     bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));
3040 
3041     {
3042          ::wxEvent* event;
3043         sipwxHVScrolledWindow *sipCpp;
3044 
3045         static const char *sipKwdList[] = {
3046             sipName_event,
3047         };
3048 
3049         if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ9", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp, sipType_wxEvent, &event))
3050         {
3051             bool sipRes;
3052 
3053             PyErr_Clear();
3054 
3055             Py_BEGIN_ALLOW_THREADS
3056             sipRes = sipCpp->sipProtectVirt_TryAfter(sipSelfWasArg,*event);
3057             Py_END_ALLOW_THREADS
3058 
3059             if (PyErr_Occurred())
3060                 return 0;
3061 
3062             return PyBool_FromLong(sipRes);
3063         }
3064     }
3065 
3066     /* Raise an exception if the arguments couldn't be parsed. */
3067     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_TryAfter, doc_wxHVScrolledWindow_TryAfter);
3068 
3069     return SIP_NULLPTR;
3070 }
3071 
3072 
3073 PyDoc_STRVAR(doc_wxHVScrolledWindow_GetClassDefaultAttributes, "GetClassDefaultAttributes(variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes");
3074 
3075 extern "C" {static PyObject *meth_wxHVScrolledWindow_GetClassDefaultAttributes(PyObject *, PyObject *, PyObject *);}
meth_wxHVScrolledWindow_GetClassDefaultAttributes(PyObject *,PyObject * sipArgs,PyObject * sipKwds)3076 static PyObject *meth_wxHVScrolledWindow_GetClassDefaultAttributes(PyObject *, PyObject *sipArgs, PyObject *sipKwds)
3077 {
3078     PyObject *sipParseErr = SIP_NULLPTR;
3079 
3080     {
3081          ::wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL;
3082 
3083         static const char *sipKwdList[] = {
3084             sipName_variant,
3085         };
3086 
3087         if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "|E", sipType_wxWindowVariant, &variant))
3088         {
3089              ::wxVisualAttributes*sipRes;
3090 
3091         if (!wxPyCheckForApp()) return NULL;
3092 
3093             PyErr_Clear();
3094 
3095             Py_BEGIN_ALLOW_THREADS
3096             sipRes = new  ::wxVisualAttributes( ::wxHVScrolledWindow::GetClassDefaultAttributes(variant));
3097             Py_END_ALLOW_THREADS
3098 
3099             if (PyErr_Occurred())
3100                 return 0;
3101 
3102             return sipConvertFromNewType(sipRes,sipType_wxVisualAttributes,SIP_NULLPTR);
3103         }
3104     }
3105 
3106     /* Raise an exception if the arguments couldn't be parsed. */
3107     sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_GetClassDefaultAttributes, SIP_NULLPTR);
3108 
3109     return SIP_NULLPTR;
3110 }
3111 
3112 
3113 /* Cast a pointer to a type somewhere in its inheritance hierarchy. */
3114 extern "C" {static void *cast_wxHVScrolledWindow(void *, const sipTypeDef *);}
cast_wxHVScrolledWindow(void * sipCppV,const sipTypeDef * targetType)3115 static void *cast_wxHVScrolledWindow(void *sipCppV, const sipTypeDef *targetType)
3116 {
3117      ::wxHVScrolledWindow *sipCpp = reinterpret_cast< ::wxHVScrolledWindow *>(sipCppV);
3118 
3119     if (targetType == sipType_wxPanel)
3120         return static_cast< ::wxPanel *>(sipCpp);
3121 
3122     if (targetType == sipType_wxWindow)
3123         return static_cast< ::wxWindow *>(sipCpp);
3124 
3125     if (targetType == sipType_wxWindowBase)
3126         return static_cast< ::wxWindowBase *>(sipCpp);
3127 
3128     if (targetType == sipType_wxEvtHandler)
3129         return static_cast< ::wxEvtHandler *>(sipCpp);
3130 
3131     if (targetType == sipType_wxObject)
3132         return static_cast< ::wxObject *>(sipCpp);
3133 
3134     if (targetType == sipType_wxTrackable)
3135         return static_cast< ::wxTrackable *>(sipCpp);
3136 
3137     if (targetType == sipType_wxVarHVScrollHelper)
3138         return static_cast< ::wxVarHVScrollHelper *>(sipCpp);
3139 
3140     if (targetType == sipType_wxVarVScrollHelper)
3141         return static_cast< ::wxVarVScrollHelper *>(sipCpp);
3142 
3143     if (targetType == sipType_wxVarHScrollHelper)
3144         return static_cast< ::wxVarHScrollHelper *>(sipCpp);
3145 
3146     return sipCppV;
3147 }
3148 
3149 
3150 /* Call the instance's destructor. */
3151 extern "C" {static void release_wxHVScrolledWindow(void *, int);}
release_wxHVScrolledWindow(void * sipCppV,int sipState)3152 static void release_wxHVScrolledWindow(void *sipCppV, int sipState)
3153 {
3154     Py_BEGIN_ALLOW_THREADS
3155 
3156     if (sipState & SIP_DERIVED_CLASS)
3157         delete reinterpret_cast<sipwxHVScrolledWindow *>(sipCppV);
3158     else
3159         delete reinterpret_cast< ::wxHVScrolledWindow *>(sipCppV);
3160 
3161     Py_END_ALLOW_THREADS
3162 }
3163 
3164 
3165 extern "C" {static void dealloc_wxHVScrolledWindow(sipSimpleWrapper *);}
dealloc_wxHVScrolledWindow(sipSimpleWrapper * sipSelf)3166 static void dealloc_wxHVScrolledWindow(sipSimpleWrapper *sipSelf)
3167 {
3168     if (sipIsDerivedClass(sipSelf))
3169         reinterpret_cast<sipwxHVScrolledWindow *>(sipGetAddress(sipSelf))->sipPySelf = SIP_NULLPTR;
3170 
3171     if (sipIsOwnedByPython(sipSelf))
3172     {
3173         release_wxHVScrolledWindow(sipGetAddress(sipSelf), sipIsDerivedClass(sipSelf));
3174     }
3175 }
3176 
3177 
3178 extern "C" {static void *init_type_wxHVScrolledWindow(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
init_type_wxHVScrolledWindow(sipSimpleWrapper * sipSelf,PyObject * sipArgs,PyObject * sipKwds,PyObject ** sipUnused,PyObject ** sipOwner,PyObject ** sipParseErr)3179 static void *init_type_wxHVScrolledWindow(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **sipOwner, PyObject **sipParseErr)
3180 {
3181     sipwxHVScrolledWindow *sipCpp = SIP_NULLPTR;
3182 
3183     {
3184         if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, SIP_NULLPTR, sipUnused, ""))
3185         {
3186 
3187         if (!wxPyCheckForApp()) return NULL;
3188 
3189             PyErr_Clear();
3190 
3191             Py_BEGIN_ALLOW_THREADS
3192             sipCpp = new sipwxHVScrolledWindow();
3193             Py_END_ALLOW_THREADS
3194 
3195             if (PyErr_Occurred())
3196             {
3197                 delete sipCpp;
3198                 return SIP_NULLPTR;
3199             }
3200 
3201             sipCpp->sipPySelf = sipSelf;
3202 
3203             return sipCpp;
3204         }
3205     }
3206 
3207     {
3208          ::wxWindow* parent;
3209          ::wxWindowID id = wxID_ANY;
3210         const  ::wxPoint& posdef = wxDefaultPosition;
3211         const  ::wxPoint* pos = &posdef;
3212         int posState = 0;
3213         const  ::wxSize& sizedef = wxDefaultSize;
3214         const  ::wxSize* size = &sizedef;
3215         int sizeState = 0;
3216         long style = 0;
3217         const  ::wxString& namedef = wxPanelNameStr;
3218         const  ::wxString* name = &namedef;
3219         int nameState = 0;
3220 
3221         static const char *sipKwdList[] = {
3222             sipName_parent,
3223             sipName_id,
3224             sipName_pos,
3225             sipName_size,
3226             sipName_style,
3227             sipName_name,
3228         };
3229 
3230         if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "JH|iJ1J1lJ1", sipType_wxWindow, &parent, sipOwner, &id, sipType_wxPoint, &pos, &posState, sipType_wxSize, &size, &sizeState, &style, sipType_wxString,&name, &nameState))
3231         {
3232 
3233         if (!wxPyCheckForApp()) return NULL;
3234 
3235             PyErr_Clear();
3236 
3237             Py_BEGIN_ALLOW_THREADS
3238             sipCpp = new sipwxHVScrolledWindow(parent,id,*pos,*size,style,*name);
3239             Py_END_ALLOW_THREADS
3240             sipReleaseType(const_cast< ::wxPoint *>(pos),sipType_wxPoint,posState);
3241             sipReleaseType(const_cast< ::wxSize *>(size),sipType_wxSize,sizeState);
3242             sipReleaseType(const_cast< ::wxString *>(name),sipType_wxString,nameState);
3243 
3244             if (PyErr_Occurred())
3245             {
3246                 delete sipCpp;
3247                 return SIP_NULLPTR;
3248             }
3249 
3250             sipCpp->sipPySelf = sipSelf;
3251 
3252             return sipCpp;
3253         }
3254     }
3255 
3256     return SIP_NULLPTR;
3257 }
3258 
3259 
3260 /* Define this type's super-types. */
3261 static sipEncodedTypeDef supers_wxHVScrolledWindow[] = {{373, 255, 0}, {562, 255, 1}};
3262 
3263 
3264 static PyMethodDef methods_wxHVScrolledWindow[] = {
3265     {SIP_MLNAME_CAST(sipName_AcceptsFocus), meth_wxHVScrolledWindow_AcceptsFocus, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_AcceptsFocus)},
3266     {SIP_MLNAME_CAST(sipName_AcceptsFocusFromKeyboard), meth_wxHVScrolledWindow_AcceptsFocusFromKeyboard, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_AcceptsFocusFromKeyboard)},
3267     {SIP_MLNAME_CAST(sipName_AcceptsFocusRecursively), meth_wxHVScrolledWindow_AcceptsFocusRecursively, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_AcceptsFocusRecursively)},
3268     {SIP_MLNAME_CAST(sipName_AddChild), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_AddChild), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_AddChild)},
3269     {SIP_MLNAME_CAST(sipName_Create), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_Create), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_Create)},
3270     {SIP_MLNAME_CAST(sipName_Destroy), meth_wxHVScrolledWindow_Destroy, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_Destroy)},
3271     {SIP_MLNAME_CAST(sipName_DoEnable), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_DoEnable), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_DoEnable)},
3272     {SIP_MLNAME_CAST(sipName_DoFreeze), meth_wxHVScrolledWindow_DoFreeze, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_DoFreeze)},
3273     {SIP_MLNAME_CAST(sipName_DoGetBestClientSize), meth_wxHVScrolledWindow_DoGetBestClientSize, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_DoGetBestClientSize)},
3274     {SIP_MLNAME_CAST(sipName_DoGetBestSize), meth_wxHVScrolledWindow_DoGetBestSize, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_DoGetBestSize)},
3275     {SIP_MLNAME_CAST(sipName_DoGetBorderSize), meth_wxHVScrolledWindow_DoGetBorderSize, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_DoGetBorderSize)},
3276     {SIP_MLNAME_CAST(sipName_DoGetClientSize), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_DoGetClientSize), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_DoGetClientSize)},
3277     {SIP_MLNAME_CAST(sipName_DoGetPosition), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_DoGetPosition), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_DoGetPosition)},
3278     {SIP_MLNAME_CAST(sipName_DoGetSize), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_DoGetSize), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_DoGetSize)},
3279     {SIP_MLNAME_CAST(sipName_DoMoveWindow), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_DoMoveWindow), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_DoMoveWindow)},
3280     {SIP_MLNAME_CAST(sipName_DoSetClientSize), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_DoSetClientSize), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_DoSetClientSize)},
3281     {SIP_MLNAME_CAST(sipName_DoSetSize), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_DoSetSize), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_DoSetSize)},
3282     {SIP_MLNAME_CAST(sipName_DoSetSizeHints), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_DoSetSizeHints), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_DoSetSizeHints)},
3283     {SIP_MLNAME_CAST(sipName_DoSetWindowVariant), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_DoSetWindowVariant), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_DoSetWindowVariant)},
3284     {SIP_MLNAME_CAST(sipName_DoThaw), meth_wxHVScrolledWindow_DoThaw, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_DoThaw)},
3285     {SIP_MLNAME_CAST(sipName_EstimateTotalHeight), meth_wxHVScrolledWindow_EstimateTotalHeight, METH_VARARGS, SIP_NULLPTR},
3286     {SIP_MLNAME_CAST(sipName_EstimateTotalWidth), meth_wxHVScrolledWindow_EstimateTotalWidth, METH_VARARGS, SIP_NULLPTR},
3287     {SIP_MLNAME_CAST(sipName_GetClassDefaultAttributes), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_GetClassDefaultAttributes), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_GetClassDefaultAttributes)},
3288     {SIP_MLNAME_CAST(sipName_GetClientAreaOrigin), meth_wxHVScrolledWindow_GetClientAreaOrigin, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_GetClientAreaOrigin)},
3289     {SIP_MLNAME_CAST(sipName_GetDefaultBorder), meth_wxHVScrolledWindow_GetDefaultBorder, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_GetDefaultBorder)},
3290     {SIP_MLNAME_CAST(sipName_GetDefaultBorderForControl), meth_wxHVScrolledWindow_GetDefaultBorderForControl, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_GetDefaultBorderForControl)},
3291     {SIP_MLNAME_CAST(sipName_GetMainWindowOfCompositeControl), meth_wxHVScrolledWindow_GetMainWindowOfCompositeControl, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_GetMainWindowOfCompositeControl)},
3292     {SIP_MLNAME_CAST(sipName_GetValidator), meth_wxHVScrolledWindow_GetValidator, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_GetValidator)},
3293     {SIP_MLNAME_CAST(sipName_HasTransparentBackground), meth_wxHVScrolledWindow_HasTransparentBackground, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_HasTransparentBackground)},
3294     {SIP_MLNAME_CAST(sipName_InformFirstDirection), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_InformFirstDirection), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_InformFirstDirection)},
3295     {SIP_MLNAME_CAST(sipName_InheritAttributes), meth_wxHVScrolledWindow_InheritAttributes, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_InheritAttributes)},
3296     {SIP_MLNAME_CAST(sipName_InitDialog), meth_wxHVScrolledWindow_InitDialog, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_InitDialog)},
3297     {SIP_MLNAME_CAST(sipName_OnGetColumnWidth), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_OnGetColumnWidth), METH_VARARGS|METH_KEYWORDS, SIP_NULLPTR},
3298     {SIP_MLNAME_CAST(sipName_OnGetColumnsWidthHint), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_OnGetColumnsWidthHint), METH_VARARGS|METH_KEYWORDS, SIP_NULLPTR},
3299     {SIP_MLNAME_CAST(sipName_OnGetRowHeight), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_OnGetRowHeight), METH_VARARGS|METH_KEYWORDS, SIP_NULLPTR},
3300     {SIP_MLNAME_CAST(sipName_OnGetRowsHeightHint), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_OnGetRowsHeightHint), METH_VARARGS|METH_KEYWORDS, SIP_NULLPTR},
3301     {SIP_MLNAME_CAST(sipName_OnInternalIdle), meth_wxHVScrolledWindow_OnInternalIdle, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_OnInternalIdle)},
3302     {SIP_MLNAME_CAST(sipName_ProcessEvent), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_ProcessEvent), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_ProcessEvent)},
3303     {SIP_MLNAME_CAST(sipName_RemoveChild), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_RemoveChild), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_RemoveChild)},
3304     {SIP_MLNAME_CAST(sipName_SendDestroyEvent), meth_wxHVScrolledWindow_SendDestroyEvent, METH_VARARGS, SIP_NULLPTR},
3305     {SIP_MLNAME_CAST(sipName_SetCanFocus), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_SetCanFocus), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_SetCanFocus)},
3306     {SIP_MLNAME_CAST(sipName_SetValidator), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_SetValidator), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_SetValidator)},
3307     {SIP_MLNAME_CAST(sipName_ShouldInheritColours), meth_wxHVScrolledWindow_ShouldInheritColours, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_ShouldInheritColours)},
3308     {SIP_MLNAME_CAST(sipName_TransferDataFromWindow), meth_wxHVScrolledWindow_TransferDataFromWindow, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_TransferDataFromWindow)},
3309     {SIP_MLNAME_CAST(sipName_TransferDataToWindow), meth_wxHVScrolledWindow_TransferDataToWindow, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_TransferDataToWindow)},
3310     {SIP_MLNAME_CAST(sipName_TryAfter), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_TryAfter), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_TryAfter)},
3311     {SIP_MLNAME_CAST(sipName_TryBefore), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_TryBefore), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_TryBefore)},
3312     {SIP_MLNAME_CAST(sipName_Validate), meth_wxHVScrolledWindow_Validate, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_Validate)}
3313 };
3314 
3315 PyDoc_STRVAR(doc_wxHVScrolledWindow, "HVScrolledWindow()\n"
3316 "HVScrolledWindow(parent, id=ID_ANY, pos=DefaultPosition, size=DefaultSize, style=0, name=PanelNameStr)\n"
3317 "\n"
3318 "This window inherits all functionality of both vertical and\n"
3319 "horizontal, variable scrolled windows.");
3320 
3321 
3322 sipClassTypeDef sipTypeDef__core_wxHVScrolledWindow = {
3323     {
3324         -1,
3325         SIP_NULLPTR,
3326         SIP_NULLPTR,
3327         SIP_TYPE_ABSTRACT|SIP_TYPE_SCC|SIP_TYPE_CLASS,
3328         sipNameNr_wxHVScrolledWindow,
3329         {SIP_NULLPTR},
3330         SIP_NULLPTR
3331     },
3332     {
3333         sipNameNr_HVScrolledWindow,
3334         {0, 0, 1},
3335         48, methods_wxHVScrolledWindow,
3336         0, SIP_NULLPTR,
3337         0, SIP_NULLPTR,
3338         {SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
3339     },
3340     doc_wxHVScrolledWindow,
3341     -1,
3342     -1,
3343     supers_wxHVScrolledWindow,
3344     SIP_NULLPTR,
3345     init_type_wxHVScrolledWindow,
3346     SIP_NULLPTR,
3347     SIP_NULLPTR,
3348 #if PY_MAJOR_VERSION >= 3
3349     SIP_NULLPTR,
3350     SIP_NULLPTR,
3351 #else
3352     SIP_NULLPTR,
3353     SIP_NULLPTR,
3354     SIP_NULLPTR,
3355     SIP_NULLPTR,
3356 #endif
3357     dealloc_wxHVScrolledWindow,
3358     SIP_NULLPTR,
3359     SIP_NULLPTR,
3360     SIP_NULLPTR,
3361     release_wxHVScrolledWindow,
3362     cast_wxHVScrolledWindow,
3363     SIP_NULLPTR,
3364     SIP_NULLPTR,
3365     SIP_NULLPTR,
3366     SIP_NULLPTR,
3367     SIP_NULLPTR,
3368     SIP_NULLPTR
3369 };
3370