static int convertTo_QList_0100QsciStyledText(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
QList<QsciStyledText> **sipCppPtr = reinterpret_cast<QList<QsciStyledText> **>(sipCppPtrV);
#line 64 "/opt/local/Library/Frameworks/Python.framework/Versions/2.7/share/sip/PyQt4/QtCore/qlist.sip"
SIP_SSIZE_T len;
// Check the type if that is all that is required.
if (sipIsErr == NULL)
{
if (!PySequence_Check(sipPy) || (len = PySequence_Size(sipPy)) < 0)
return 0;
for (SIP_SSIZE_T i = 0; i < len; ++i)
{
PyObject *itm = PySequence_ITEM(sipPy, i);
bool ok = (itm && sipCanConvertToType(itm, sipType_QsciStyledText, SIP_NOT_NONE));
Py_XDECREF(itm);
if (!ok)
return 0;
}
return 1;
}
QList<QsciStyledText> *ql = new QList<QsciStyledText>;
len = PySequence_Size(sipPy);
for (SIP_SSIZE_T i = 0; i < len; ++i)
{
PyObject *itm = PySequence_ITEM(sipPy, i);
int state;
QsciStyledText *t = reinterpret_cast<QsciStyledText *>(sipConvertToType(itm, sipType_QsciStyledText, sipTransferObj, SIP_NOT_NONE, &state, sipIsErr));
Py_DECREF(itm);
if (*sipIsErr)
{
sipReleaseType(t, sipType_QsciStyledText, state);
delete ql;
return 0;
}
ql->append(*t);
sipReleaseType(t, sipType_QsciStyledText, state);
}
*sipCppPtr = ql;
return sipGetState(sipTransferObj);
#line 126 "./sipQsciQList0100QsciStyledText.cpp"
}
static int convertTo_QList_0100QModelIndex(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
QList<QModelIndex> **sipCppPtr = reinterpret_cast<QList<QModelIndex> **>(sipCppPtrV);
#line 59 "/home/vikky/Desktop/DVCS/stuff/scrapy/soft/PyQt-x11-gpl-4.11.4/sip/QtCore/qlist.sip"
SIP_SSIZE_T len;
// Check the type if that is all that is required.
if (sipIsErr == NULL)
{
if (!PySequence_Check(sipPy) || (len = PySequence_Size(sipPy)) < 0)
return 0;
for (SIP_SSIZE_T i = 0; i < len; ++i)
{
PyObject *itm = PySequence_ITEM(sipPy, i);
bool ok = (itm && sipCanConvertToType(itm, sipType_QModelIndex, SIP_NOT_NONE));
Py_XDECREF(itm);
if (!ok)
return 0;
}
return 1;
}
QList<QModelIndex> *ql = new QList<QModelIndex>;
len = PySequence_Size(sipPy);
for (SIP_SSIZE_T i = 0; i < len; ++i)
{
PyObject *itm = PySequence_ITEM(sipPy, i);
int state;
QModelIndex *t = reinterpret_cast<QModelIndex *>(sipConvertToType(itm, sipType_QModelIndex, sipTransferObj, SIP_NOT_NONE, &state, sipIsErr));
Py_DECREF(itm);
if (*sipIsErr)
{
sipReleaseType(t, sipType_QModelIndex, state);
delete ql;
return 0;
}
ql->append(*t);
sipReleaseType(t, sipType_QModelIndex, state);
}
*sipCppPtr = ql;
return sipGetState(sipTransferObj);
#line 123 "/home/vikky/Desktop/DVCS/stuff/scrapy/soft/PyQt-x11-gpl-4.11.4/QtCore/sipQtCoreQList0100QModelIndex.cpp"
}
static int convertTo_QList_0100QSize(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
QList<QSize> **sipCppPtr = reinterpret_cast<QList<QSize> **>(sipCppPtrV);
#line 69 "/home/tsheasha/GUC/Bachelors/android-python27/python-build/PyQt-x11-gpl-4.8/sip/QtCore/qlist.sip"
SIP_SSIZE_T len;
// Check the type if that is all that is required.
if (sipIsErr == NULL)
{
if (!PySequence_Check(sipPy) || (len = PySequence_Size(sipPy)) < 0)
return 0;
for (SIP_SSIZE_T i = 0; i < len; ++i)
{
PyObject *itm = PySequence_ITEM(sipPy, i);
bool ok = (itm && sipCanConvertToType(itm, sipType_QSize, SIP_NOT_NONE));
Py_XDECREF(itm);
if (!ok)
return 0;
}
return 1;
}
QList<QSize> *ql = new QList<QSize>;
len = PySequence_Size(sipPy);
for (SIP_SSIZE_T i = 0; i < len; ++i)
{
PyObject *itm = PySequence_ITEM(sipPy, i);
int state;
QSize *t = reinterpret_cast<QSize *>(sipConvertToType(itm, sipType_QSize, sipTransferObj, SIP_NOT_NONE, &state, sipIsErr));
Py_DECREF(itm);
if (*sipIsErr)
{
sipReleaseType(t, sipType_QSize, state);
delete ql;
return 0;
}
ql->append(*t);
sipReleaseType(t, sipType_QSize, state);
}
*sipCppPtr = ql;
return sipGetState(sipTransferObj);
#line 133 "sipQtGuiQList0100QSize.cpp"
}
static int convertTo_QList_0100QSize(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
QList<QSize> **sipCppPtr = reinterpret_cast<QList<QSize> **>(sipCppPtrV);
#line 64 "sip/QtCore/qlist.sip"
SIP_SSIZE_T len;
// Check the type if that is all that is required.
if (sipIsErr == NULL)
{
if (!PySequence_Check(sipPy) || (len = PySequence_Size(sipPy)) < 0)
return 0;
for (SIP_SSIZE_T i = 0; i < len; ++i)
{
PyObject *itm = PySequence_ITEM(sipPy, i);
bool ok = (itm && sipCanConvertToType(itm, sipType_QSize, SIP_NOT_NONE));
Py_XDECREF(itm);
if (!ok)
return 0;
}
return 1;
}
QList<QSize> *ql = new QList<QSize>;
len = PySequence_Size(sipPy);
for (SIP_SSIZE_T i = 0; i < len; ++i)
{
PyObject *itm = PySequence_ITEM(sipPy, i);
int state;
QSize *t = reinterpret_cast<QSize *>(sipConvertToType(itm, sipType_QSize, sipTransferObj, SIP_NOT_NONE, &state, sipIsErr));
Py_DECREF(itm);
if (*sipIsErr)
{
sipReleaseType(t, sipType_QSize, state);
delete ql;
return 0;
}
ql->append(*t);
sipReleaseType(t, sipType_QSize, state);
}
*sipCppPtr = ql;
return sipGetState(sipTransferObj);
#line 128 "/Users/ktaylora/PLJV/tillage_likelihood_model/gui/PyQt4/QtGui/sipQtGuiQList0100QSize.cpp"
}
static int convertTo_QList_0100QNetworkProxy(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
QList<QNetworkProxy> **sipCppPtr = reinterpret_cast<QList<QNetworkProxy> **>(sipCppPtrV);
#line 64 "/Users/Kunwiji/Dropbox/Spectroscopy_paper/PyQt-mac-gpl-4.11.2/sip/QtCore/qlist.sip"
SIP_SSIZE_T len;
// Check the type if that is all that is required.
if (sipIsErr == NULL)
{
if (!PySequence_Check(sipPy) || (len = PySequence_Size(sipPy)) < 0)
return 0;
for (SIP_SSIZE_T i = 0; i < len; ++i)
{
PyObject *itm = PySequence_ITEM(sipPy, i);
bool ok = (itm && sipCanConvertToType(itm, sipType_QNetworkProxy, SIP_NOT_NONE));
Py_XDECREF(itm);
if (!ok)
return 0;
}
return 1;
}
QList<QNetworkProxy> *ql = new QList<QNetworkProxy>;
len = PySequence_Size(sipPy);
for (SIP_SSIZE_T i = 0; i < len; ++i)
{
PyObject *itm = PySequence_ITEM(sipPy, i);
int state;
QNetworkProxy *t = reinterpret_cast<QNetworkProxy *>(sipConvertToType(itm, sipType_QNetworkProxy, sipTransferObj, SIP_NOT_NONE, &state, sipIsErr));
Py_DECREF(itm);
if (*sipIsErr)
{
sipReleaseType(t, sipType_QNetworkProxy, state);
delete ql;
return 0;
}
ql->append(*t);
sipReleaseType(t, sipType_QNetworkProxy, state);
}
*sipCppPtr = ql;
return sipGetState(sipTransferObj);
#line 128 "/Users/Kunwiji/Dropbox/Spectroscopy_paper/PyQt-mac-gpl-4.11.2/QtNetwork/sipQtNetworkQList0100QNetworkProxy.cpp"
}
static int convertTo_QList_0100QLocale(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
QList< ::QLocale> **sipCppPtr = reinterpret_cast<QList< ::QLocale> **>(sipCppPtrV);
#line 59 "/home/thais/Faculdade/TCC/NEW/PyQt4_gpl_x11-4.12/sip/QtCore/qlist.sip"
SIP_SSIZE_T len;
// Check the type if that is all that is required.
if (sipIsErr == NULL)
{
if (!PySequence_Check(sipPy) || (len = PySequence_Size(sipPy)) < 0)
return 0;
for (SIP_SSIZE_T i = 0; i < len; ++i)
{
PyObject *itm = PySequence_ITEM(sipPy, i);
bool ok = (itm && sipCanConvertToType(itm, sipType_QLocale, SIP_NOT_NONE));
Py_XDECREF(itm);
if (!ok)
return 0;
}
return 1;
}
QList<QLocale> *ql = new QList<QLocale>;
len = PySequence_Size(sipPy);
for (SIP_SSIZE_T i = 0; i < len; ++i)
{
PyObject *itm = PySequence_ITEM(sipPy, i);
int state;
QLocale *t = reinterpret_cast<QLocale *>(sipConvertToType(itm, sipType_QLocale, sipTransferObj, SIP_NOT_NONE, &state, sipIsErr));
Py_DECREF(itm);
if (*sipIsErr)
{
sipReleaseType(t, sipType_QLocale, state);
delete ql;
return 0;
}
ql->append(*t);
sipReleaseType(t, sipType_QLocale, state);
}
*sipCppPtr = ql;
return sipGetState(sipTransferObj);
#line 123 "/home/thais/Faculdade/TCC/NEW/PyQt4_gpl_x11-4.12/QtCore/sipQtCoreQList0100QLocale.cpp"
}
static int convertTo_QList_0101QTableWidgetItem(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
QList<QTableWidgetItem*> **sipCppPtr = reinterpret_cast<QList<QTableWidgetItem*> **>(sipCppPtrV);
#line 145 "sip/QtCore/qlist.sip"
SIP_SSIZE_T len;
// Check the type if that is all that is required.
if (sipIsErr == NULL)
{
if (!PySequence_Check(sipPy) || (len = PySequence_Size(sipPy)) < 0)
return 0;
for (SIP_SSIZE_T i = 0; i < len; ++i)
{
PyObject *itm = PySequence_ITEM(sipPy, i);
bool ok = (itm && sipCanConvertToType(itm, sipType_QTableWidgetItem, 0));
Py_XDECREF(itm);
if (!ok)
return 0;
}
return 1;
}
QList<QTableWidgetItem *> *ql = new QList<QTableWidgetItem *>;
len = PySequence_Size(sipPy);
for (SIP_SSIZE_T i = 0; i < len; ++i)
{
PyObject *itm = PySequence_ITEM(sipPy, i);
QTableWidgetItem *t = reinterpret_cast<QTableWidgetItem *>(sipConvertToType(itm, sipType_QTableWidgetItem, sipTransferObj, 0, 0, sipIsErr));
Py_DECREF(itm);
if (*sipIsErr)
{
delete ql;
return 0;
}
ql->append(t);
}
*sipCppPtr = ql;
return sipGetState(sipTransferObj);
#line 118 "/home/vikky/Desktop/DVCS/stuff/scrapy/soft/PyQt-x11-gpl-4.11.4/QtGui/sipQtGuiQList0101QTableWidgetItem.cpp"
}
static int convertTo_QList_0101QAction(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
QList< ::QAction*> **sipCppPtr = reinterpret_cast<QList< ::QAction*> **>(sipCppPtrV);
#line 145 "sip/QtCore/qlist.sip"
SIP_SSIZE_T len;
// Check the type if that is all that is required.
if (sipIsErr == NULL)
{
if (!PySequence_Check(sipPy) || (len = PySequence_Size(sipPy)) < 0)
return 0;
for (SIP_SSIZE_T i = 0; i < len; ++i)
{
PyObject *itm = PySequence_ITEM(sipPy, i);
bool ok = (itm && sipCanConvertToType(itm, sipType_QAction, 0));
Py_XDECREF(itm);
if (!ok)
return 0;
}
return 1;
}
QList<QAction *> *ql = new QList<QAction *>;
len = PySequence_Size(sipPy);
for (SIP_SSIZE_T i = 0; i < len; ++i)
{
PyObject *itm = PySequence_ITEM(sipPy, i);
QAction *t = reinterpret_cast<QAction *>(sipConvertToType(itm, sipType_QAction, sipTransferObj, 0, 0, sipIsErr));
Py_DECREF(itm);
if (*sipIsErr)
{
delete ql;
return 0;
}
ql->append(t);
}
*sipCppPtr = ql;
return sipGetState(sipTransferObj);
#line 118 "/home/thais/Faculdade/TCC/NEW/PyQt4_gpl_x11-4.12/QtGui/sipQtGuiQList0101QAction.cpp"
}
static int convertTo_QList_0101qt_gui_cpp_PluginProvider(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
QList<qt_gui_cpp::PluginProvider*> **sipCppPtr = reinterpret_cast<QList<qt_gui_cpp::PluginProvider*> **>(sipCppPtrV);
#line 145 "/usr/share/sip/PyQt4/QtCore/qlist.sip"
SIP_SSIZE_T len;
// Check the type if that is all that is required.
if (sipIsErr == NULL)
{
if (!PySequence_Check(sipPy) || (len = PySequence_Size(sipPy)) < 0)
return 0;
for (SIP_SSIZE_T i = 0; i < len; ++i)
{
PyObject *itm = PySequence_ITEM(sipPy, i);
bool ok = (itm && sipCanConvertToType(itm, sipType_qt_gui_cpp_PluginProvider, 0));
Py_XDECREF(itm);
if (!ok)
return 0;
}
return 1;
}
QList<qt_gui_cpp::PluginProvider *> *ql = new QList<qt_gui_cpp::PluginProvider *>;
len = PySequence_Size(sipPy);
for (SIP_SSIZE_T i = 0; i < len; ++i)
{
PyObject *itm = PySequence_ITEM(sipPy, i);
qt_gui_cpp::PluginProvider *t = reinterpret_cast<qt_gui_cpp::PluginProvider *>(sipConvertToType(itm, sipType_qt_gui_cpp_PluginProvider, sipTransferObj, 0, 0, sipIsErr));
Py_DECREF(itm);
if (*sipIsErr)
{
delete ql;
return 0;
}
ql->append(t);
}
*sipCppPtr = ql;
return sipGetState(sipTransferObj);
#line 101 "/opt/ros_catkin_ws/build_isolated/qt_gui_cpp/sip/qt_gui_cpp_sip/siplibqt_gui_cpp_sipQList0101qt_gui_cppPluginProvider.cpp"
}
static int convertTo_QList_0101QsciCommand(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
QList<QsciCommand *> **sipCppPtr = reinterpret_cast<QList<QsciCommand *> **>(sipCppPtrV);
#line 155 "/System/Library/Frameworks/Python.framework/Versions/2.7/share/sip/PyQt4/QtCore/qlist.sip"
SIP_SSIZE_T len;
// Check the type if that is all that is required.
if (sipIsErr == NULL)
{
if (!PySequence_Check(sipPy) || (len = PySequence_Size(sipPy)) < 0)
return 0;
for (SIP_SSIZE_T i = 0; i < len; ++i)
{
PyObject *itm = PySequence_ITEM(sipPy, i);
bool ok = (itm && sipCanConvertToType(itm, sipType_QsciCommand, 0));
Py_XDECREF(itm);
if (!ok)
return 0;
}
return 1;
}
QList<QsciCommand *> *ql = new QList<QsciCommand *>;
len = PySequence_Size(sipPy);
for (SIP_SSIZE_T i = 0; i < len; ++i)
{
PyObject *itm = PySequence_ITEM(sipPy, i);
QsciCommand *t = reinterpret_cast<QsciCommand *>(sipConvertToType(itm, sipType_QsciCommand, sipTransferObj, 0, 0, sipIsErr));
Py_DECREF(itm);
if (*sipIsErr)
{
delete ql;
return 0;
}
ql->append(t);
}
*sipCppPtr = ql;
return sipGetState(sipTransferObj);
#line 128 "./sipQsciQList0101QsciCommand.cpp"
}
static int convertTo_QList_0101QAction(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
QList<QAction*> **sipCppPtr = reinterpret_cast<QList<QAction*> **>(sipCppPtrV);
#line 150 "/Users/Kunwiji/Dropbox/Spectroscopy_paper/PyQt-mac-gpl-4.11.2/sip/QtCore/qlist.sip"
SIP_SSIZE_T len;
// Check the type if that is all that is required.
if (sipIsErr == NULL)
{
if (!PySequence_Check(sipPy) || (len = PySequence_Size(sipPy)) < 0)
return 0;
for (SIP_SSIZE_T i = 0; i < len; ++i)
{
PyObject *itm = PySequence_ITEM(sipPy, i);
bool ok = (itm && sipCanConvertToType(itm, sipType_QAction, 0));
Py_XDECREF(itm);
if (!ok)
return 0;
}
return 1;
}
QList<QAction *> *ql = new QList<QAction *>;
len = PySequence_Size(sipPy);
for (SIP_SSIZE_T i = 0; i < len; ++i)
{
PyObject *itm = PySequence_ITEM(sipPy, i);
QAction *t = reinterpret_cast<QAction *>(sipConvertToType(itm, sipType_QAction, sipTransferObj, 0, 0, sipIsErr));
Py_DECREF(itm);
if (*sipIsErr)
{
delete ql;
return 0;
}
ql->append(t);
}
*sipCppPtr = ql;
return sipGetState(sipTransferObj);
#line 123 "/Users/Kunwiji/Dropbox/Spectroscopy_paper/PyQt-mac-gpl-4.11.2/QtGui/sipQtGuiQList0101QAction.cpp"
}
// Convert a Python sequence object to a QStringList. This should only be
// called after a successful call to qpycore_PySequence_Check_QStringList().
QStringList qpycore_PySequence_AsQStringList(PyObject *obj)
{
QStringList qstrlst;
SIP_SSIZE_T len = PySequence_Size(obj);
for (SIP_SSIZE_T i = 0; i < len; ++i)
{
PyObject *itm = PySequence_ITEM(obj, i);
int state, iserr = 0;
QString *qs = reinterpret_cast<QString *>(sipConvertToType(itm, sipType_QString, 0, SIP_NOT_NONE, &state, &iserr));
Py_DECREF(itm);
if (iserr)
{
// This should never happen.
sipReleaseType(qs, sipType_QString, state);
return QStringList();
}
qstrlst.append(*qs);
sipReleaseType(qs, sipType_QString, state);
}
return qstrlst;
}
int
ColMap_construct_list(ColMap *self, PyObject *map)
{
int i = 0, len = 0;
int *lmap;
PyObject*tmp;
if(!PySequence_Check(map)){
return 0;
}
len = (int)PySequence_Size(map);
if(len<0)
return 0;
self->lmap_len = len;
lmap = PyMem_Malloc(sizeof(int) * len);
if(lmap==NULL)
return 0;
for(i=0; i<len; ++i){
tmp = PySequence_ITEM(map, (Py_ssize_t)i);
if(tmp==NULL){
return 0;
}
lmap[i] = (int)PyInt_AsLong(tmp);
}
self->lmap = lmap;
return 1;
}
static bool
_py_build_signature(uint32_t *argc, int **signature, PyObject *co_argcount, PyObject *co_varnames, PyObject *annotations)
{
bool success = false;
assert(argc != NULL);
assert(*argc == 0);
assert(signature != NULL);
assert(*signature == NULL);
assert(co_argcount != NULL);
assert(PyLong_Check(co_argcount));
assert(co_varnames != NULL);
assert(PySequence_Check(co_varnames));
assert(annotations != NULL);
assert(PyMapping_Check(annotations));
long argcount = PyLong_AsLong(co_argcount);
if(argcount > 0)
{
PyObject *var = PySequence_ITEM(co_varnames, 0);
CallbackArgType type = _py_map_typehint(annotations, var);
Py_XDECREF(var);
if(type == CALLBACK_ARG_TYPE_STRING)
{
*argc = argcount - 1;
if(*argc)
{
*signature = utils_new(*argc, int);
}
else
{
static CYTHON_INLINE int __Pyx_unpack_tuple2(PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2,
int is_tuple, int has_known_size, int decref_tuple) {
Py_ssize_t index;
PyObject *value1 = NULL, *value2 = NULL, *iter = NULL;
if (!is_tuple && unlikely(!PyTuple_Check(tuple))) {
iternextfunc iternext;
iter = PyObject_GetIter(tuple);
if (unlikely(!iter)) goto bad;
if (decref_tuple) { Py_DECREF(tuple); tuple = NULL; }
iternext = Py_TYPE(iter)->tp_iternext;
value1 = iternext(iter); if (unlikely(!value1)) { index = 0; goto unpacking_failed; }
value2 = iternext(iter); if (unlikely(!value2)) { index = 1; goto unpacking_failed; }
if (!has_known_size && unlikely(__Pyx_IternextUnpackEndCheck(iternext(iter), 2))) goto bad;
Py_DECREF(iter);
} else {
if (!has_known_size && unlikely(PyTuple_GET_SIZE(tuple) != 2)) {
__Pyx_UnpackTupleError(tuple, 2);
goto bad;
}
#if CYTHON_COMPILING_IN_PYPY
value1 = PySequence_ITEM(tuple, 0);
if (unlikely(!value1)) goto bad;
value2 = PySequence_ITEM(tuple, 1);
if (unlikely(!value2)) goto bad;
#else
value1 = PyTuple_GET_ITEM(tuple, 0);
value2 = PyTuple_GET_ITEM(tuple, 1);
Py_INCREF(value1);
Py_INCREF(value2);
#endif
if (decref_tuple) { Py_DECREF(tuple); }
}
*pvalue1 = value1;
*pvalue2 = value2;
return 0;
unpacking_failed:
if (!has_known_size && __Pyx_IterFinish() == 0)
__Pyx_RaiseNeedMoreValuesError(index);
bad:
Py_XDECREF(iter);
Py_XDECREF(value1);
Py_XDECREF(value2);
if (decref_tuple) { Py_XDECREF(tuple); }
return -1;
}
int
_moo_pyobject_to_boxed_array (PyObject *obj,
MooPtrArray **dest)
{
int len, i;
PyTypeObject *type;
type = moo_get_pygboxed_type();
g_return_val_if_fail(type != NULL, FALSE);
if (obj == Py_None)
{
*dest = NULL;
return TRUE;
}
if (!PySequence_Check(obj))
{
PyErr_SetString(PyExc_TypeError,
"argument must be a sequence");
return FALSE;
}
len = PySequence_Size(obj);
if (len < 0)
{
PyErr_SetString(PyExc_RuntimeError,
"got negative length of a sequence");
return FALSE;
}
for (i = 0; i < len; ++i)
{
PyObject *item = PySequence_ITEM(obj, i);
g_return_val_if_fail(item != NULL, FALSE);
// TODO: doesn't check types, will crash
if (!PyObject_TypeCheck(item, &PyGBoxed_Type))
{
PyErr_SetString(PyExc_TypeError,
"argument must be a sequence of boxed objects");
return FALSE;
}
}
*dest = _moo_pyobject_to_boxed_array_no_check(obj, len);
return TRUE;
}
static int
__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) {
int result = 0;
PyObject *res = op->defaults_getter((PyObject *) op);
if (unlikely(!res))
return -1;
// Cache result
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
op->defaults_tuple = PyTuple_GET_ITEM(res, 0);
Py_INCREF(op->defaults_tuple);
op->defaults_kwdict = PyTuple_GET_ITEM(res, 1);
Py_INCREF(op->defaults_kwdict);
#else
op->defaults_tuple = PySequence_ITEM(res, 0);
if (unlikely(!op->defaults_tuple)) result = -1;
else {
op->defaults_kwdict = PySequence_ITEM(res, 1);
if (unlikely(!op->defaults_kwdict)) result = -1;
}
#endif
Py_DECREF(res);
return result;
}
static MooObjectArray *
_moo_pyobject_to_object_array_no_check (PyObject *seq,
int len)
{
int i;
MooObjectArray *ar;
ar = moo_object_array_new ();
for (i = 0; i < len; ++i)
{
PyObject *item = PySequence_ITEM (seq, i);
moo_object_array_append (ar, pygobject_get (item));
}
return ar;
}
int _moo_pyobject_to_strv (PyObject *obj, char ***dest)
{
int len, i;
if (obj == Py_None)
{
*dest = NULL;
return TRUE;
}
if (!PySequence_Check (obj))
{
PyErr_SetString (PyExc_TypeError,
"argument must be a sequence");
return FALSE;
}
len = PySequence_Size (obj);
if (len < 0)
{
PyErr_SetString (PyExc_RuntimeError,
"got negative length of a sequence");
return FALSE;
}
for (i = 0; i < len; ++i)
{
PyObject *item = PySequence_ITEM (obj, i);
g_return_val_if_fail (item != NULL, FALSE);
if (!PyString_Check (item))
{
PyErr_SetString (PyExc_TypeError,
"argument must be a sequence of strings");
return FALSE;
}
}
*dest = _moo_pyobject_to_strv_no_check (obj, len);
return TRUE;
}
static PyObject* __Pyx_Globals(void) {
Py_ssize_t i;
PyObject *names;
PyObject *globals = $moddict_cname;
Py_INCREF(globals);
names = PyObject_Dir($module_cname);
if (!names)
goto bad;
for (i = PyList_GET_SIZE(names)-1; i >= 0; i--) {
#if CYTHON_COMPILING_IN_PYPY
PyObject* name = PySequence_ITEM(names, i);
if (!name)
goto bad;
#else
PyObject* name = PyList_GET_ITEM(names, i);
#endif
if (!PyDict_Contains(globals, name)) {
PyObject* value = __Pyx_GetAttr($module_cname, name);
if (!value) {
#if CYTHON_COMPILING_IN_PYPY
Py_DECREF(name);
#endif
goto bad;
}
if (PyDict_SetItem(globals, name, value) < 0) {
#if CYTHON_COMPILING_IN_PYPY
Py_DECREF(name);
#endif
Py_DECREF(value);
goto bad;
}
}
#if CYTHON_COMPILING_IN_PYPY
Py_DECREF(name);
#endif
}
Py_DECREF(names);
return globals;
bad:
Py_XDECREF(names);
Py_XDECREF(globals);
return NULL;
}
static MooPtrArray *
_moo_pyobject_to_boxed_array_no_check(PyObject *seq,
int len)
{
int i;
MooPtrArray *ar;
ar = moo_ptr_array_new();
moo_ptr_array_reserve(ar, len);
for (i = 0; i < len; ++i)
{
PyObject *item = PySequence_ITEM(seq, i);
gpointer elm = g_boxed_copy(((PyGBoxed*)item)->gtype, pyg_boxed_get(item, void));
moo_ptr_array_append(ar, elm);
}
return ar;
}
// See if a Python sequence object can be converted to a QStringList.
int qpycore_PySequence_Check_QStringList(PyObject *obj)
{
SIP_SSIZE_T len;
if (!PySequence_Check(obj) || (len = PySequence_Size(obj)) < 0)
return 0;
for (SIP_SSIZE_T i = 0; i < len; ++i)
{
PyObject *itm = PySequence_ITEM(obj, i);
bool ok = (itm && sipCanConvertToType(itm, sipType_QString, SIP_NOT_NONE));
Py_XDECREF(itm);
if (!ok)
return 0;
}
return 1;
}
char* parseSignature(PyObject* args)
{
char* signature = 0;
if (args && (Shiboken::String::check(args) || !PySequence_Check(args)))
return getTypeName(args);
for (Py_ssize_t i = 0, i_max = PySequence_Size(args); i < i_max; i++) {
Shiboken::AutoDecRef arg(PySequence_ITEM(args, i));
char* typeName = getTypeName(arg);
if (typeName) {
if (signature) {
signature = reinterpret_cast<char*>(realloc(signature, (strlen(signature) + 1 + strlen(typeName)) * sizeof(char*)));
signature = strcat(signature, ",");
signature = strcat(signature, typeName);
free(typeName);
} else {
signature = typeName;
}
}
}
return signature;
}
static int convertTo_QList_1800(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
QList<int> **sipCppPtr = reinterpret_cast<QList<int> **>(sipCppPtrV);
#line 652 "/home/vikky/Desktop/DVCS/stuff/scrapy/soft/PyQt-x11-gpl-4.11.4/sip/QtCore/qlist.sip"
// Check the type if that is all that is required.
if (sipIsErr == NULL)
return (PySequence_Check(sipPy) && PySequence_Size(sipPy) >= 0);
QList<int> *ql = new QList<int>;
SIP_SSIZE_T len = PySequence_Size(sipPy);
for (SIP_SSIZE_T i = 0; i < len; ++i)
{
PyObject *itm = PySequence_ITEM(sipPy, i);
PyErr_Clear();
long val = itm ? SIPLong_AsLong(itm) : -1;
if (!itm || (val == -1 && PyErr_Occurred()))
{
Py_XDECREF(itm);
delete ql;
*sipIsErr = 1;
return 0;
}
ql->append(val);
Py_DECREF(itm);
}
*sipCppPtr = ql;
return sipGetState(sipTransferObj);
#line 102 "/home/vikky/Desktop/DVCS/stuff/scrapy/soft/PyQt-x11-gpl-4.11.4/QtCore/sipQtCoreQList1800.cpp"
}
static int convertTo_QList_1800(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
QList<int> **sipCppPtr = reinterpret_cast<QList<int> **>(sipCppPtrV);
#line 657 "/Users/Kunwiji/Dropbox/Spectroscopy_paper/PyQt-mac-gpl-4.11.2/sip/QtCore/qlist.sip"
// Check the type if that is all that is required.
if (sipIsErr == NULL)
return (PySequence_Check(sipPy) && PySequence_Size(sipPy) >= 0);
QList<int> *ql = new QList<int>;
SIP_SSIZE_T len = PySequence_Size(sipPy);
for (SIP_SSIZE_T i = 0; i < len; ++i)
{
PyObject *itm = PySequence_ITEM(sipPy, i);
PyErr_Clear();
long val = itm ? SIPLong_AsLong(itm) : -1;
if (!itm || (val == -1 && PyErr_Occurred()))
{
Py_XDECREF(itm);
delete ql;
*sipIsErr = 1;
return 0;
}
ql->append(val);
Py_DECREF(itm);
}
*sipCppPtr = ql;
return sipGetState(sipTransferObj);
#line 107 "/Users/Kunwiji/Dropbox/Spectroscopy_paper/PyQt-mac-gpl-4.11.2/QtCore/sipQtCoreQList1800.cpp"
}
static int convertTo_QList_2400(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
::QList< ::qreal> **sipCppPtr = reinterpret_cast< ::QList< ::qreal> **>(sipCppPtrV);
#line 784 "/home/thais/Faculdade/TCC/NEW/PyQt4_gpl_x11-4.12/sip/QtCore/qlist.sip"
// Check the type if that is all that is required.
if (sipIsErr == NULL)
return (PySequence_Check(sipPy) && PySequence_Size(sipPy) >= 0);
QList<qreal> *ql = new QList<qreal>;
SIP_SSIZE_T len = PySequence_Size(sipPy);
for (SIP_SSIZE_T i = 0; i < len; ++i)
{
PyObject *itm = PySequence_ITEM(sipPy, i);
PyErr_Clear();
double val = itm ? PyFloat_AsDouble(itm) : -1.0;
if (!itm || (val == -1.0 && PyErr_Occurred()))
{
Py_XDECREF(itm);
delete ql;
*sipIsErr = 1;
return 0;
}
ql->append(val);
Py_DECREF(itm);
}
*sipCppPtr = ql;
return sipGetState(sipTransferObj);
#line 102 "/home/thais/Faculdade/TCC/NEW/PyQt4_gpl_x11-4.12/QtCore/sipQtCoreQList2400.cpp"
}
// Create a dynamic meta-object for a Python type by introspecting its
// attributes. Note that it leaks if the type is deleted.
static int create_dynamic_metaobject(pyqtWrapperType *pyqt_wt)
{
PyTypeObject *pytype = (PyTypeObject *)pyqt_wt;
qpycore_metaobject *qo = new qpycore_metaobject;
// Get the super-type's meta-object.
qo->mo.d.superdata = get_qmetaobject((pyqtWrapperType *)pytype->tp_base);
// Get the name of the type. Dynamic types have simple names.
qo->str_data = pytype->tp_name;
qo->str_data.append('\0');
// Go through the class dictionary getting all PyQt properties, slots,
// signals or a (deprecated) sequence of signals.
typedef QPair<PyObject *, PyObject *> prop_data;
QMap<uint, prop_data> pprops;
QList<QByteArray> psigs;
QList<const QMetaObject *> enum_scopes;
SIP_SSIZE_T pos = 0;
PyObject *key, *value;
while (PyDict_Next(pytype->tp_dict, &pos, &key, &value))
{
// See if it is a slot, ie. it has been decorated with pyqtSlot().
PyObject *sig_obj = PyObject_GetAttr(value,
qpycore_signature_attr_name);
if (sig_obj)
{
// Make sure it is a list and not some legitimate attribute that
// happens to use our special name.
if (PyList_Check(sig_obj))
{
for (SIP_SSIZE_T i = 0; i < PyList_GET_SIZE(sig_obj); ++i)
{
qpycore_slot slot;
// Set up the skeleton slot.
PyObject *decoration = PyList_GET_ITEM(sig_obj, i);
slot.signature = Chimera::Signature::fromPyObject(decoration);
slot.sip_slot.pyobj = 0;
slot.sip_slot.name = 0;
slot.sip_slot.meth.mfunc = value;
slot.sip_slot.meth.mself = 0;
#if PY_MAJOR_VERSION < 3
slot.sip_slot.meth.mclass = (PyObject *)pyqt_wt;
#endif
slot.sip_slot.weakSlot = 0;
qo->pslots.append(slot);
}
}
Py_DECREF(sig_obj);
}
else
{
PyErr_Clear();
// Make sure the key is an ASCII string. Delay the error checking
// until we know we actually need it.
const char *ascii_key = sipString_AsASCIIString(&key);
// See if the value is of interest.
if (PyType_IsSubtype(Py_TYPE(value), &qpycore_pyqtProperty_Type))
{
// It is a property.
if (!ascii_key)
return -1;
Py_INCREF(value);
qpycore_pyqtProperty *pp = (qpycore_pyqtProperty *)value;
pprops.insert(pp->pyqtprop_sequence, prop_data(key, value));
// See if the property has a scope. If so, collect all
// QMetaObject pointers that are not in the super-class
// hierarchy.
const QMetaObject *mo = get_scope_qmetaobject(pp->pyqtprop_parsed_type);
if (mo && !enum_scopes.contains(mo))
enum_scopes.append(mo);
}
else if (PyType_IsSubtype(Py_TYPE(value), &qpycore_pyqtSignal_Type))
{
// It is a signal.
if (!ascii_key)
return -1;
qpycore_pyqtSignal *ps = (qpycore_pyqtSignal *)value;
// Make sure the signal has a name.
qpycore_set_signal_name(ps, ascii_key);
// Add all the overloads.
for (int ol = 0; ol < ps->overloads->size(); ++ol)
psigs.append(ps->overloads->at(ol)->signature);
Py_DECREF(key);
}
else if (ascii_key && qstrcmp(ascii_key, "__pyqtSignals__") == 0)
{
// It is a sequence of signal signatures. This is deprecated
// in favour of pyqtSignal().
if (PySequence_Check(value))
{
SIP_SSIZE_T seq_sz = PySequence_Size(value);
for (SIP_SSIZE_T i = 0; i < seq_sz; ++i)
{
PyObject *itm = PySequence_ITEM(value, i);
if (!itm)
{
Py_DECREF(key);
return -1;
}
PyObject *ascii_itm = itm;
const char *ascii = sipString_AsASCIIString(&ascii_itm);
Py_DECREF(itm);
if (!ascii)
{
Py_DECREF(key);
return -1;
}
QByteArray old_sig = QMetaObject::normalizedSignature(ascii);
old_sig.prepend('2');
psigs.append(old_sig);
Py_DECREF(ascii_itm);
}
}
Py_DECREF(key);
}
}
}
qo->nr_signals = psigs.count();
// Create and fill the extradata array.
if (enum_scopes.isEmpty())
{
qo->mo.d.extradata = 0;
}
else
{
const QMetaObject **objects = new const QMetaObject *[enum_scopes.size() + 1];
for (int i = 0; i < enum_scopes.size(); ++i)
objects[i] = enum_scopes.at(i);
objects[enum_scopes.size()] = 0;
qo->mo.d.extradata = objects;
}
// Initialise the header section of the data table. Qt v4.5 introduced
// revision 2 which added constructors. However the design is broken in
// that the static meta-call function doesn't provide enough information to
// determine which Python sub-class of a Qt class is to be created. So we
// stick with revision 1 (and don't allow pyqtSlot() to decorate __init__).
const int revision = 1;
const int header_size = 10;
int data_len = header_size + qo->nr_signals * 5 + qo->pslots.count() * 5 +
pprops.count() * 3 + 1;
uint *data = new uint[data_len];
int g_offset = header_size;
int s_offset = g_offset + qo->nr_signals * 5;
int p_offset = s_offset + qo->pslots.count() * 5;
int empty = 0;
for (int i = 0; i < data_len; ++i)
data[i] = 0;
// The revision number.
data[0] = revision;
// Set up the methods count and offset.
if (qo->nr_signals || qo->pslots.count())
{
data[4] = qo->nr_signals + qo->pslots.count();
data[5] = g_offset;
// We might need an empty string.
empty = qo->str_data.size();
qo->str_data.append('\0');
}
// Set up the properties count and offset.
if (pprops.count())
{
data[6] = pprops.count();
data[7] = p_offset;
}
// Add the signals to the meta-object.
for (int g = 0; g < qo->nr_signals; ++g)
{
const QByteArray &norm = psigs.at(g);
// Add the (non-existent) argument names.
data[g_offset + (g * 5) + 1] = add_arg_names(qo, norm, empty);
// Add the full signature.
data[g_offset + (g * 5) + 0] = qo->str_data.size();
qo->str_data.append(norm.constData() + 1);
qo->str_data.append('\0');
// Add the type, tag and flags.
data[g_offset + (g * 5) + 2] = empty;
data[g_offset + (g * 5) + 3] = empty;
data[g_offset + (g * 5) + 4] = 0x05;
}
// Add the slots to the meta-object.
for (int s = 0; s < qo->pslots.count(); ++s)
{
const qpycore_slot &slot = qo->pslots.at(s);
const QByteArray &sig = slot.signature->signature;
// Add the (non-existent) argument names.
data[s_offset + (s * 5) + 1] = add_arg_names(qo, sig, empty);
// Add the full signature.
data[s_offset + (s * 5) + 0] = qo->str_data.size();
qo->str_data.append(sig);
qo->str_data.append('\0');
// Add any type.
if (slot.signature->result)
{
data[s_offset + (s * 5) + 2] = qo->str_data.size();
qo->str_data.append(slot.signature->result->name());
qo->str_data.append('\0');
}
else
{
data[s_offset + (s * 5) + 2] = empty;
}
// Add the tag and flags.
data[s_offset + (s * 5) + 3] = empty;
data[s_offset + (s * 5) + 4] = 0x0a;
}
// Add the properties to the meta-object.
QMapIterator<uint, prop_data> it(pprops);
for (int p = 0; it.hasNext(); ++p)
{
it.next();
const prop_data &pprop = it.value();
const char *prop_name = SIPBytes_AS_STRING(pprop.first);
qpycore_pyqtProperty *pp = (qpycore_pyqtProperty *)pprop.second;
// Add the property name.
data[p_offset + (p * 3) + 0] = qo->str_data.size();
qo->str_data.append(prop_name);
qo->str_data.append('\0');
// Add the name of the property type.
data[p_offset + (p * 3) + 1] = qo->str_data.size();
qo->str_data.append(pp->pyqtprop_parsed_type->name());
qo->str_data.append('\0');
// Add the property flags.
uint flags = pp->pyqtprop_flags;
// Enum or flag.
if (pp->pyqtprop_parsed_type->isEnum() || pp->pyqtprop_parsed_type->isFlag())
flags |= 0x00000008;
if (pp->prop_get && PyCallable_Check(pp->prop_get))
// Readable.
flags |= 0x00000001;
if (pp->prop_set && PyCallable_Check(pp->prop_set))
{
// Writable.
flags |= 0x00000002;
// See if the name of the setter follows the Designer convention.
// If so tell the UI compilers not to use setProperty().
PyObject *setter_name_obj = PyObject_GetAttr(pp->prop_set,
qpycore_name_attr_name);
if (setter_name_obj)
{
PyObject *ascii_obj = setter_name_obj;
const char *ascii = sipString_AsASCIIString(&ascii_obj);
Py_DECREF(setter_name_obj);
if (ascii)
{
if (qstrlen(ascii) > 3 && ascii[0] == 's' &&
ascii[1] == 'e' && ascii[2] == 't' &&
ascii[3] == toupper(prop_name[0]) &&
qstrcmp(&ascii[4], &prop_name[1]) == 0)
flags |= 0x00000100;
}
Py_DECREF(ascii_obj);
}
PyErr_Clear();
}
if (pp->pyqtprop_reset && PyCallable_Check(pp->pyqtprop_reset))
// Resetable.
flags |= 0x00000004;
// There are only 8 bits available for the type so use the special
// value if more are required.
uint metatype = pp->pyqtprop_parsed_type->metatype();
if (metatype > 0xff)
metatype = 0xff;
flags |= metatype << 24;
data[p_offset + (p * 3) + 2] = flags;
// Save the property data for qt_metacall(). (We already have a
// reference.)
qo->pprops.append(pp);
// We've finished with the property name.
Py_DECREF(pprop.first);
}
// Initialise the rest of the meta-object.
qo->mo.d.stringdata = qo->str_data.constData();
qo->mo.d.data = data;
// Save the meta-object.
pyqt_wt->metaobject = qo;
return 0;
}
static int convertTo_QList_0600QPair_0100QByteArray_0100QByteArray(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
QList<QPair<QByteArray,QByteArray> > **sipCppPtr = reinterpret_cast<QList<QPair<QByteArray,QByteArray> > **>(sipCppPtrV);
#line 286 "sip/QtCore/qpycore_qlist.sip"
PyObject *iter = PyObject_GetIter(sipPy);
if (!sipIsErr)
{
Py_XDECREF(iter);
return (iter
#if PY_MAJOR_VERSION < 3
&& !PyString_Check(sipPy)
#endif
&& !PyUnicode_Check(sipPy));
}
if (!iter)
{
*sipIsErr = 1;
return 0;
}
QList<QPair<QByteArray, QByteArray> > *ql = new QList<QPair<QByteArray, QByteArray> >;
for (SIP_SSIZE_T i = 0; ; ++i)
{
PyErr_Clear();
PyObject *seq = PyIter_Next(iter);
if (!seq)
{
if (PyErr_Occurred())
{
delete ql;
Py_DECREF(iter);
*sipIsErr = 1;
return 0;
}
break;
}
SIP_SSIZE_T sub_len;
if (PySequence_Check(seq)
#if PY_MAJOR_VERSION < 3
&& !PyString_Check(seq)
#endif
&& !PyUnicode_Check(seq))
sub_len = PySequence_Size(seq);
else
sub_len = -1;
if (sub_len != 2)
{
if (sub_len < 0)
PyErr_Format(PyExc_TypeError,
"index " SIP_SSIZE_T_FORMAT " has type '%s' but a 2 element non-string sequence is expected",
i, Py_TYPE(seq)->tp_name);
else
PyErr_Format(PyExc_TypeError,
"index " SIP_SSIZE_T_FORMAT " is a sequence of " SIP_SSIZE_T_FORMAT " sub-elements but 2 sub-elements are expected",
i, sub_len);
Py_DECREF(seq);
delete ql;
Py_DECREF(iter);
*sipIsErr = 1;
return 0;
}
PyObject *itm1 = PySequence_ITEM(seq, 0);
if (!itm1)
{
Py_DECREF(seq);
delete ql;
Py_DECREF(iter);
*sipIsErr = 1;
return 0;
}
int state1;
QByteArray *s1 = reinterpret_cast<QByteArray *>(
sipForceConvertToType(itm1, sipType_QByteArray, sipTransferObj,
SIP_NOT_NONE, &state1, sipIsErr));
if (*sipIsErr)
{
PyErr_Format(PyExc_TypeError,
"the first sub-element of index " SIP_SSIZE_T_FORMAT " has type '%s' but 'QByteArray' is expected",
i, Py_TYPE(itm1)->tp_name);
Py_DECREF(itm1);
Py_DECREF(seq);
delete ql;
Py_DECREF(iter);
return 0;
}
PyObject *itm2 = PySequence_ITEM(seq, 1);
if (!itm2)
{
sipReleaseType(s1, sipType_QByteArray, state1);
Py_DECREF(itm1);
Py_DECREF(seq);
delete ql;
Py_DECREF(iter);
*sipIsErr = 1;
return 0;
}
int state2;
QByteArray *s2 = reinterpret_cast<QByteArray *>(
sipForceConvertToType(itm2, sipType_QByteArray, sipTransferObj,
SIP_NOT_NONE, &state2, sipIsErr));
if (*sipIsErr)
{
PyErr_Format(PyExc_TypeError,
"the second sub-element of index " SIP_SSIZE_T_FORMAT " has type '%s' but 'QByteArray' is expected",
i, Py_TYPE(itm2)->tp_name);
Py_DECREF(itm2);
sipReleaseType(s1, sipType_QByteArray, state1);
Py_DECREF(itm1);
Py_DECREF(seq);
delete ql;
Py_DECREF(iter);
return 0;
}
ql->append(QPair<QByteArray, QByteArray>(*s1, *s2));
sipReleaseType(s2, sipType_QByteArray, state2);
Py_DECREF(itm2);
sipReleaseType(s1, sipType_QByteArray, state1);
Py_DECREF(itm1);
Py_DECREF(seq);
}
Py_DECREF(iter);
*sipCppPtr = ql;
return sipGetState(sipTransferObj);
#line 224 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\QtNetwork/sipQtNetworkQList0600QPair0100QByteArray0100QByteArray.cpp"
}
static PyObject*
_gfx_filledpolygoncolor (PyObject *self, PyObject* args)
{
PyObject *surface, *color, *points, *item;
Sint16 *vx, *vy;
int tmp1, tmp2;
Py_ssize_t count, i;
int ret;
pguint32 c;
ASSERT_VIDEO_INIT (NULL);
if (!PyArg_ParseTuple (args, "OOO:filled_polygon", &surface, &points,
&color))
return NULL;
if (!PySDLSurface_Check (surface))
{
PyErr_SetString (PyExc_TypeError, "surface must be a Surface");
return NULL;
}
if (!PySequence_Check (points))
{
PyErr_SetString (PyExc_TypeError, "points must be a sequence");
return NULL;
}
count = PySequence_Size (points);
if (count < 3)
{
PyErr_SetString (PyExc_ValueError,
"points must contain more than 2 points");
return NULL;
}
if (!ColorFromObj (color, &c))
return NULL;
vx = PyMem_New (Sint16, (size_t) count);
vy = PyMem_New (Sint16, (size_t) count);
if (!vx || !vy)
{
if (vx)
PyMem_Free (vx);
if (vy)
PyMem_Free (vy);
return NULL;
}
for (i = 0; i < count; i++)
{
item = PySequence_ITEM (points, i);
if (!PointFromObj (item, &tmp1, &tmp2))
{
PyMem_Free (vx);
PyMem_Free (vy);
Py_XDECREF (item);
return NULL;
}
Py_DECREF (item);
vx[i] = (Sint16)tmp1;
vy[i] = (Sint16)tmp2;
}
Py_BEGIN_ALLOW_THREADS;
ret = filledPolygonColor (((PySDLSurface*)surface)->surface, vx, vy,
(int)count, (Uint32)c);
Py_END_ALLOW_THREADS;
PyMem_Free (vx);
PyMem_Free (vy);
if (ret == -1)
{
PyErr_SetString (PyExc_PyGameError, SDL_GetError ());
return NULL;
}
Py_RETURN_NONE;
}
static PyObject*
_gfx_texturedpolygon (PyObject *self, PyObject* args)
{
PyObject *surface, *texture, *points, *item, *pt;
Sint16 *vx, *vy;
int tmp1, tmp2, tdx, tdy;
Py_ssize_t count, i;
int ret;
ASSERT_VIDEO_INIT (NULL);
if (!PyArg_ParseTuple (args, "OOOO:textured_polygon", &surface, &points,
&texture, &pt))
{
PyErr_Clear ();
if (!PyArg_ParseTuple (args, "OOOii:textured_polygon", &surface,
&points, &texture, &tdx, &tdy))
return NULL;
}
else
{
if (!PointFromObj (pt, &tdx, &tdy))
return NULL;
}
if (!PySDLSurface_Check (surface))
{
PyErr_SetString (PyExc_TypeError, "surface must be a Surface");
return NULL;
}
if (!PySDLSurface_Check (texture))
{
PyErr_SetString (PyExc_TypeError, "texture must be a Surface");
return NULL;
}
if (!PySequence_Check (points))
{
PyErr_SetString (PyExc_TypeError, "points must be a sequence");
return NULL;
}
count = PySequence_Size (points);
if (count < 3)
{
PyErr_SetString (PyExc_ValueError,
"points must contain more than 2 points");
return NULL;
}
vx = PyMem_New (Sint16, (size_t) count);
vy = PyMem_New (Sint16, (size_t) count);
if (!vx || !vy)
{
if (vx)
PyMem_Free (vx);
if (vy)
PyMem_Free (vy);
return NULL;
}
for (i = 0; i < count; i++)
{
item = PySequence_ITEM (points, i);
if (!PointFromObj (item, &tmp1, &tmp2))
{
PyMem_Free (vx);
PyMem_Free (vy);
Py_XDECREF (item);
return NULL;
}
Py_DECREF (item);
vx[i] = (Sint16)tmp1;
vy[i] = (Sint16)tmp2;
}
Py_BEGIN_ALLOW_THREADS;
ret = texturedPolygon (((PySDLSurface*)surface)->surface, vx, vy,
(int)count, ((PySDLSurface*)texture)->surface, (Sint16)tdx,
(Sint16)tdy);
Py_END_ALLOW_THREADS;
PyMem_Free (vx);
PyMem_Free (vy);
if (ret == -1)
{
PyErr_SetString (PyExc_PyGameError, SDL_GetError ());
return NULL;
}
Py_RETURN_NONE;
}
