diff --git a/python-libburn/pyburn.cpp b/python-libburn/pyburn.cpp new file mode 100644 index 0000000..b4460df --- /dev/null +++ b/python-libburn/pyburn.cpp @@ -0,0 +1,3190 @@ +/* This file was generated by PyBindGen 0.10.0 */ +#define PY_SSIZE_T_CLEAN +#include +#include + + +#if PY_VERSION_HEX < 0x020400F0 + +#define PyEval_ThreadsInitialized() 1 + +#define Py_CLEAR(op) \ + do { \ + if (op) { \ + PyObject *tmp = (PyObject *)(op); \ + (op) = NULL; \ + Py_DECREF(tmp); \ + } \ + } while (0) + + +#define Py_VISIT(op) \ + do { \ + if (op) { \ + int vret = visit((PyObject *)(op), arg); \ + if (vret) \ + return vret; \ + } \ + } while (0) + +#endif + + + +#if PY_VERSION_HEX < 0x020500F0 + +typedef int Py_ssize_t; +# define PY_SSIZE_T_MAX INT_MAX +# define PY_SSIZE_T_MIN INT_MIN +typedef inquiry lenfunc; +typedef intargfunc ssizeargfunc; +typedef intobjargproc ssizeobjargproc; + +#endif + + +#if __GNUC__ > 2 +# define PYBINDGEN_UNUSED(param) param __attribute__((__unused__)) +#elif __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ > 4) +# define PYBINDGEN_UNUSED(param) __attribute__((__unused__)) param +#else +# define PYBINDGEN_UNUSED(param) +#endif /* !__GNUC__ */ + +#include "libburn.h" +/* --- forward declarations --- */ + + +typedef struct { + PyObject_HEAD + burn::burn_drive_info *obj; +} PyBurnBurn_drive_info; + + +extern PyTypeObject PyBurnBurn_drive_info_Type; + + +typedef struct { + PyObject_HEAD + burn::burn_multi_caps *obj; +} PyBurnBurn_multi_caps; + + +extern PyTypeObject PyBurnBurn_multi_caps_Type; + + +typedef struct { + PyObject_HEAD + burn::burn_progress *obj; +} PyBurnBurn_progress; + + +extern PyTypeObject PyBurnBurn_progress_Type; + + +typedef struct { + PyObject_HEAD + burn::burn_source *obj; +} PyBurnBurn_source; + + +extern PyTypeObject PyBurnBurn_source_Type; + + +typedef struct { + PyObject_HEAD + burn::burn_speed_descriptor *obj; +} PyBurnBurn_speed_descriptor; + + +extern PyTypeObject PyBurnBurn_speed_descriptor_Type; + + +typedef struct { + PyObject_HEAD + burn::burn_toc_entry *obj; +} PyBurnBurn_toc_entry; + + +extern PyTypeObject PyBurnBurn_toc_entry_Type; + +/* --- module functions --- */ + + +PyObject * +_wrap_burn_burnburn_drive_convert_fs_adr(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs) +{ + PyObject *py_retval; + int retval; + char *path2; + char *adr2; + const char *keywords[] = {"path", "adr", NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "ss", (char **) keywords, &path2, &adr2)) { + return NULL; + } + retval = burn::burn_drive_convert_fs_adr(path2, adr2); + py_retval = Py_BuildValue((char *) "i", retval); + return py_retval; +} +PyObject * _wrap_burn_burnburn_drive_convert_fs_adr(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs); + + +PyObject * +_wrap_burn_burnburn_msgs_set_severities(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs) +{ + PyObject *py_retval; + int retval; + char *queue_severity2; + char *print_severity2; + char *print_id2; + const char *keywords[] = {"queue_severity", "print_severity", "print_id", NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "sss", (char **) keywords, &queue_severity2, &print_severity2, &print_id2)) { + return NULL; + } + retval = burn::burn_msgs_set_severities(queue_severity2, print_severity2, print_id2); + py_retval = Py_BuildValue((char *) "i", retval); + return py_retval; +} +PyObject * _wrap_burn_burnburn_msgs_set_severities(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs); + + +PyObject * +_wrap_burn_burnburn_finish() +{ + PyObject *py_retval; + + burn::burn_finish(); + Py_INCREF(Py_None); + py_retval = Py_None; + return py_retval; +} +PyObject * _wrap_burn_burnburn_finish(); + + +PyObject * +_wrap_burn_burnburn_drive_clear_whitelist() +{ + PyObject *py_retval; + + burn::burn_drive_clear_whitelist(); + Py_INCREF(Py_None); + py_retval = Py_None; + return py_retval; +} +PyObject * _wrap_burn_burnburn_drive_clear_whitelist(); + + +PyObject * +_wrap_burn_burnburn_drive_convert_scsi_adr(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs) +{ + PyObject *py_retval; + int retval; + int bus_no2; + int host_no2; + int channel_no2; + int target_no2; + int lun_no2; + char *adr2; + const char *keywords[] = {"bus_no", "host_no", "channel_no", "target_no", "lun_no", "adr", NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "iiiiis", (char **) keywords, &bus_no2, &host_no2, &channel_no2, &target_no2, &lun_no2, &adr2)) { + return NULL; + } + retval = burn::burn_drive_convert_scsi_adr(bus_no2, host_no2, channel_no2, target_no2, lun_no2, adr2); + py_retval = Py_BuildValue((char *) "i", retval); + return py_retval; +} +PyObject * _wrap_burn_burnburn_drive_convert_scsi_adr(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs); + + +PyObject * +_wrap_burn_burnburn_msf_to_sectors(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs) +{ + PyObject *py_retval; + int retval; + int m2; + int s2; + int f2; + const char *keywords[] = {"m", "s", "f", NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "iii", (char **) keywords, &m2, &s2, &f2)) { + return NULL; + } + retval = burn::burn_msf_to_sectors(m2, s2, f2); + py_retval = Py_BuildValue((char *) "i", retval); + return py_retval; +} +PyObject * _wrap_burn_burnburn_msf_to_sectors(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs); + + +PyObject * +_wrap_burn_burnburn_drive_is_enumerable_adr(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs) +{ + PyObject *py_retval; + int retval; + char *adr2; + const char *keywords[] = {"adr", NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "s", (char **) keywords, &adr2)) { + return NULL; + } + retval = burn::burn_drive_is_enumerable_adr(adr2); + py_retval = Py_BuildValue((char *) "i", retval); + return py_retval; +} +PyObject * _wrap_burn_burnburn_drive_is_enumerable_adr(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs); + + +PyObject * +_wrap_burn_burnburn_allow_untested_profiles(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs) +{ + PyObject *py_retval; + int yes2; + const char *keywords[] = {"yes", NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "i", (char **) keywords, &yes2)) { + return NULL; + } + burn::burn_allow_untested_profiles(yes2); + Py_INCREF(Py_None); + py_retval = Py_None; + return py_retval; +} +PyObject * _wrap_burn_burnburn_allow_untested_profiles(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs); + + +PyObject * +_wrap_burn_burnburn_preset_device_open(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs) +{ + PyObject *py_retval; + int exclusive2; + int blocking2; + int abort_on_busy2; + const char *keywords[] = {"exclusive", "blocking", "abort_on_busy", NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "iii", (char **) keywords, &exclusive2, &blocking2, &abort_on_busy2)) { + return NULL; + } + burn::burn_preset_device_open(exclusive2, blocking2, abort_on_busy2); + Py_INCREF(Py_None); + py_retval = Py_None; + return py_retval; +} +PyObject * _wrap_burn_burnburn_preset_device_open(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs); + + +PyObject * +_wrap_burn_burnburn_msf_to_lba(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs) +{ + PyObject *py_retval; + int retval; + int m2; + int s2; + int f2; + const char *keywords[] = {"m", "s", "f", NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "iii", (char **) keywords, &m2, &s2, &f2)) { + return NULL; + } + retval = burn::burn_msf_to_lba(m2, s2, f2); + py_retval = Py_BuildValue((char *) "i", retval); + return py_retval; +} +PyObject * _wrap_burn_burnburn_msf_to_lba(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs); + + +PyObject * +_wrap_burn_burnburn_initialize() +{ + PyObject *py_retval; + int retval; + + retval = burn::burn_initialize(); + py_retval = Py_BuildValue((char *) "i", retval); + return py_retval; +} +PyObject * _wrap_burn_burnburn_initialize(); + + +PyObject * +_wrap_burn_burnburn_drive_add_whitelist(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs) +{ + PyObject *py_retval; + int retval; + char *device_address2; + const char *keywords[] = {"device_address", NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "s", (char **) keywords, &device_address2)) { + return NULL; + } + retval = burn::burn_drive_add_whitelist(device_address2); + py_retval = Py_BuildValue((char *) "i", retval); + return py_retval; +} +PyObject * _wrap_burn_burnburn_drive_add_whitelist(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs); + + +PyObject * +_wrap_burn_burnburn_set_verbosity(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs) +{ + PyObject *py_retval; + int level2; + const char *keywords[] = {"level", NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "i", (char **) keywords, &level2)) { + return NULL; + } + burn::burn_set_verbosity(level2); + Py_INCREF(Py_None); + py_retval = Py_None; + return py_retval; +} +PyObject * _wrap_burn_burnburn_set_verbosity(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs); + +static PyMethodDef burn_burn_functions[] = { + {(char *) "drive_convert_fs_adr", (PyCFunction) _wrap_burn_burnburn_drive_convert_fs_adr, METH_KEYWORDS|METH_VARARGS, NULL }, + {(char *) "msgs_set_severities", (PyCFunction) _wrap_burn_burnburn_msgs_set_severities, METH_KEYWORDS|METH_VARARGS, NULL }, + {(char *) "finish", (PyCFunction) _wrap_burn_burnburn_finish, METH_NOARGS, NULL }, + {(char *) "drive_clear_whitelist", (PyCFunction) _wrap_burn_burnburn_drive_clear_whitelist, METH_NOARGS, NULL }, + {(char *) "drive_convert_scsi_adr", (PyCFunction) _wrap_burn_burnburn_drive_convert_scsi_adr, METH_KEYWORDS|METH_VARARGS, NULL }, + {(char *) "msf_to_sectors", (PyCFunction) _wrap_burn_burnburn_msf_to_sectors, METH_KEYWORDS|METH_VARARGS, NULL }, + {(char *) "drive_is_enumerable_adr", (PyCFunction) _wrap_burn_burnburn_drive_is_enumerable_adr, METH_KEYWORDS|METH_VARARGS, NULL }, + {(char *) "allow_untested_profiles", (PyCFunction) _wrap_burn_burnburn_allow_untested_profiles, METH_KEYWORDS|METH_VARARGS, NULL }, + {(char *) "preset_device_open", (PyCFunction) _wrap_burn_burnburn_preset_device_open, METH_KEYWORDS|METH_VARARGS, NULL }, + {(char *) "msf_to_lba", (PyCFunction) _wrap_burn_burnburn_msf_to_lba, METH_KEYWORDS|METH_VARARGS, NULL }, + {(char *) "initialize", (PyCFunction) _wrap_burn_burnburn_initialize, METH_NOARGS, NULL }, + {(char *) "drive_add_whitelist", (PyCFunction) _wrap_burn_burnburn_drive_add_whitelist, METH_KEYWORDS|METH_VARARGS, NULL }, + {(char *) "set_verbosity", (PyCFunction) _wrap_burn_burnburn_set_verbosity, METH_KEYWORDS|METH_VARARGS, NULL }, + {NULL, NULL, 0, NULL} +}; +/* --- classes --- */ + + +static PyObject* _wrap_PyBurnBurn_drive_info__get_read_dvdram(PyBurnBurn_drive_info *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "N", PyLong_FromUnsignedLong(self->obj->read_dvdram)); + return py_retval; +} +static int _wrap_PyBurnBurn_drive_info__set_read_dvdram(PyBurnBurn_drive_info *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "I", &self->obj->read_dvdram)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_drive_info__get_read_dvdr(PyBurnBurn_drive_info *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "N", PyLong_FromUnsignedLong(self->obj->read_dvdr)); + return py_retval; +} +static int _wrap_PyBurnBurn_drive_info__set_read_dvdr(PyBurnBurn_drive_info *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "I", &self->obj->read_dvdr)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_drive_info__get_read_dvdrom(PyBurnBurn_drive_info *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "N", PyLong_FromUnsignedLong(self->obj->read_dvdrom)); + return py_retval; +} +static int _wrap_PyBurnBurn_drive_info__set_read_dvdrom(PyBurnBurn_drive_info *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "I", &self->obj->read_dvdrom)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_drive_info__get_read_cdr(PyBurnBurn_drive_info *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "N", PyLong_FromUnsignedLong(self->obj->read_cdr)); + return py_retval; +} +static int _wrap_PyBurnBurn_drive_info__set_read_cdr(PyBurnBurn_drive_info *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "I", &self->obj->read_cdr)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_drive_info__get_read_cdrw(PyBurnBurn_drive_info *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "N", PyLong_FromUnsignedLong(self->obj->read_cdrw)); + return py_retval; +} +static int _wrap_PyBurnBurn_drive_info__set_read_cdrw(PyBurnBurn_drive_info *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "I", &self->obj->read_cdrw)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_drive_info__get_write_dvdram(PyBurnBurn_drive_info *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "N", PyLong_FromUnsignedLong(self->obj->write_dvdram)); + return py_retval; +} +static int _wrap_PyBurnBurn_drive_info__set_write_dvdram(PyBurnBurn_drive_info *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "I", &self->obj->write_dvdram)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_drive_info__get_write_dvdr(PyBurnBurn_drive_info *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "N", PyLong_FromUnsignedLong(self->obj->write_dvdr)); + return py_retval; +} +static int _wrap_PyBurnBurn_drive_info__set_write_dvdr(PyBurnBurn_drive_info *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "I", &self->obj->write_dvdr)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_drive_info__get_write_cdr(PyBurnBurn_drive_info *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "N", PyLong_FromUnsignedLong(self->obj->write_cdr)); + return py_retval; +} +static int _wrap_PyBurnBurn_drive_info__set_write_cdr(PyBurnBurn_drive_info *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "I", &self->obj->write_cdr)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_drive_info__get_write_cdrw(PyBurnBurn_drive_info *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "N", PyLong_FromUnsignedLong(self->obj->write_cdrw)); + return py_retval; +} +static int _wrap_PyBurnBurn_drive_info__set_write_cdrw(PyBurnBurn_drive_info *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "I", &self->obj->write_cdrw)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_drive_info__get_write_simulate(PyBurnBurn_drive_info *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "N", PyLong_FromUnsignedLong(self->obj->write_simulate)); + return py_retval; +} +static int _wrap_PyBurnBurn_drive_info__set_write_simulate(PyBurnBurn_drive_info *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "I", &self->obj->write_simulate)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_drive_info__get_c2_errors(PyBurnBurn_drive_info *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "N", PyLong_FromUnsignedLong(self->obj->c2_errors)); + return py_retval; +} +static int _wrap_PyBurnBurn_drive_info__set_c2_errors(PyBurnBurn_drive_info *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "I", &self->obj->c2_errors)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_drive_info__get_buffer_size(PyBurnBurn_drive_info *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "i", self->obj->buffer_size); + return py_retval; +} +static int _wrap_PyBurnBurn_drive_info__set_buffer_size(PyBurnBurn_drive_info *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->buffer_size)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_drive_info__get_tao_block_types(PyBurnBurn_drive_info *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "i", self->obj->tao_block_types); + return py_retval; +} +static int _wrap_PyBurnBurn_drive_info__set_tao_block_types(PyBurnBurn_drive_info *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->tao_block_types)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_drive_info__get_sao_block_types(PyBurnBurn_drive_info *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "i", self->obj->sao_block_types); + return py_retval; +} +static int _wrap_PyBurnBurn_drive_info__set_sao_block_types(PyBurnBurn_drive_info *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->sao_block_types)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_drive_info__get_raw_block_types(PyBurnBurn_drive_info *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "i", self->obj->raw_block_types); + return py_retval; +} +static int _wrap_PyBurnBurn_drive_info__set_raw_block_types(PyBurnBurn_drive_info *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->raw_block_types)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_drive_info__get_packet_block_types(PyBurnBurn_drive_info *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "i", self->obj->packet_block_types); + return py_retval; +} +static int _wrap_PyBurnBurn_drive_info__set_packet_block_types(PyBurnBurn_drive_info *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->packet_block_types)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyGetSetDef PyBurnBurn_drive_info__getsets[] = { + { + (char*) "read_dvdrom", /* attribute name */ + (getter) _wrap_PyBurnBurn_drive_info__get_read_dvdrom, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_drive_info__set_read_dvdrom, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "read_dvdram", /* attribute name */ + (getter) _wrap_PyBurnBurn_drive_info__get_read_dvdram, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_drive_info__set_read_dvdram, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "tao_block_types", /* attribute name */ + (getter) _wrap_PyBurnBurn_drive_info__get_tao_block_types, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_drive_info__set_tao_block_types, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "write_dvdr", /* attribute name */ + (getter) _wrap_PyBurnBurn_drive_info__get_write_dvdr, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_drive_info__set_write_dvdr, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "read_dvdr", /* attribute name */ + (getter) _wrap_PyBurnBurn_drive_info__get_read_dvdr, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_drive_info__set_read_dvdr, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "c2_errors", /* attribute name */ + (getter) _wrap_PyBurnBurn_drive_info__get_c2_errors, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_drive_info__set_c2_errors, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "read_cdr", /* attribute name */ + (getter) _wrap_PyBurnBurn_drive_info__get_read_cdr, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_drive_info__set_read_cdr, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "write_cdrw", /* attribute name */ + (getter) _wrap_PyBurnBurn_drive_info__get_write_cdrw, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_drive_info__set_write_cdrw, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "write_dvdram", /* attribute name */ + (getter) _wrap_PyBurnBurn_drive_info__get_write_dvdram, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_drive_info__set_write_dvdram, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "write_simulate", /* attribute name */ + (getter) _wrap_PyBurnBurn_drive_info__get_write_simulate, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_drive_info__set_write_simulate, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "read_cdrw", /* attribute name */ + (getter) _wrap_PyBurnBurn_drive_info__get_read_cdrw, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_drive_info__set_read_cdrw, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "packet_block_types", /* attribute name */ + (getter) _wrap_PyBurnBurn_drive_info__get_packet_block_types, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_drive_info__set_packet_block_types, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "sao_block_types", /* attribute name */ + (getter) _wrap_PyBurnBurn_drive_info__get_sao_block_types, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_drive_info__set_sao_block_types, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "buffer_size", /* attribute name */ + (getter) _wrap_PyBurnBurn_drive_info__get_buffer_size, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_drive_info__set_buffer_size, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "write_cdr", /* attribute name */ + (getter) _wrap_PyBurnBurn_drive_info__get_write_cdr, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_drive_info__set_write_cdr, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "raw_block_types", /* attribute name */ + (getter) _wrap_PyBurnBurn_drive_info__get_raw_block_types, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_drive_info__set_raw_block_types, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { NULL, NULL, NULL, NULL, NULL } +}; + + +static int +_wrap_PyBurnBurn_drive_info__tp_init__0(PyBurnBurn_drive_info *self, PyObject *args, PyObject *kwargs, PyObject **return_exception) +{ + PyBurnBurn_drive_info *arg02; + const char *keywords[] = {"arg0", NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "O!", (char **) keywords, &PyBurnBurn_drive_info_Type, &arg02)) { + { + PyObject *exc_type, *traceback; + PyErr_Fetch(&exc_type, return_exception, &traceback); + Py_XDECREF(exc_type); + Py_XDECREF(traceback); + } + return -1; + } + self->obj = new burn::burn_drive_info(*((PyBurnBurn_drive_info *) arg02)->obj); + return 0; +} + +static int +_wrap_PyBurnBurn_drive_info__tp_init__1(PyBurnBurn_drive_info *self, PyObject *args, PyObject *kwargs, PyObject **return_exception) +{ + const char *keywords[] = {NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "", (char **) keywords)) { + { + PyObject *exc_type, *traceback; + PyErr_Fetch(&exc_type, return_exception, &traceback); + Py_XDECREF(exc_type); + Py_XDECREF(traceback); + } + return -1; + } + self->obj = new burn::burn_drive_info(); + return 0; +} + +int _wrap_PyBurnBurn_drive_info__tp_init(PyBurnBurn_drive_info *self, PyObject *args, PyObject *kwargs) +{ + int retval; + PyObject *error_list; + PyObject *exceptions[2] = {0,}; + retval = _wrap_PyBurnBurn_drive_info__tp_init__0(self, args, kwargs, &exceptions[0]); + if (!exceptions[0]) { + return retval; + } + retval = _wrap_PyBurnBurn_drive_info__tp_init__1(self, args, kwargs, &exceptions[1]); + if (!exceptions[1]) { + Py_DECREF(exceptions[0]); + return retval; + } + error_list = PyList_New(2); + PyList_SET_ITEM(error_list, 0, PyObject_Str(exceptions[0])); + Py_DECREF(exceptions[0]); + PyList_SET_ITEM(error_list, 1, PyObject_Str(exceptions[1])); + Py_DECREF(exceptions[1]); + PyErr_SetObject(PyExc_TypeError, error_list); + Py_DECREF(error_list); + return -1; +} + + +static PyObject* +_wrap_PyBurnBurn_drive_info__copy__(PyBurnBurn_drive_info *self) +{ + + PyBurnBurn_drive_info *py_copy; + py_copy = PyObject_New(PyBurnBurn_drive_info, &PyBurnBurn_drive_info_Type); + py_copy->obj = new burn::burn_drive_info(*self->obj); + return (PyObject*) py_copy; +} + +static PyMethodDef PyBurnBurn_drive_info_methods[] = { + {(char *) "__copy__", (PyCFunction) _wrap_PyBurnBurn_drive_info__copy__, METH_NOARGS, NULL}, + {NULL, NULL, 0, NULL} +}; + +static void +_wrap_PyBurnBurn_drive_info__tp_dealloc(PyBurnBurn_drive_info *self) +{ + burn::burn_drive_info *tmp = self->obj; + self->obj = NULL; + delete tmp; + self->ob_type->tp_free((PyObject*)self); +} + +static PyObject* +_wrap_PyBurnBurn_drive_info__tp_richcompare (PyBurnBurn_drive_info *self, PyBurnBurn_drive_info *other, int opid) +{ + + if (!PyObject_IsInstance((PyObject*) other, (PyObject*) &PyBurnBurn_drive_info_Type)) { + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + } + switch (opid) + { + case Py_LT: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + case Py_LE: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + case Py_EQ: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + case Py_NE: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + case Py_GE: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + case Py_GT: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + } /* closes switch (opid) */ + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; +} + +PyTypeObject PyBurnBurn_drive_info_Type = { + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ + (char *) "burn.burn.Burn_drive_info", /* tp_name */ + sizeof(PyBurnBurn_drive_info), /* tp_basicsize */ + 0, /* tp_itemsize */ + /* methods */ + (destructor)_wrap_PyBurnBurn_drive_info__tp_dealloc, /* tp_dealloc */ + (printfunc)0, /* tp_print */ + (getattrfunc)NULL, /* tp_getattr */ + (setattrfunc)NULL, /* tp_setattr */ + (cmpfunc)NULL, /* tp_compare */ + (reprfunc)NULL, /* tp_repr */ + (PyNumberMethods*)NULL, /* tp_as_number */ + (PySequenceMethods*)NULL, /* tp_as_sequence */ + (PyMappingMethods*)NULL, /* tp_as_mapping */ + (hashfunc)NULL, /* tp_hash */ + (ternaryfunc)NULL, /* tp_call */ + (reprfunc)NULL, /* tp_str */ + (getattrofunc)NULL, /* tp_getattro */ + (setattrofunc)NULL, /* tp_setattro */ + (PyBufferProcs*)NULL, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /* tp_flags */ + NULL, /* Documentation string */ + (traverseproc)NULL, /* tp_traverse */ + (inquiry)NULL, /* tp_clear */ + (richcmpfunc)_wrap_PyBurnBurn_drive_info__tp_richcompare, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + (getiterfunc)NULL, /* tp_iter */ + (iternextfunc)NULL, /* tp_iternext */ + (struct PyMethodDef*)PyBurnBurn_drive_info_methods, /* tp_methods */ + (struct PyMemberDef*)0, /* tp_members */ + PyBurnBurn_drive_info__getsets, /* tp_getset */ + NULL, /* tp_base */ + NULL, /* tp_dict */ + (descrgetfunc)NULL, /* tp_descr_get */ + (descrsetfunc)NULL, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)_wrap_PyBurnBurn_drive_info__tp_init, /* tp_init */ + (allocfunc)PyType_GenericAlloc, /* tp_alloc */ + (newfunc)PyType_GenericNew, /* tp_new */ + (freefunc)0, /* tp_free */ + (inquiry)NULL, /* tp_is_gc */ + NULL, /* tp_bases */ + NULL, /* tp_mro */ + NULL, /* tp_cache */ + NULL, /* tp_subclasses */ + NULL, /* tp_weaklist */ + (destructor) NULL /* tp_del */ +}; + + + +static PyObject* _wrap_PyBurnBurn_multi_caps__get_multi_session(PyBurnBurn_multi_caps *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "i", self->obj->multi_session); + return py_retval; +} +static int _wrap_PyBurnBurn_multi_caps__set_multi_session(PyBurnBurn_multi_caps *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->multi_session)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_multi_caps__get_multi_track(PyBurnBurn_multi_caps *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "i", self->obj->multi_track); + return py_retval; +} +static int _wrap_PyBurnBurn_multi_caps__set_multi_track(PyBurnBurn_multi_caps *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->multi_track)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_multi_caps__get_start_adr(PyBurnBurn_multi_caps *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "i", self->obj->start_adr); + return py_retval; +} +static int _wrap_PyBurnBurn_multi_caps__set_start_adr(PyBurnBurn_multi_caps *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->start_adr)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_multi_caps__get_might_do_tao(PyBurnBurn_multi_caps *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "i", self->obj->might_do_tao); + return py_retval; +} +static int _wrap_PyBurnBurn_multi_caps__set_might_do_tao(PyBurnBurn_multi_caps *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->might_do_tao)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_multi_caps__get_might_do_sao(PyBurnBurn_multi_caps *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "i", self->obj->might_do_sao); + return py_retval; +} +static int _wrap_PyBurnBurn_multi_caps__set_might_do_sao(PyBurnBurn_multi_caps *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->might_do_sao)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_multi_caps__get_might_do_raw(PyBurnBurn_multi_caps *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "i", self->obj->might_do_raw); + return py_retval; +} +static int _wrap_PyBurnBurn_multi_caps__set_might_do_raw(PyBurnBurn_multi_caps *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->might_do_raw)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_multi_caps__get_advised_write_mode(PyBurnBurn_multi_caps *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "i", self->obj->advised_write_mode); + return py_retval; +} +static int _wrap_PyBurnBurn_multi_caps__set_advised_write_mode(PyBurnBurn_multi_caps *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->advised_write_mode)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_multi_caps__get_selected_write_mode(PyBurnBurn_multi_caps *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "i", self->obj->selected_write_mode); + return py_retval; +} +static int _wrap_PyBurnBurn_multi_caps__set_selected_write_mode(PyBurnBurn_multi_caps *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->selected_write_mode)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_multi_caps__get_current_profile(PyBurnBurn_multi_caps *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "i", self->obj->current_profile); + return py_retval; +} +static int _wrap_PyBurnBurn_multi_caps__set_current_profile(PyBurnBurn_multi_caps *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->current_profile)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_multi_caps__get_current_is_cd_profile(PyBurnBurn_multi_caps *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "i", self->obj->current_is_cd_profile); + return py_retval; +} +static int _wrap_PyBurnBurn_multi_caps__set_current_is_cd_profile(PyBurnBurn_multi_caps *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->current_is_cd_profile)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_multi_caps__get_might_simulate(PyBurnBurn_multi_caps *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "i", self->obj->might_simulate); + return py_retval; +} +static int _wrap_PyBurnBurn_multi_caps__set_might_simulate(PyBurnBurn_multi_caps *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->might_simulate)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyGetSetDef PyBurnBurn_multi_caps__getsets[] = { + { + (char*) "multi_track", /* attribute name */ + (getter) _wrap_PyBurnBurn_multi_caps__get_multi_track, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_multi_caps__set_multi_track, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "advised_write_mode", /* attribute name */ + (getter) _wrap_PyBurnBurn_multi_caps__get_advised_write_mode, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_multi_caps__set_advised_write_mode, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "current_profile", /* attribute name */ + (getter) _wrap_PyBurnBurn_multi_caps__get_current_profile, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_multi_caps__set_current_profile, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "start_adr", /* attribute name */ + (getter) _wrap_PyBurnBurn_multi_caps__get_start_adr, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_multi_caps__set_start_adr, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "might_do_sao", /* attribute name */ + (getter) _wrap_PyBurnBurn_multi_caps__get_might_do_sao, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_multi_caps__set_might_do_sao, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "might_do_raw", /* attribute name */ + (getter) _wrap_PyBurnBurn_multi_caps__get_might_do_raw, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_multi_caps__set_might_do_raw, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "might_simulate", /* attribute name */ + (getter) _wrap_PyBurnBurn_multi_caps__get_might_simulate, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_multi_caps__set_might_simulate, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "multi_session", /* attribute name */ + (getter) _wrap_PyBurnBurn_multi_caps__get_multi_session, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_multi_caps__set_multi_session, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "selected_write_mode", /* attribute name */ + (getter) _wrap_PyBurnBurn_multi_caps__get_selected_write_mode, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_multi_caps__set_selected_write_mode, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "might_do_tao", /* attribute name */ + (getter) _wrap_PyBurnBurn_multi_caps__get_might_do_tao, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_multi_caps__set_might_do_tao, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "current_is_cd_profile", /* attribute name */ + (getter) _wrap_PyBurnBurn_multi_caps__get_current_is_cd_profile, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_multi_caps__set_current_is_cd_profile, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { NULL, NULL, NULL, NULL, NULL } +}; + + +static int +_wrap_PyBurnBurn_multi_caps__tp_init__0(PyBurnBurn_multi_caps *self, PyObject *args, PyObject *kwargs, PyObject **return_exception) +{ + PyBurnBurn_multi_caps *arg02; + const char *keywords[] = {"arg0", NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "O!", (char **) keywords, &PyBurnBurn_multi_caps_Type, &arg02)) { + { + PyObject *exc_type, *traceback; + PyErr_Fetch(&exc_type, return_exception, &traceback); + Py_XDECREF(exc_type); + Py_XDECREF(traceback); + } + return -1; + } + self->obj = new burn::burn_multi_caps(*((PyBurnBurn_multi_caps *) arg02)->obj); + return 0; +} + +static int +_wrap_PyBurnBurn_multi_caps__tp_init__1(PyBurnBurn_multi_caps *self, PyObject *args, PyObject *kwargs, PyObject **return_exception) +{ + const char *keywords[] = {NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "", (char **) keywords)) { + { + PyObject *exc_type, *traceback; + PyErr_Fetch(&exc_type, return_exception, &traceback); + Py_XDECREF(exc_type); + Py_XDECREF(traceback); + } + return -1; + } + self->obj = new burn::burn_multi_caps(); + return 0; +} + +int _wrap_PyBurnBurn_multi_caps__tp_init(PyBurnBurn_multi_caps *self, PyObject *args, PyObject *kwargs) +{ + int retval; + PyObject *error_list; + PyObject *exceptions[2] = {0,}; + retval = _wrap_PyBurnBurn_multi_caps__tp_init__0(self, args, kwargs, &exceptions[0]); + if (!exceptions[0]) { + return retval; + } + retval = _wrap_PyBurnBurn_multi_caps__tp_init__1(self, args, kwargs, &exceptions[1]); + if (!exceptions[1]) { + Py_DECREF(exceptions[0]); + return retval; + } + error_list = PyList_New(2); + PyList_SET_ITEM(error_list, 0, PyObject_Str(exceptions[0])); + Py_DECREF(exceptions[0]); + PyList_SET_ITEM(error_list, 1, PyObject_Str(exceptions[1])); + Py_DECREF(exceptions[1]); + PyErr_SetObject(PyExc_TypeError, error_list); + Py_DECREF(error_list); + return -1; +} + + +static PyObject* +_wrap_PyBurnBurn_multi_caps__copy__(PyBurnBurn_multi_caps *self) +{ + + PyBurnBurn_multi_caps *py_copy; + py_copy = PyObject_New(PyBurnBurn_multi_caps, &PyBurnBurn_multi_caps_Type); + py_copy->obj = new burn::burn_multi_caps(*self->obj); + return (PyObject*) py_copy; +} + +static PyMethodDef PyBurnBurn_multi_caps_methods[] = { + {(char *) "__copy__", (PyCFunction) _wrap_PyBurnBurn_multi_caps__copy__, METH_NOARGS, NULL}, + {NULL, NULL, 0, NULL} +}; + +static void +_wrap_PyBurnBurn_multi_caps__tp_dealloc(PyBurnBurn_multi_caps *self) +{ + burn::burn_multi_caps *tmp = self->obj; + self->obj = NULL; + delete tmp; + self->ob_type->tp_free((PyObject*)self); +} + +static PyObject* +_wrap_PyBurnBurn_multi_caps__tp_richcompare (PyBurnBurn_multi_caps *self, PyBurnBurn_multi_caps *other, int opid) +{ + + if (!PyObject_IsInstance((PyObject*) other, (PyObject*) &PyBurnBurn_multi_caps_Type)) { + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + } + switch (opid) + { + case Py_LT: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + case Py_LE: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + case Py_EQ: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + case Py_NE: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + case Py_GE: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + case Py_GT: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + } /* closes switch (opid) */ + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; +} + +PyTypeObject PyBurnBurn_multi_caps_Type = { + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ + (char *) "burn.burn.Burn_multi_caps", /* tp_name */ + sizeof(PyBurnBurn_multi_caps), /* tp_basicsize */ + 0, /* tp_itemsize */ + /* methods */ + (destructor)_wrap_PyBurnBurn_multi_caps__tp_dealloc, /* tp_dealloc */ + (printfunc)0, /* tp_print */ + (getattrfunc)NULL, /* tp_getattr */ + (setattrfunc)NULL, /* tp_setattr */ + (cmpfunc)NULL, /* tp_compare */ + (reprfunc)NULL, /* tp_repr */ + (PyNumberMethods*)NULL, /* tp_as_number */ + (PySequenceMethods*)NULL, /* tp_as_sequence */ + (PyMappingMethods*)NULL, /* tp_as_mapping */ + (hashfunc)NULL, /* tp_hash */ + (ternaryfunc)NULL, /* tp_call */ + (reprfunc)NULL, /* tp_str */ + (getattrofunc)NULL, /* tp_getattro */ + (setattrofunc)NULL, /* tp_setattro */ + (PyBufferProcs*)NULL, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /* tp_flags */ + NULL, /* Documentation string */ + (traverseproc)NULL, /* tp_traverse */ + (inquiry)NULL, /* tp_clear */ + (richcmpfunc)_wrap_PyBurnBurn_multi_caps__tp_richcompare, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + (getiterfunc)NULL, /* tp_iter */ + (iternextfunc)NULL, /* tp_iternext */ + (struct PyMethodDef*)PyBurnBurn_multi_caps_methods, /* tp_methods */ + (struct PyMemberDef*)0, /* tp_members */ + PyBurnBurn_multi_caps__getsets, /* tp_getset */ + NULL, /* tp_base */ + NULL, /* tp_dict */ + (descrgetfunc)NULL, /* tp_descr_get */ + (descrsetfunc)NULL, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)_wrap_PyBurnBurn_multi_caps__tp_init, /* tp_init */ + (allocfunc)PyType_GenericAlloc, /* tp_alloc */ + (newfunc)PyType_GenericNew, /* tp_new */ + (freefunc)0, /* tp_free */ + (inquiry)NULL, /* tp_is_gc */ + NULL, /* tp_bases */ + NULL, /* tp_mro */ + NULL, /* tp_cache */ + NULL, /* tp_subclasses */ + NULL, /* tp_weaklist */ + (destructor) NULL /* tp_del */ +}; + + + +static PyObject* _wrap_PyBurnBurn_progress__get_sessions(PyBurnBurn_progress *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "i", self->obj->sessions); + return py_retval; +} +static int _wrap_PyBurnBurn_progress__set_sessions(PyBurnBurn_progress *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->sessions)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_progress__get_session(PyBurnBurn_progress *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "i", self->obj->session); + return py_retval; +} +static int _wrap_PyBurnBurn_progress__set_session(PyBurnBurn_progress *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->session)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_progress__get_tracks(PyBurnBurn_progress *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "i", self->obj->tracks); + return py_retval; +} +static int _wrap_PyBurnBurn_progress__set_tracks(PyBurnBurn_progress *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->tracks)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_progress__get_track(PyBurnBurn_progress *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "i", self->obj->track); + return py_retval; +} +static int _wrap_PyBurnBurn_progress__set_track(PyBurnBurn_progress *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->track)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_progress__get_indices(PyBurnBurn_progress *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "i", self->obj->indices); + return py_retval; +} +static int _wrap_PyBurnBurn_progress__set_indices(PyBurnBurn_progress *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->indices)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_progress__get_index(PyBurnBurn_progress *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "i", self->obj->index); + return py_retval; +} +static int _wrap_PyBurnBurn_progress__set_index(PyBurnBurn_progress *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->index)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_progress__get_start_sector(PyBurnBurn_progress *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "i", self->obj->start_sector); + return py_retval; +} +static int _wrap_PyBurnBurn_progress__set_start_sector(PyBurnBurn_progress *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->start_sector)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_progress__get_sectors(PyBurnBurn_progress *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "i", self->obj->sectors); + return py_retval; +} +static int _wrap_PyBurnBurn_progress__set_sectors(PyBurnBurn_progress *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->sectors)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_progress__get_sector(PyBurnBurn_progress *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "i", self->obj->sector); + return py_retval; +} +static int _wrap_PyBurnBurn_progress__set_sector(PyBurnBurn_progress *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->sector)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_progress__get_buffer_capacity(PyBurnBurn_progress *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "N", PyLong_FromUnsignedLong(self->obj->buffer_capacity)); + return py_retval; +} +static int _wrap_PyBurnBurn_progress__set_buffer_capacity(PyBurnBurn_progress *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "I", &self->obj->buffer_capacity)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_progress__get_buffer_available(PyBurnBurn_progress *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "N", PyLong_FromUnsignedLong(self->obj->buffer_available)); + return py_retval; +} +static int _wrap_PyBurnBurn_progress__set_buffer_available(PyBurnBurn_progress *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "I", &self->obj->buffer_available)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_progress__get_buffer_min_fill(PyBurnBurn_progress *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "N", PyLong_FromUnsignedLong(self->obj->buffer_min_fill)); + return py_retval; +} +static int _wrap_PyBurnBurn_progress__set_buffer_min_fill(PyBurnBurn_progress *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "I", &self->obj->buffer_min_fill)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyGetSetDef PyBurnBurn_progress__getsets[] = { + { + (char*) "sector", /* attribute name */ + (getter) _wrap_PyBurnBurn_progress__get_sector, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_progress__set_sector, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "index", /* attribute name */ + (getter) _wrap_PyBurnBurn_progress__get_index, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_progress__set_index, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "sectors", /* attribute name */ + (getter) _wrap_PyBurnBurn_progress__get_sectors, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_progress__set_sectors, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "sessions", /* attribute name */ + (getter) _wrap_PyBurnBurn_progress__get_sessions, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_progress__set_sessions, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "track", /* attribute name */ + (getter) _wrap_PyBurnBurn_progress__get_track, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_progress__set_track, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "buffer_available", /* attribute name */ + (getter) _wrap_PyBurnBurn_progress__get_buffer_available, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_progress__set_buffer_available, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "tracks", /* attribute name */ + (getter) _wrap_PyBurnBurn_progress__get_tracks, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_progress__set_tracks, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "session", /* attribute name */ + (getter) _wrap_PyBurnBurn_progress__get_session, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_progress__set_session, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "start_sector", /* attribute name */ + (getter) _wrap_PyBurnBurn_progress__get_start_sector, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_progress__set_start_sector, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "buffer_capacity", /* attribute name */ + (getter) _wrap_PyBurnBurn_progress__get_buffer_capacity, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_progress__set_buffer_capacity, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "indices", /* attribute name */ + (getter) _wrap_PyBurnBurn_progress__get_indices, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_progress__set_indices, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "buffer_min_fill", /* attribute name */ + (getter) _wrap_PyBurnBurn_progress__get_buffer_min_fill, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_progress__set_buffer_min_fill, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { NULL, NULL, NULL, NULL, NULL } +}; + + +static int +_wrap_PyBurnBurn_progress__tp_init__0(PyBurnBurn_progress *self, PyObject *args, PyObject *kwargs, PyObject **return_exception) +{ + PyBurnBurn_progress *arg02; + const char *keywords[] = {"arg0", NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "O!", (char **) keywords, &PyBurnBurn_progress_Type, &arg02)) { + { + PyObject *exc_type, *traceback; + PyErr_Fetch(&exc_type, return_exception, &traceback); + Py_XDECREF(exc_type); + Py_XDECREF(traceback); + } + return -1; + } + self->obj = new burn::burn_progress(*((PyBurnBurn_progress *) arg02)->obj); + return 0; +} + +static int +_wrap_PyBurnBurn_progress__tp_init__1(PyBurnBurn_progress *self, PyObject *args, PyObject *kwargs, PyObject **return_exception) +{ + const char *keywords[] = {NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "", (char **) keywords)) { + { + PyObject *exc_type, *traceback; + PyErr_Fetch(&exc_type, return_exception, &traceback); + Py_XDECREF(exc_type); + Py_XDECREF(traceback); + } + return -1; + } + self->obj = new burn::burn_progress(); + return 0; +} + +int _wrap_PyBurnBurn_progress__tp_init(PyBurnBurn_progress *self, PyObject *args, PyObject *kwargs) +{ + int retval; + PyObject *error_list; + PyObject *exceptions[2] = {0,}; + retval = _wrap_PyBurnBurn_progress__tp_init__0(self, args, kwargs, &exceptions[0]); + if (!exceptions[0]) { + return retval; + } + retval = _wrap_PyBurnBurn_progress__tp_init__1(self, args, kwargs, &exceptions[1]); + if (!exceptions[1]) { + Py_DECREF(exceptions[0]); + return retval; + } + error_list = PyList_New(2); + PyList_SET_ITEM(error_list, 0, PyObject_Str(exceptions[0])); + Py_DECREF(exceptions[0]); + PyList_SET_ITEM(error_list, 1, PyObject_Str(exceptions[1])); + Py_DECREF(exceptions[1]); + PyErr_SetObject(PyExc_TypeError, error_list); + Py_DECREF(error_list); + return -1; +} + + +static PyObject* +_wrap_PyBurnBurn_progress__copy__(PyBurnBurn_progress *self) +{ + + PyBurnBurn_progress *py_copy; + py_copy = PyObject_New(PyBurnBurn_progress, &PyBurnBurn_progress_Type); + py_copy->obj = new burn::burn_progress(*self->obj); + return (PyObject*) py_copy; +} + +static PyMethodDef PyBurnBurn_progress_methods[] = { + {(char *) "__copy__", (PyCFunction) _wrap_PyBurnBurn_progress__copy__, METH_NOARGS, NULL}, + {NULL, NULL, 0, NULL} +}; + +static void +_wrap_PyBurnBurn_progress__tp_dealloc(PyBurnBurn_progress *self) +{ + burn::burn_progress *tmp = self->obj; + self->obj = NULL; + delete tmp; + self->ob_type->tp_free((PyObject*)self); +} + +static PyObject* +_wrap_PyBurnBurn_progress__tp_richcompare (PyBurnBurn_progress *self, PyBurnBurn_progress *other, int opid) +{ + + if (!PyObject_IsInstance((PyObject*) other, (PyObject*) &PyBurnBurn_progress_Type)) { + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + } + switch (opid) + { + case Py_LT: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + case Py_LE: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + case Py_EQ: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + case Py_NE: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + case Py_GE: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + case Py_GT: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + } /* closes switch (opid) */ + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; +} + +PyTypeObject PyBurnBurn_progress_Type = { + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ + (char *) "burn.burn.Burn_progress", /* tp_name */ + sizeof(PyBurnBurn_progress), /* tp_basicsize */ + 0, /* tp_itemsize */ + /* methods */ + (destructor)_wrap_PyBurnBurn_progress__tp_dealloc, /* tp_dealloc */ + (printfunc)0, /* tp_print */ + (getattrfunc)NULL, /* tp_getattr */ + (setattrfunc)NULL, /* tp_setattr */ + (cmpfunc)NULL, /* tp_compare */ + (reprfunc)NULL, /* tp_repr */ + (PyNumberMethods*)NULL, /* tp_as_number */ + (PySequenceMethods*)NULL, /* tp_as_sequence */ + (PyMappingMethods*)NULL, /* tp_as_mapping */ + (hashfunc)NULL, /* tp_hash */ + (ternaryfunc)NULL, /* tp_call */ + (reprfunc)NULL, /* tp_str */ + (getattrofunc)NULL, /* tp_getattro */ + (setattrofunc)NULL, /* tp_setattro */ + (PyBufferProcs*)NULL, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /* tp_flags */ + NULL, /* Documentation string */ + (traverseproc)NULL, /* tp_traverse */ + (inquiry)NULL, /* tp_clear */ + (richcmpfunc)_wrap_PyBurnBurn_progress__tp_richcompare, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + (getiterfunc)NULL, /* tp_iter */ + (iternextfunc)NULL, /* tp_iternext */ + (struct PyMethodDef*)PyBurnBurn_progress_methods, /* tp_methods */ + (struct PyMemberDef*)0, /* tp_members */ + PyBurnBurn_progress__getsets, /* tp_getset */ + NULL, /* tp_base */ + NULL, /* tp_dict */ + (descrgetfunc)NULL, /* tp_descr_get */ + (descrsetfunc)NULL, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)_wrap_PyBurnBurn_progress__tp_init, /* tp_init */ + (allocfunc)PyType_GenericAlloc, /* tp_alloc */ + (newfunc)PyType_GenericNew, /* tp_new */ + (freefunc)0, /* tp_free */ + (inquiry)NULL, /* tp_is_gc */ + NULL, /* tp_bases */ + NULL, /* tp_mro */ + NULL, /* tp_cache */ + NULL, /* tp_subclasses */ + NULL, /* tp_weaklist */ + (destructor) NULL /* tp_del */ +}; + + + +static PyObject* _wrap_PyBurnBurn_source__get_refcount(PyBurnBurn_source *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "i", self->obj->refcount); + return py_retval; +} +static int _wrap_PyBurnBurn_source__set_refcount(PyBurnBurn_source *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->refcount)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_source__get_version(PyBurnBurn_source *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "i", self->obj->version); + return py_retval; +} +static int _wrap_PyBurnBurn_source__set_version(PyBurnBurn_source *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->version)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyGetSetDef PyBurnBurn_source__getsets[] = { + { + (char*) "version", /* attribute name */ + (getter) _wrap_PyBurnBurn_source__get_version, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_source__set_version, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "refcount", /* attribute name */ + (getter) _wrap_PyBurnBurn_source__get_refcount, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_source__set_refcount, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { NULL, NULL, NULL, NULL, NULL } +}; + + +static int +_wrap_PyBurnBurn_source__tp_init__0(PyBurnBurn_source *self, PyObject *args, PyObject *kwargs, PyObject **return_exception) +{ + PyBurnBurn_source *arg02; + const char *keywords[] = {"arg0", NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "O!", (char **) keywords, &PyBurnBurn_source_Type, &arg02)) { + { + PyObject *exc_type, *traceback; + PyErr_Fetch(&exc_type, return_exception, &traceback); + Py_XDECREF(exc_type); + Py_XDECREF(traceback); + } + return -1; + } + self->obj = new burn::burn_source(*((PyBurnBurn_source *) arg02)->obj); + return 0; +} + +static int +_wrap_PyBurnBurn_source__tp_init__1(PyBurnBurn_source *self, PyObject *args, PyObject *kwargs, PyObject **return_exception) +{ + const char *keywords[] = {NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "", (char **) keywords)) { + { + PyObject *exc_type, *traceback; + PyErr_Fetch(&exc_type, return_exception, &traceback); + Py_XDECREF(exc_type); + Py_XDECREF(traceback); + } + return -1; + } + self->obj = new burn::burn_source(); + return 0; +} + +int _wrap_PyBurnBurn_source__tp_init(PyBurnBurn_source *self, PyObject *args, PyObject *kwargs) +{ + int retval; + PyObject *error_list; + PyObject *exceptions[2] = {0,}; + retval = _wrap_PyBurnBurn_source__tp_init__0(self, args, kwargs, &exceptions[0]); + if (!exceptions[0]) { + return retval; + } + retval = _wrap_PyBurnBurn_source__tp_init__1(self, args, kwargs, &exceptions[1]); + if (!exceptions[1]) { + Py_DECREF(exceptions[0]); + return retval; + } + error_list = PyList_New(2); + PyList_SET_ITEM(error_list, 0, PyObject_Str(exceptions[0])); + Py_DECREF(exceptions[0]); + PyList_SET_ITEM(error_list, 1, PyObject_Str(exceptions[1])); + Py_DECREF(exceptions[1]); + PyErr_SetObject(PyExc_TypeError, error_list); + Py_DECREF(error_list); + return -1; +} + + +static PyObject* +_wrap_PyBurnBurn_source__copy__(PyBurnBurn_source *self) +{ + + PyBurnBurn_source *py_copy; + py_copy = PyObject_New(PyBurnBurn_source, &PyBurnBurn_source_Type); + py_copy->obj = new burn::burn_source(*self->obj); + return (PyObject*) py_copy; +} + +static PyMethodDef PyBurnBurn_source_methods[] = { + {(char *) "__copy__", (PyCFunction) _wrap_PyBurnBurn_source__copy__, METH_NOARGS, NULL}, + {NULL, NULL, 0, NULL} +}; + +static void +_wrap_PyBurnBurn_source__tp_dealloc(PyBurnBurn_source *self) +{ + burn::burn_source *tmp = self->obj; + self->obj = NULL; + delete tmp; + self->ob_type->tp_free((PyObject*)self); +} + +static PyObject* +_wrap_PyBurnBurn_source__tp_richcompare (PyBurnBurn_source *self, PyBurnBurn_source *other, int opid) +{ + + if (!PyObject_IsInstance((PyObject*) other, (PyObject*) &PyBurnBurn_source_Type)) { + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + } + switch (opid) + { + case Py_LT: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + case Py_LE: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + case Py_EQ: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + case Py_NE: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + case Py_GE: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + case Py_GT: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + } /* closes switch (opid) */ + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; +} + +PyTypeObject PyBurnBurn_source_Type = { + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ + (char *) "burn.burn.Burn_source", /* tp_name */ + sizeof(PyBurnBurn_source), /* tp_basicsize */ + 0, /* tp_itemsize */ + /* methods */ + (destructor)_wrap_PyBurnBurn_source__tp_dealloc, /* tp_dealloc */ + (printfunc)0, /* tp_print */ + (getattrfunc)NULL, /* tp_getattr */ + (setattrfunc)NULL, /* tp_setattr */ + (cmpfunc)NULL, /* tp_compare */ + (reprfunc)NULL, /* tp_repr */ + (PyNumberMethods*)NULL, /* tp_as_number */ + (PySequenceMethods*)NULL, /* tp_as_sequence */ + (PyMappingMethods*)NULL, /* tp_as_mapping */ + (hashfunc)NULL, /* tp_hash */ + (ternaryfunc)NULL, /* tp_call */ + (reprfunc)NULL, /* tp_str */ + (getattrofunc)NULL, /* tp_getattro */ + (setattrofunc)NULL, /* tp_setattro */ + (PyBufferProcs*)NULL, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /* tp_flags */ + NULL, /* Documentation string */ + (traverseproc)NULL, /* tp_traverse */ + (inquiry)NULL, /* tp_clear */ + (richcmpfunc)_wrap_PyBurnBurn_source__tp_richcompare, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + (getiterfunc)NULL, /* tp_iter */ + (iternextfunc)NULL, /* tp_iternext */ + (struct PyMethodDef*)PyBurnBurn_source_methods, /* tp_methods */ + (struct PyMemberDef*)0, /* tp_members */ + PyBurnBurn_source__getsets, /* tp_getset */ + NULL, /* tp_base */ + NULL, /* tp_dict */ + (descrgetfunc)NULL, /* tp_descr_get */ + (descrsetfunc)NULL, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)_wrap_PyBurnBurn_source__tp_init, /* tp_init */ + (allocfunc)PyType_GenericAlloc, /* tp_alloc */ + (newfunc)PyType_GenericNew, /* tp_new */ + (freefunc)0, /* tp_free */ + (inquiry)NULL, /* tp_is_gc */ + NULL, /* tp_bases */ + NULL, /* tp_mro */ + NULL, /* tp_cache */ + NULL, /* tp_subclasses */ + NULL, /* tp_weaklist */ + (destructor) NULL /* tp_del */ +}; + + + +static PyObject* _wrap_PyBurnBurn_speed_descriptor__get_source(PyBurnBurn_speed_descriptor *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "i", self->obj->source); + return py_retval; +} +static int _wrap_PyBurnBurn_speed_descriptor__set_source(PyBurnBurn_speed_descriptor *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->source)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_speed_descriptor__get_profile_loaded(PyBurnBurn_speed_descriptor *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "i", self->obj->profile_loaded); + return py_retval; +} +static int _wrap_PyBurnBurn_speed_descriptor__set_profile_loaded(PyBurnBurn_speed_descriptor *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->profile_loaded)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_speed_descriptor__get_end_lba(PyBurnBurn_speed_descriptor *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "i", self->obj->end_lba); + return py_retval; +} +static int _wrap_PyBurnBurn_speed_descriptor__set_end_lba(PyBurnBurn_speed_descriptor *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->end_lba)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_speed_descriptor__get_write_speed(PyBurnBurn_speed_descriptor *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "i", self->obj->write_speed); + return py_retval; +} +static int _wrap_PyBurnBurn_speed_descriptor__set_write_speed(PyBurnBurn_speed_descriptor *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->write_speed)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_speed_descriptor__get_read_speed(PyBurnBurn_speed_descriptor *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "i", self->obj->read_speed); + return py_retval; +} +static int _wrap_PyBurnBurn_speed_descriptor__set_read_speed(PyBurnBurn_speed_descriptor *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->read_speed)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_speed_descriptor__get_wrc(PyBurnBurn_speed_descriptor *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "i", self->obj->wrc); + return py_retval; +} +static int _wrap_PyBurnBurn_speed_descriptor__set_wrc(PyBurnBurn_speed_descriptor *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->wrc)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_speed_descriptor__get_exact(PyBurnBurn_speed_descriptor *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "i", self->obj->exact); + return py_retval; +} +static int _wrap_PyBurnBurn_speed_descriptor__set_exact(PyBurnBurn_speed_descriptor *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->exact)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_speed_descriptor__get_mrw(PyBurnBurn_speed_descriptor *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "i", self->obj->mrw); + return py_retval; +} +static int _wrap_PyBurnBurn_speed_descriptor__set_mrw(PyBurnBurn_speed_descriptor *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->mrw)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyGetSetDef PyBurnBurn_speed_descriptor__getsets[] = { + { + (char*) "mrw", /* attribute name */ + (getter) _wrap_PyBurnBurn_speed_descriptor__get_mrw, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_speed_descriptor__set_mrw, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "wrc", /* attribute name */ + (getter) _wrap_PyBurnBurn_speed_descriptor__get_wrc, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_speed_descriptor__set_wrc, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "profile_loaded", /* attribute name */ + (getter) _wrap_PyBurnBurn_speed_descriptor__get_profile_loaded, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_speed_descriptor__set_profile_loaded, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "source", /* attribute name */ + (getter) _wrap_PyBurnBurn_speed_descriptor__get_source, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_speed_descriptor__set_source, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "write_speed", /* attribute name */ + (getter) _wrap_PyBurnBurn_speed_descriptor__get_write_speed, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_speed_descriptor__set_write_speed, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "end_lba", /* attribute name */ + (getter) _wrap_PyBurnBurn_speed_descriptor__get_end_lba, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_speed_descriptor__set_end_lba, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "exact", /* attribute name */ + (getter) _wrap_PyBurnBurn_speed_descriptor__get_exact, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_speed_descriptor__set_exact, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "read_speed", /* attribute name */ + (getter) _wrap_PyBurnBurn_speed_descriptor__get_read_speed, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_speed_descriptor__set_read_speed, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { NULL, NULL, NULL, NULL, NULL } +}; + + +static int +_wrap_PyBurnBurn_speed_descriptor__tp_init__0(PyBurnBurn_speed_descriptor *self, PyObject *args, PyObject *kwargs, PyObject **return_exception) +{ + PyBurnBurn_speed_descriptor *arg02; + const char *keywords[] = {"arg0", NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "O!", (char **) keywords, &PyBurnBurn_speed_descriptor_Type, &arg02)) { + { + PyObject *exc_type, *traceback; + PyErr_Fetch(&exc_type, return_exception, &traceback); + Py_XDECREF(exc_type); + Py_XDECREF(traceback); + } + return -1; + } + self->obj = new burn::burn_speed_descriptor(*((PyBurnBurn_speed_descriptor *) arg02)->obj); + return 0; +} + +static int +_wrap_PyBurnBurn_speed_descriptor__tp_init__1(PyBurnBurn_speed_descriptor *self, PyObject *args, PyObject *kwargs, PyObject **return_exception) +{ + const char *keywords[] = {NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "", (char **) keywords)) { + { + PyObject *exc_type, *traceback; + PyErr_Fetch(&exc_type, return_exception, &traceback); + Py_XDECREF(exc_type); + Py_XDECREF(traceback); + } + return -1; + } + self->obj = new burn::burn_speed_descriptor(); + return 0; +} + +int _wrap_PyBurnBurn_speed_descriptor__tp_init(PyBurnBurn_speed_descriptor *self, PyObject *args, PyObject *kwargs) +{ + int retval; + PyObject *error_list; + PyObject *exceptions[2] = {0,}; + retval = _wrap_PyBurnBurn_speed_descriptor__tp_init__0(self, args, kwargs, &exceptions[0]); + if (!exceptions[0]) { + return retval; + } + retval = _wrap_PyBurnBurn_speed_descriptor__tp_init__1(self, args, kwargs, &exceptions[1]); + if (!exceptions[1]) { + Py_DECREF(exceptions[0]); + return retval; + } + error_list = PyList_New(2); + PyList_SET_ITEM(error_list, 0, PyObject_Str(exceptions[0])); + Py_DECREF(exceptions[0]); + PyList_SET_ITEM(error_list, 1, PyObject_Str(exceptions[1])); + Py_DECREF(exceptions[1]); + PyErr_SetObject(PyExc_TypeError, error_list); + Py_DECREF(error_list); + return -1; +} + + +static PyObject* +_wrap_PyBurnBurn_speed_descriptor__copy__(PyBurnBurn_speed_descriptor *self) +{ + + PyBurnBurn_speed_descriptor *py_copy; + py_copy = PyObject_New(PyBurnBurn_speed_descriptor, &PyBurnBurn_speed_descriptor_Type); + py_copy->obj = new burn::burn_speed_descriptor(*self->obj); + return (PyObject*) py_copy; +} + +static PyMethodDef PyBurnBurn_speed_descriptor_methods[] = { + {(char *) "__copy__", (PyCFunction) _wrap_PyBurnBurn_speed_descriptor__copy__, METH_NOARGS, NULL}, + {NULL, NULL, 0, NULL} +}; + +static void +_wrap_PyBurnBurn_speed_descriptor__tp_dealloc(PyBurnBurn_speed_descriptor *self) +{ + burn::burn_speed_descriptor *tmp = self->obj; + self->obj = NULL; + delete tmp; + self->ob_type->tp_free((PyObject*)self); +} + +static PyObject* +_wrap_PyBurnBurn_speed_descriptor__tp_richcompare (PyBurnBurn_speed_descriptor *self, PyBurnBurn_speed_descriptor *other, int opid) +{ + + if (!PyObject_IsInstance((PyObject*) other, (PyObject*) &PyBurnBurn_speed_descriptor_Type)) { + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + } + switch (opid) + { + case Py_LT: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + case Py_LE: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + case Py_EQ: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + case Py_NE: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + case Py_GE: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + case Py_GT: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + } /* closes switch (opid) */ + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; +} + +PyTypeObject PyBurnBurn_speed_descriptor_Type = { + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ + (char *) "burn.burn.Burn_speed_descriptor", /* tp_name */ + sizeof(PyBurnBurn_speed_descriptor), /* tp_basicsize */ + 0, /* tp_itemsize */ + /* methods */ + (destructor)_wrap_PyBurnBurn_speed_descriptor__tp_dealloc, /* tp_dealloc */ + (printfunc)0, /* tp_print */ + (getattrfunc)NULL, /* tp_getattr */ + (setattrfunc)NULL, /* tp_setattr */ + (cmpfunc)NULL, /* tp_compare */ + (reprfunc)NULL, /* tp_repr */ + (PyNumberMethods*)NULL, /* tp_as_number */ + (PySequenceMethods*)NULL, /* tp_as_sequence */ + (PyMappingMethods*)NULL, /* tp_as_mapping */ + (hashfunc)NULL, /* tp_hash */ + (ternaryfunc)NULL, /* tp_call */ + (reprfunc)NULL, /* tp_str */ + (getattrofunc)NULL, /* tp_getattro */ + (setattrofunc)NULL, /* tp_setattro */ + (PyBufferProcs*)NULL, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /* tp_flags */ + NULL, /* Documentation string */ + (traverseproc)NULL, /* tp_traverse */ + (inquiry)NULL, /* tp_clear */ + (richcmpfunc)_wrap_PyBurnBurn_speed_descriptor__tp_richcompare, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + (getiterfunc)NULL, /* tp_iter */ + (iternextfunc)NULL, /* tp_iternext */ + (struct PyMethodDef*)PyBurnBurn_speed_descriptor_methods, /* tp_methods */ + (struct PyMemberDef*)0, /* tp_members */ + PyBurnBurn_speed_descriptor__getsets, /* tp_getset */ + NULL, /* tp_base */ + NULL, /* tp_dict */ + (descrgetfunc)NULL, /* tp_descr_get */ + (descrsetfunc)NULL, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)_wrap_PyBurnBurn_speed_descriptor__tp_init, /* tp_init */ + (allocfunc)PyType_GenericAlloc, /* tp_alloc */ + (newfunc)PyType_GenericNew, /* tp_new */ + (freefunc)0, /* tp_free */ + (inquiry)NULL, /* tp_is_gc */ + NULL, /* tp_bases */ + NULL, /* tp_mro */ + NULL, /* tp_cache */ + NULL, /* tp_subclasses */ + NULL, /* tp_weaklist */ + (destructor) NULL /* tp_del */ +}; + + + +static PyObject* _wrap_PyBurnBurn_toc_entry__get_start_lba(PyBurnBurn_toc_entry *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "i", self->obj->start_lba); + return py_retval; +} +static int _wrap_PyBurnBurn_toc_entry__set_start_lba(PyBurnBurn_toc_entry *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->start_lba)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyObject* _wrap_PyBurnBurn_toc_entry__get_track_blocks(PyBurnBurn_toc_entry *self) +{ + PyObject *py_retval; + + py_retval = Py_BuildValue((char *) "i", self->obj->track_blocks); + return py_retval; +} +static int _wrap_PyBurnBurn_toc_entry__set_track_blocks(PyBurnBurn_toc_entry *self, PyObject *value) +{ + PyGILState_STATE __py_gil_state; + PyObject *py_retval; + + __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0); + py_retval = Py_BuildValue((char *) "(O)", value); + if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->track_blocks)) { + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return -1; + } + Py_DECREF(py_retval); + if (PyEval_ThreadsInitialized()) + PyGILState_Release(__py_gil_state); + return 0; +} +static PyGetSetDef PyBurnBurn_toc_entry__getsets[] = { + { + (char*) "track_blocks", /* attribute name */ + (getter) _wrap_PyBurnBurn_toc_entry__get_track_blocks, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_toc_entry__set_track_blocks, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { + (char*) "start_lba", /* attribute name */ + (getter) _wrap_PyBurnBurn_toc_entry__get_start_lba, /* C function to get the attribute */ + (setter) _wrap_PyBurnBurn_toc_entry__set_start_lba, /* C function to set the attribute */ + NULL, /* optional doc string */ + NULL /* optional additional data for getter and setter */ + }, + { NULL, NULL, NULL, NULL, NULL } +}; + + +static int +_wrap_PyBurnBurn_toc_entry__tp_init__0(PyBurnBurn_toc_entry *self, PyObject *args, PyObject *kwargs, PyObject **return_exception) +{ + PyBurnBurn_toc_entry *arg02; + const char *keywords[] = {"arg0", NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "O!", (char **) keywords, &PyBurnBurn_toc_entry_Type, &arg02)) { + { + PyObject *exc_type, *traceback; + PyErr_Fetch(&exc_type, return_exception, &traceback); + Py_XDECREF(exc_type); + Py_XDECREF(traceback); + } + return -1; + } + self->obj = new burn::burn_toc_entry(*((PyBurnBurn_toc_entry *) arg02)->obj); + return 0; +} + +static int +_wrap_PyBurnBurn_toc_entry__tp_init__1(PyBurnBurn_toc_entry *self, PyObject *args, PyObject *kwargs, PyObject **return_exception) +{ + const char *keywords[] = {NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "", (char **) keywords)) { + { + PyObject *exc_type, *traceback; + PyErr_Fetch(&exc_type, return_exception, &traceback); + Py_XDECREF(exc_type); + Py_XDECREF(traceback); + } + return -1; + } + self->obj = new burn::burn_toc_entry(); + return 0; +} + +int _wrap_PyBurnBurn_toc_entry__tp_init(PyBurnBurn_toc_entry *self, PyObject *args, PyObject *kwargs) +{ + int retval; + PyObject *error_list; + PyObject *exceptions[2] = {0,}; + retval = _wrap_PyBurnBurn_toc_entry__tp_init__0(self, args, kwargs, &exceptions[0]); + if (!exceptions[0]) { + return retval; + } + retval = _wrap_PyBurnBurn_toc_entry__tp_init__1(self, args, kwargs, &exceptions[1]); + if (!exceptions[1]) { + Py_DECREF(exceptions[0]); + return retval; + } + error_list = PyList_New(2); + PyList_SET_ITEM(error_list, 0, PyObject_Str(exceptions[0])); + Py_DECREF(exceptions[0]); + PyList_SET_ITEM(error_list, 1, PyObject_Str(exceptions[1])); + Py_DECREF(exceptions[1]); + PyErr_SetObject(PyExc_TypeError, error_list); + Py_DECREF(error_list); + return -1; +} + + +static PyObject* +_wrap_PyBurnBurn_toc_entry__copy__(PyBurnBurn_toc_entry *self) +{ + + PyBurnBurn_toc_entry *py_copy; + py_copy = PyObject_New(PyBurnBurn_toc_entry, &PyBurnBurn_toc_entry_Type); + py_copy->obj = new burn::burn_toc_entry(*self->obj); + return (PyObject*) py_copy; +} + +static PyMethodDef PyBurnBurn_toc_entry_methods[] = { + {(char *) "__copy__", (PyCFunction) _wrap_PyBurnBurn_toc_entry__copy__, METH_NOARGS, NULL}, + {NULL, NULL, 0, NULL} +}; + +static void +_wrap_PyBurnBurn_toc_entry__tp_dealloc(PyBurnBurn_toc_entry *self) +{ + burn::burn_toc_entry *tmp = self->obj; + self->obj = NULL; + delete tmp; + self->ob_type->tp_free((PyObject*)self); +} + +static PyObject* +_wrap_PyBurnBurn_toc_entry__tp_richcompare (PyBurnBurn_toc_entry *self, PyBurnBurn_toc_entry *other, int opid) +{ + + if (!PyObject_IsInstance((PyObject*) other, (PyObject*) &PyBurnBurn_toc_entry_Type)) { + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + } + switch (opid) + { + case Py_LT: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + case Py_LE: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + case Py_EQ: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + case Py_NE: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + case Py_GE: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + case Py_GT: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + } /* closes switch (opid) */ + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; +} + +PyTypeObject PyBurnBurn_toc_entry_Type = { + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ + (char *) "burn.burn.Burn_toc_entry", /* tp_name */ + sizeof(PyBurnBurn_toc_entry), /* tp_basicsize */ + 0, /* tp_itemsize */ + /* methods */ + (destructor)_wrap_PyBurnBurn_toc_entry__tp_dealloc, /* tp_dealloc */ + (printfunc)0, /* tp_print */ + (getattrfunc)NULL, /* tp_getattr */ + (setattrfunc)NULL, /* tp_setattr */ + (cmpfunc)NULL, /* tp_compare */ + (reprfunc)NULL, /* tp_repr */ + (PyNumberMethods*)NULL, /* tp_as_number */ + (PySequenceMethods*)NULL, /* tp_as_sequence */ + (PyMappingMethods*)NULL, /* tp_as_mapping */ + (hashfunc)NULL, /* tp_hash */ + (ternaryfunc)NULL, /* tp_call */ + (reprfunc)NULL, /* tp_str */ + (getattrofunc)NULL, /* tp_getattro */ + (setattrofunc)NULL, /* tp_setattro */ + (PyBufferProcs*)NULL, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /* tp_flags */ + NULL, /* Documentation string */ + (traverseproc)NULL, /* tp_traverse */ + (inquiry)NULL, /* tp_clear */ + (richcmpfunc)_wrap_PyBurnBurn_toc_entry__tp_richcompare, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + (getiterfunc)NULL, /* tp_iter */ + (iternextfunc)NULL, /* tp_iternext */ + (struct PyMethodDef*)PyBurnBurn_toc_entry_methods, /* tp_methods */ + (struct PyMemberDef*)0, /* tp_members */ + PyBurnBurn_toc_entry__getsets, /* tp_getset */ + NULL, /* tp_base */ + NULL, /* tp_dict */ + (descrgetfunc)NULL, /* tp_descr_get */ + (descrsetfunc)NULL, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)_wrap_PyBurnBurn_toc_entry__tp_init, /* tp_init */ + (allocfunc)PyType_GenericAlloc, /* tp_alloc */ + (newfunc)PyType_GenericNew, /* tp_new */ + (freefunc)0, /* tp_free */ + (inquiry)NULL, /* tp_is_gc */ + NULL, /* tp_bases */ + NULL, /* tp_mro */ + NULL, /* tp_cache */ + NULL, /* tp_subclasses */ + NULL, /* tp_weaklist */ + (destructor) NULL /* tp_del */ +}; + + +/* --- enumerations --- */ + + + + + + + + + + + + +static PyObject * +initburn_burn(void) +{ + PyObject *m; + m = Py_InitModule3((char *) "burn.burn", burn_burn_functions, NULL); + if (m == NULL) { + return NULL; + } + /* Register the 'burn::burn_drive_info' class */ + if (PyType_Ready(&PyBurnBurn_drive_info_Type)) { + return NULL; + } + PyModule_AddObject(m, (char *) "burn_drive_info", (PyObject *) &PyBurnBurn_drive_info_Type); + /* Register the 'burn::burn_multi_caps' class */ + if (PyType_Ready(&PyBurnBurn_multi_caps_Type)) { + return NULL; + } + PyModule_AddObject(m, (char *) "burn_multi_caps", (PyObject *) &PyBurnBurn_multi_caps_Type); + /* Register the 'burn::burn_progress' class */ + if (PyType_Ready(&PyBurnBurn_progress_Type)) { + return NULL; + } + PyModule_AddObject(m, (char *) "burn_progress", (PyObject *) &PyBurnBurn_progress_Type); + /* Register the 'burn::burn_source' class */ + if (PyType_Ready(&PyBurnBurn_source_Type)) { + return NULL; + } + PyModule_AddObject(m, (char *) "burn_source", (PyObject *) &PyBurnBurn_source_Type); + /* Register the 'burn::burn_speed_descriptor' class */ + if (PyType_Ready(&PyBurnBurn_speed_descriptor_Type)) { + return NULL; + } + PyModule_AddObject(m, (char *) "burn_speed_descriptor", (PyObject *) &PyBurnBurn_speed_descriptor_Type); + /* Register the 'burn::burn_toc_entry' class */ + if (PyType_Ready(&PyBurnBurn_toc_entry_Type)) { + return NULL; + } + PyModule_AddObject(m, (char *) "burn_toc_entry", (PyObject *) &PyBurnBurn_toc_entry_Type); + PyModule_AddIntConstant(m, (char *) "BURN_BLOCK_RAW0", burn::BURN_BLOCK_RAW0); + PyModule_AddIntConstant(m, (char *) "BURN_BLOCK_RAW16", burn::BURN_BLOCK_RAW16); + PyModule_AddIntConstant(m, (char *) "BURN_BLOCK_RAW96P", burn::BURN_BLOCK_RAW96P); + PyModule_AddIntConstant(m, (char *) "BURN_BLOCK_RAW96R", burn::BURN_BLOCK_RAW96R); + PyModule_AddIntConstant(m, (char *) "BURN_BLOCK_MODE1", burn::BURN_BLOCK_MODE1); + PyModule_AddIntConstant(m, (char *) "BURN_BLOCK_MODE2R", burn::BURN_BLOCK_MODE2R); + PyModule_AddIntConstant(m, (char *) "BURN_BLOCK_MODE2_PATHETIC", burn::BURN_BLOCK_MODE2_PATHETIC); + PyModule_AddIntConstant(m, (char *) "BURN_BLOCK_MODE2_LAME", burn::BURN_BLOCK_MODE2_LAME); + PyModule_AddIntConstant(m, (char *) "BURN_BLOCK_MODE2_OBSCURE", burn::BURN_BLOCK_MODE2_OBSCURE); + PyModule_AddIntConstant(m, (char *) "BURN_BLOCK_MODE2_OK", burn::BURN_BLOCK_MODE2_OK); + PyModule_AddIntConstant(m, (char *) "BURN_BLOCK_SAO", burn::BURN_BLOCK_SAO); + PyModule_AddIntConstant(m, (char *) "BURN_DISC_UNREADY", burn::BURN_DISC_UNREADY); + PyModule_AddIntConstant(m, (char *) "BURN_DISC_BLANK", burn::BURN_DISC_BLANK); + PyModule_AddIntConstant(m, (char *) "BURN_DISC_EMPTY", burn::BURN_DISC_EMPTY); + PyModule_AddIntConstant(m, (char *) "BURN_DISC_APPENDABLE", burn::BURN_DISC_APPENDABLE); + PyModule_AddIntConstant(m, (char *) "BURN_DISC_FULL", burn::BURN_DISC_FULL); + PyModule_AddIntConstant(m, (char *) "BURN_DISC_UNGRABBED", burn::BURN_DISC_UNGRABBED); + PyModule_AddIntConstant(m, (char *) "BURN_DISC_UNSUITABLE", burn::BURN_DISC_UNSUITABLE); + PyModule_AddIntConstant(m, (char *) "BURN_SOURCE_OK", burn::BURN_SOURCE_OK); + PyModule_AddIntConstant(m, (char *) "BURN_SOURCE_EOF", burn::BURN_SOURCE_EOF); + PyModule_AddIntConstant(m, (char *) "BURN_SOURCE_FAILED", burn::BURN_SOURCE_FAILED); + PyModule_AddIntConstant(m, (char *) "BURN_WRITE_PACKET", burn::BURN_WRITE_PACKET); + PyModule_AddIntConstant(m, (char *) "BURN_WRITE_TAO", burn::BURN_WRITE_TAO); + PyModule_AddIntConstant(m, (char *) "BURN_WRITE_SAO", burn::BURN_WRITE_SAO); + PyModule_AddIntConstant(m, (char *) "BURN_WRITE_RAW", burn::BURN_WRITE_RAW); + PyModule_AddIntConstant(m, (char *) "BURN_WRITE_NONE", burn::BURN_WRITE_NONE); + PyModule_AddIntConstant(m, (char *) "BURN_DRIVE_IDLE", burn::BURN_DRIVE_IDLE); + PyModule_AddIntConstant(m, (char *) "BURN_DRIVE_SPAWNING", burn::BURN_DRIVE_SPAWNING); + PyModule_AddIntConstant(m, (char *) "BURN_DRIVE_READING", burn::BURN_DRIVE_READING); + PyModule_AddIntConstant(m, (char *) "BURN_DRIVE_WRITING", burn::BURN_DRIVE_WRITING); + PyModule_AddIntConstant(m, (char *) "BURN_DRIVE_WRITING_LEADIN", burn::BURN_DRIVE_WRITING_LEADIN); + PyModule_AddIntConstant(m, (char *) "BURN_DRIVE_WRITING_LEADOUT", burn::BURN_DRIVE_WRITING_LEADOUT); + PyModule_AddIntConstant(m, (char *) "BURN_DRIVE_ERASING", burn::BURN_DRIVE_ERASING); + PyModule_AddIntConstant(m, (char *) "BURN_DRIVE_GRABBING", burn::BURN_DRIVE_GRABBING); + PyModule_AddIntConstant(m, (char *) "BURN_DRIVE_WRITING_PREGAP", burn::BURN_DRIVE_WRITING_PREGAP); + PyModule_AddIntConstant(m, (char *) "BURN_DRIVE_CLOSING_TRACK", burn::BURN_DRIVE_CLOSING_TRACK); + PyModule_AddIntConstant(m, (char *) "BURN_DRIVE_CLOSING_SESSION", burn::BURN_DRIVE_CLOSING_SESSION); + PyModule_AddIntConstant(m, (char *) "BURN_DRIVE_FORMATTING", burn::BURN_DRIVE_FORMATTING); + PyModule_AddIntConstant(m, (char *) "BURN_DRIVE_READING_SYNC", burn::BURN_DRIVE_READING_SYNC); + PyModule_AddIntConstant(m, (char *) "BURN_DRIVE_WRITING_SYNC", burn::BURN_DRIVE_WRITING_SYNC); + return m; +} +static PyMethodDef burn_std_functions[] = { + {NULL, NULL, 0, NULL} +}; + +static PyObject * +initburn_std(void) +{ + PyObject *m; + m = Py_InitModule3((char *) "burn.std", burn_std_functions, NULL); + if (m == NULL) { + return NULL; + } + return m; +} +static PyMethodDef burn_functions[] = { + {NULL, NULL, 0, NULL} +}; + +PyMODINIT_FUNC +initburn(void) +{ + PyObject *m; + PyObject *submodule; + m = Py_InitModule3((char *) "burn", burn_functions, NULL); + if (m == NULL) { + return; + } + submodule = initburn_burn(); + if (submodule == NULL) { + return; + } + Py_INCREF(submodule); + PyModule_AddObject(m, (char *) "burn", submodule); + submodule = initburn_std(); + if (submodule == NULL) { + return; + } + Py_INCREF(submodule); + PyModule_AddObject(m, (char *) "std", submodule); +}