From: Jaroslav Kysela Date: Wed, 6 Feb 2008 09:17:39 +0000 (+0100) Subject: unify naming, only classes and constants use upper letters now X-Git-Tag: v1.0.17rc1~6 X-Git-Url: https://git.alsa-project.org/?a=commitdiff_plain;h=ac07d0777e85c94014a109fb1112a4985369475c;p=alsa-python.git unify naming, only classes and constants use upper letters now --- diff --git a/pyalsa/alsacard.c b/pyalsa/alsacard.c index 6e575bf..4738334 100644 --- a/pyalsa/alsacard.c +++ b/pyalsa/alsacard.c @@ -55,7 +55,7 @@ asoundlib_version(PyObject *self, PyObject *args) } PyDoc_STRVAR(card_load__doc__, -"cardLoad([card]) -- Load driver for given card."); +"card_load([card]) -- Load driver for given card."); static PyObject * card_load(PyObject *self, PyObject *args, PyObject *kwds) @@ -70,7 +70,7 @@ card_load(PyObject *self, PyObject *args, PyObject *kwds) } PyDoc_STRVAR(card_list__doc__, -"cardList() -- Get a card number list in tuple."); +"card_list() -- Get a card number list in tuple."); static PyObject * card_list(PyObject *self, PyObject *args) @@ -98,7 +98,7 @@ card_list(PyObject *self, PyObject *args) } PyDoc_STRVAR(card_get_index__doc__, -"cardGetIndex(name) -- Get card index using ID string."); +"card_get_index(name) -- Get card index using ID string."); static PyObject * card_get_index(PyObject *self, PyObject *args, PyObject *kwds) @@ -113,7 +113,7 @@ card_get_index(PyObject *self, PyObject *args, PyObject *kwds) } PyDoc_STRVAR(card_get_name__doc__, -"cardGetName(card) -- Get card name string using card index."); +"card_get_name(card) -- Get card name string using card index."); static PyObject * card_get_name(PyObject *self, PyObject *args, PyObject *kwds) @@ -135,7 +135,7 @@ card_get_name(PyObject *self, PyObject *args, PyObject *kwds) } PyDoc_STRVAR(card_get_longname__doc__, -"cardGetLongname(card) -- Get long card name string using card index."); +"card_get_longname(card) -- Get long card name string using card index."); static PyObject * card_get_longname(PyObject *self, PyObject *args, PyObject *kwds) @@ -157,7 +157,7 @@ card_get_longname(PyObject *self, PyObject *args, PyObject *kwds) } PyDoc_STRVAR(device_name_hint__doc__, -"deviceNameHint(card, interface) -- Get device name hints."); +"device_name_hint(card, interface) -- Get device name hints."); static PyObject * device_name_hint(PyObject *self, PyObject *args, PyObject *kwds) @@ -217,13 +217,13 @@ device_name_hint(PyObject *self, PyObject *args, PyObject *kwds) */ static PyMethodDef pyalsacardparse_methods[] = { - {"asoundlibVersion", (PyCFunction)asoundlib_version, METH_NOARGS, asoundlib_version__doc__}, - {"cardLoad", (PyCFunction)card_load, METH_VARARGS|METH_KEYWORDS, card_load__doc__}, - {"cardList", (PyCFunction)card_list, METH_NOARGS, card_list__doc__}, - {"cardGetIndex", (PyCFunction)card_get_index, METH_VARARGS|METH_KEYWORDS, card_get_index__doc__}, - {"cardGetName", (PyCFunction)card_get_name, METH_VARARGS|METH_KEYWORDS, card_get_name__doc__}, - {"cardGetLongname", (PyCFunction)card_get_longname, METH_VARARGS|METH_KEYWORDS, card_get_longname__doc__}, - {"deviceNameHint", (PyCFunction)device_name_hint, METH_VARARGS|METH_KEYWORDS, device_name_hint__doc__}, + {"asoundlib_version", (PyCFunction)asoundlib_version, METH_NOARGS, asoundlib_version__doc__}, + {"card_load", (PyCFunction)card_load, METH_VARARGS|METH_KEYWORDS, card_load__doc__}, + {"card_list", (PyCFunction)card_list, METH_NOARGS, card_list__doc__}, + {"card_get_index", (PyCFunction)card_get_index, METH_VARARGS|METH_KEYWORDS, card_get_index__doc__}, + {"card_get_name", (PyCFunction)card_get_name, METH_VARARGS|METH_KEYWORDS, card_get_name__doc__}, + {"card_get_longname", (PyCFunction)card_get_longname, METH_VARARGS|METH_KEYWORDS, card_get_longname__doc__}, + {"device_name_hint", (PyCFunction)device_name_hint, METH_VARARGS|METH_KEYWORDS, device_name_hint__doc__}, {NULL} }; diff --git a/pyalsa/alsacontrol.c b/pyalsa/alsacontrol.c index 1a6a4ce..8d401bb 100644 --- a/pyalsa/alsacontrol.c +++ b/pyalsa/alsacontrol.c @@ -67,7 +67,7 @@ static inline PyObject *get_bool(int val) } PyDoc_STRVAR(cardinfo__doc__, -"cardInfo() -- Return a dictionary with card specific information."); +"card_info() -- Return a dictionary with card specific information."); static PyObject * pyalsacontrol_cardinfo(struct pyalsacontrol *self, PyObject *args) @@ -122,7 +122,7 @@ devices(struct pyalsacontrol *self, PyObject *args, } PyDoc_STRVAR(hwdepdevices__doc__, -"hwdepDevices() -- Return a tuple with available hwdep devices."); +"hwdep_devices() -- Return a tuple with available hwdep devices."); static PyObject * pyalsacontrol_hwdepdevices(struct pyalsacontrol *self, PyObject *args) @@ -131,7 +131,7 @@ pyalsacontrol_hwdepdevices(struct pyalsacontrol *self, PyObject *args) } PyDoc_STRVAR(pcmdevices__doc__, -"pcmDevices() -- Return a tuple with available PCM devices."); +"pcm_devices() -- Return a tuple with available PCM devices."); static PyObject * pyalsacontrol_pcmdevices(struct pyalsacontrol *self, PyObject *args) @@ -140,7 +140,7 @@ pyalsacontrol_pcmdevices(struct pyalsacontrol *self, PyObject *args) } PyDoc_STRVAR(rawmididevices__doc__, -"rawmidiDevices() -- Return a tuple with available RawMidi devices."); +"rawmidi_devices() -- Return a tuple with available RawMidi devices."); static PyObject * pyalsacontrol_rawmididevices(struct pyalsacontrol *self, PyObject *args) @@ -191,10 +191,10 @@ static PyGetSetDef pyalsacontrol_getseters[] = { static PyMethodDef pyalsacontrol_methods[] = { - {"cardInfo", (PyCFunction)pyalsacontrol_cardinfo, METH_NOARGS, cardinfo__doc__}, - {"hwdepDevices",(PyCFunction)pyalsacontrol_hwdepdevices, METH_NOARGS, hwdepdevices__doc__}, - {"pcmDevices", (PyCFunction)pyalsacontrol_pcmdevices, METH_NOARGS, pcmdevices__doc__}, - {"rawmidiDevices",(PyCFunction)pyalsacontrol_rawmididevices, METH_NOARGS, rawmididevices__doc__}, + {"card_info", (PyCFunction)pyalsacontrol_cardinfo, METH_NOARGS, cardinfo__doc__}, + {"hwdep_devices",(PyCFunction)pyalsacontrol_hwdepdevices, METH_NOARGS, hwdepdevices__doc__}, + {"pcm_devices", (PyCFunction)pyalsacontrol_pcmdevices, METH_NOARGS, pcmdevices__doc__}, + {"rawmidi_devices",(PyCFunction)pyalsacontrol_rawmididevices, METH_NOARGS, rawmididevices__doc__}, {NULL} }; @@ -256,16 +256,16 @@ initalsacontrol(void) PyDict_SetItemString(d1, pname, o); \ Py_DECREF(o); } - add_space1("Card", CARD); - add_space1("HwDep", HWDEP); - add_space1("Mixer", MIXER); + add_space1("CARD", CARD); + add_space1("HWDEP", HWDEP); + add_space1("MIXER", MIXER); add_space1("PCM", PCM); - add_space1("RawMidi", RAWMIDI); - add_space1("Timer", TIMER); - add_space1("Sequencer", SEQUENCER); - add_space1("Last", LAST); + add_space1("RAWMIDI", RAWMIDI); + add_space1("TIMER", TIMER); + add_space1("SEQUENCER", SEQUENCER); + add_space1("LAST", LAST); - PyDict_SetItemString(d, "InterfaceId", d1); + PyDict_SetItemString(d, "interface_id", d1); Py_DECREF(d1); /* ---- */ @@ -278,7 +278,7 @@ initalsacontrol(void) Py_DECREF(o); } - PyDict_SetItemString(d, "InterfaceName", l1); + PyDict_SetItemString(d, "interface_name", l1); Py_DECREF(l1); /* ---- */ @@ -290,11 +290,11 @@ initalsacontrol(void) PyDict_SetItemString(d1, pname, o); \ Py_DECREF(o); } - add_space5("NonBlock", NONBLOCK); - add_space5("Async", ASYNC); - add_space5("ReadOnly", READONLY); + add_space5("NONBLOCK", NONBLOCK); + add_space5("ASYNC", ASYNC); + add_space5("READONLY", READONLY); - PyDict_SetItemString(d, "OpenMode", d1); + PyDict_SetItemString(d, "open_mode", d1); Py_DECREF(d1); /* ---- */ diff --git a/pyalsa/alsahcontrol.c b/pyalsa/alsahcontrol.c index 70ce807..bb853e7 100644 --- a/pyalsa/alsahcontrol.c +++ b/pyalsa/alsahcontrol.c @@ -143,7 +143,7 @@ pyalsahcontrol_getChctl(struct pyalsahcontrol *self, void *priv) } PyDoc_STRVAR(handlevents__doc__, -"handleEvents() -- Process waiting hcontrol events (and call appropriate callbacks)."); +"handle_events() -- Process waiting hcontrol events (and call appropriate callbacks)."); static PyObject * pyalsahcontrol_handleevents(struct pyalsahcontrol *self, PyObject *args) @@ -160,7 +160,7 @@ pyalsahcontrol_handleevents(struct pyalsahcontrol *self, PyObject *args) } PyDoc_STRVAR(registerpoll__doc__, -"registerPoll(pollObj) -- Register poll file descriptors."); +"register_poll(pollObj) -- Register poll file descriptors."); static PyObject * pyalsahcontrol_registerpoll(struct pyalsahcontrol *self, PyObject *args) @@ -233,10 +233,10 @@ pyalsahcontrol_list(struct pyalsahcontrol *self, PyObject *args) } PyDoc_STRVAR(elementnew__doc__, -"elementNew(ElementType['Integer'], id, count, min, max, step)\n" -"elementNew(ElementType['Integer64'], id, count, min64, max64, step64)\n" -"elementNew(ElementType['Boolean'], id, count)\n" -"elementNew(ElementType['IEC958'], id)\n" +"element_new(element_type['INTEGER'], id, count, min, max, step)\n" +"element_new(element_type['INTEGER64'], id, count, min64, max64, step64)\n" +"element_new(element_type['BOOLEAN'], id, count)\n" +"element_new(element_type['IEC958'], id)\n" " -- Create a new hcontrol element.\n" " -- The id argument is tuple (interface, device, subdevice, name, index).\n"); @@ -319,8 +319,8 @@ pyalsahcontrol_elementnew(struct pyalsahcontrol *self, PyObject *args) } PyDoc_STRVAR(elementremove__doc__, -"elementRemove(id)\n" -"elementRemove(interface, device, subdevice, name, index)\n" +"element_remove(id)\n" +"element_remove(interface, device, subdevice, name, index)\n" " -- Remove element.\n"); static PyObject * @@ -330,8 +330,8 @@ pyalsahcontrol_elementremove(struct pyalsahcontrol *self, PyObject *args) } PyDoc_STRVAR(elementlock__doc__, -"elementLock(id)\n" -"elementLock(interface, device, subdevice, name, index)\n" +"element_lock(id)\n" +"element_lock(interface, device, subdevice, name, index)\n" " -- Lock element.\n"); static PyObject * @@ -341,8 +341,8 @@ pyalsahcontrol_elementlock(struct pyalsahcontrol *self, PyObject *args) } PyDoc_STRVAR(elementunlock__doc__, -"elementUnlock(id)\n" -"elementUnlock(interface, device, subdevice, name, index)\n" +"element_unlock(id)\n" +"element_unlock(interface, device, subdevice, name, index)\n" " -- Unlock element.\n"); static PyObject * @@ -409,12 +409,12 @@ static PyGetSetDef pyalsahcontrol_getseters[] = { static PyMethodDef pyalsahcontrol_methods[] = { {"list", (PyCFunction)pyalsahcontrol_list, METH_NOARGS, list__doc__}, - {"elementNew", (PyCFunction)pyalsahcontrol_elementnew, METH_VARARGS, elementnew__doc__}, - {"elementRemove",(PyCFunction)pyalsahcontrol_elementremove, METH_VARARGS, elementremove__doc__}, - {"elementLock",(PyCFunction)pyalsahcontrol_elementlock, METH_VARARGS, elementlock__doc__}, - {"elementUnlock",(PyCFunction)pyalsahcontrol_elementunlock, METH_VARARGS, elementunlock__doc__}, - {"handleEvents",(PyCFunction)pyalsahcontrol_handleevents, METH_NOARGS, handlevents__doc__}, - {"registerPoll",(PyCFunction)pyalsahcontrol_registerpoll, METH_VARARGS|METH_KEYWORDS, registerpoll__doc__}, + {"element_new", (PyCFunction)pyalsahcontrol_elementnew, METH_VARARGS, elementnew__doc__}, + {"element_remove",(PyCFunction)pyalsahcontrol_elementremove, METH_VARARGS, elementremove__doc__}, + {"element_lock",(PyCFunction)pyalsahcontrol_elementlock, METH_VARARGS, elementlock__doc__}, + {"element_unlock",(PyCFunction)pyalsahcontrol_elementunlock, METH_VARARGS, elementunlock__doc__}, + {"handle_events",(PyCFunction)pyalsahcontrol_handleevents, METH_NOARGS, handlevents__doc__}, + {"register_poll",(PyCFunction)pyalsahcontrol_registerpoll, METH_VARARGS|METH_KEYWORDS, registerpoll__doc__}, {NULL} }; @@ -503,7 +503,7 @@ pyalsahcontrolelement_unlock(struct pyalsahcontrolelement *pyhelem, PyObject *ar } PyDoc_STRVAR(setcallback__doc__, -"setCallback(callObj) -- Set callback object.\n" +"set_callback(callObj) -- Set callback object.\n" "Note: callObj might have callObj.callback attribute.\n"); static PyObject * @@ -631,7 +631,7 @@ static PyMethodDef pyalsahcontrolelement_methods[] = { {"lock", (PyCFunction)pyalsahcontrolelement_lock, METH_NOARGS, elock__doc__}, {"unlock", (PyCFunction)pyalsahcontrolelement_unlock, METH_NOARGS, eunlock__doc__}, - {"setCallback", (PyCFunction)pyalsahcontrolelement_setcallback, METH_VARARGS, setcallback__doc__}, + {"set_callback",(PyCFunction)pyalsahcontrolelement_setcallback, METH_VARARGS, setcallback__doc__}, {NULL} }; @@ -862,16 +862,16 @@ static PyGetSetDef pyalsahcontrolinfo_getseters[] = { {"type", (getter)pyalsahcontrolinfo_uint, NULL, "hcontrol element index", snd_ctl_elem_info_get_type}, - {"isReadable", (getter)pyalsahcontrolinfo_bool, NULL, "hcontrol element is readable", snd_ctl_elem_info_is_readable}, - {"isWritable", (getter)pyalsahcontrolinfo_bool, NULL, "hcontrol element is writable",snd_ctl_elem_info_is_writable}, - {"isVolatile", (getter)pyalsahcontrolinfo_bool, NULL, "hcontrol element is volatile",snd_ctl_elem_info_is_volatile}, - {"isInactive", (getter)pyalsahcontrolinfo_bool, NULL, "hcontrol element is inactive",snd_ctl_elem_info_is_inactive}, - {"isLocked", (getter)pyalsahcontrolinfo_bool, NULL, "hcontrol element is locked",snd_ctl_elem_info_is_locked}, - {"isTlvReadable",(getter)pyalsahcontrolinfo_bool, NULL, "hcontrol element is TLV readable",snd_ctl_elem_info_is_tlv_readable}, - {"isTlvWritable",(getter)pyalsahcontrolinfo_bool, NULL, "hcontrol element is TLV writable",snd_ctl_elem_info_is_tlv_writable}, - {"isTlvCommandable",(getter)pyalsahcontrolinfo_bool, NULL, "hcontrol element is TLV commandable",snd_ctl_elem_info_is_tlv_commandable}, - {"isOwner", (getter)pyalsahcontrolinfo_bool, NULL, "this process is owner of this hcontrol element",snd_ctl_elem_info_is_owner}, - {"isUser", (getter)pyalsahcontrolinfo_bool, NULL, "hcontrol element is user element",snd_ctl_elem_info_is_user}, + {"is_readable", (getter)pyalsahcontrolinfo_bool, NULL, "hcontrol element is readable", snd_ctl_elem_info_is_readable}, + {"is_writable", (getter)pyalsahcontrolinfo_bool, NULL, "hcontrol element is writable",snd_ctl_elem_info_is_writable}, + {"is_volatile", (getter)pyalsahcontrolinfo_bool, NULL, "hcontrol element is volatile",snd_ctl_elem_info_is_volatile}, + {"is_inactive", (getter)pyalsahcontrolinfo_bool, NULL, "hcontrol element is inactive",snd_ctl_elem_info_is_inactive}, + {"is_locked", (getter)pyalsahcontrolinfo_bool, NULL, "hcontrol element is locked",snd_ctl_elem_info_is_locked}, + {"is_tlv_readable",(getter)pyalsahcontrolinfo_bool, NULL, "hcontrol element is TLV readable",snd_ctl_elem_info_is_tlv_readable}, + {"is_tlv_Writable",(getter)pyalsahcontrolinfo_bool, NULL, "hcontrol element is TLV writable",snd_ctl_elem_info_is_tlv_writable}, + {"is_tlv_Commandable",(getter)pyalsahcontrolinfo_bool, NULL, "hcontrol element is TLV commandable",snd_ctl_elem_info_is_tlv_commandable}, + {"is_owner", (getter)pyalsahcontrolinfo_bool, NULL, "this process is owner of this hcontrol element",snd_ctl_elem_info_is_owner}, + {"is_user", (getter)pyalsahcontrolinfo_bool, NULL, "hcontrol element is user element",snd_ctl_elem_info_is_user}, {"owner", (getter)pyalsahcontrolinfo_getowner, NULL, "get owner pid for this hcontrol element", NULL}, {"count", (getter)pyalsahcontrolinfo_uint, NULL, "get count of values", snd_ctl_elem_info_get_count}, @@ -884,7 +884,7 @@ static PyGetSetDef pyalsahcontrolinfo_getseters[] = { {"items", (getter)pyalsahcontrolinfo_getitems, NULL, "get count of enumerated items", NULL}, {"dimensions", (getter)pyalsahcontrolinfo_dimensions, NULL, "get hcontrol element dimensions (in tuple)", NULL}, - {"itemNames", (getter)pyalsahcontrolinfo_itemnames, NULL, "get enumerated item names (in tuple)", NULL}, + {"item_names", (getter)pyalsahcontrolinfo_itemnames, NULL, "get enumerated item names (in tuple)", NULL}, {NULL} }; @@ -956,10 +956,10 @@ pyalsahcontrolvalue_id(struct pyalsahcontrolvalue *pyvalue, void *priv) } PyDoc_STRVAR(gettuple__doc__, -"getTuple(type, count) -- Get hcontrol element values in tuple."); +"get_tuple(type, count) -- Get hcontrol element values in tuple."); PyDoc_STRVAR(getarray__doc__, -"getArray(type, count) -- Get hcontrol element values in array."); +"get_array(type, count) -- Get hcontrol element values in array."); static PyObject * pyalsahcontrolvalue_get1(struct pyalsahcontrolvalue *self, PyObject *args, int list) @@ -1074,10 +1074,10 @@ pyalsahcontrolvalue_getarray(struct pyalsahcontrolvalue *self, PyObject *args) PyDoc_STRVAR(settuple__doc__, -"setTuple(type, val) -- Set hcontrol element values from tuple."); +"set_tuple(type, val) -- Set hcontrol element values from tuple."); PyDoc_STRVAR(setarray__doc__, -"setArray(type, val) -- Set hcontrol element values from array."); +"set_array(type, val) -- Set hcontrol element values from array."); static PyObject * pyalsahcontrolvalue_settuple(struct pyalsahcontrolvalue *self, PyObject *args) @@ -1292,10 +1292,10 @@ static PyGetSetDef pyalsahcontrolvalue_getseters[] = { static PyMethodDef pyalsahcontrolvalue_methods[] = { - {"getTuple", (PyCFunction)pyalsahcontrolvalue_gettuple, METH_VARARGS, gettuple__doc__}, - {"getArray", (PyCFunction)pyalsahcontrolvalue_getarray, METH_VARARGS, getarray__doc__}, - {"setTuple", (PyCFunction)pyalsahcontrolvalue_settuple, METH_VARARGS, settuple__doc__}, - {"setArray", (PyCFunction)pyalsahcontrolvalue_settuple, METH_VARARGS, setarray__doc__}, + {"get_tuple", (PyCFunction)pyalsahcontrolvalue_gettuple, METH_VARARGS, gettuple__doc__}, + {"get_array", (PyCFunction)pyalsahcontrolvalue_getarray, METH_VARARGS, getarray__doc__}, + {"set_tuple", (PyCFunction)pyalsahcontrolvalue_settuple, METH_VARARGS, settuple__doc__}, + {"set_array", (PyCFunction)pyalsahcontrolvalue_settuple, METH_VARARGS, setarray__doc__}, {"read", (PyCFunction)pyalsahcontrolvalue_read, METH_NOARGS, read__doc__}, {"write", (PyCFunction)pyalsahcontrolvalue_write, METH_NOARGS, write__doc__}, @@ -1376,16 +1376,16 @@ initalsahcontrol(void) PyDict_SetItemString(d1, pname, o); \ Py_DECREF(o); } - add_space1("Card", CARD); - add_space1("HwDep", HWDEP); - add_space1("Mixer", MIXER); + add_space1("CARD", CARD); + add_space1("HWDEP", HWDEP); + add_space1("MIXER", MIXER); add_space1("PCM", PCM); - add_space1("RawMidi", RAWMIDI); - add_space1("Timer", TIMER); - add_space1("Sequencer", SEQUENCER); - add_space1("Last", LAST); + add_space1("RAWMIDI", RAWMIDI); + add_space1("TIMER", TIMER); + add_space1("SEQUENCER", SEQUENCER); + add_space1("LAST", LAST); - PyDict_SetItemString(d, "InterfaceId", d1); + PyDict_SetItemString(d, "interface_id", d1); Py_DECREF(d1); /* ---- */ @@ -1398,7 +1398,7 @@ initalsahcontrol(void) Py_DECREF(o); } - PyDict_SetItemString(d, "InterfaceName", l1); + PyDict_SetItemString(d, "interface_name", l1); Py_DECREF(l1); /* ---- */ @@ -1410,16 +1410,16 @@ initalsahcontrol(void) PyDict_SetItemString(d1, pname, o); \ Py_DECREF(o); } - add_space2("None", NONE); - add_space2("Boolean", BOOLEAN); - add_space2("Integer", INTEGER); - add_space2("Enumerated", ENUMERATED); - add_space2("Bytes", BYTES); + add_space2("NONE", NONE); + add_space2("BOOLEAN", BOOLEAN); + add_space2("INTEGER", INTEGER); + add_space2("ENUMERATED", ENUMERATED); + add_space2("BYTES", BYTES); add_space2("IEC958", IEC958); - add_space2("Integer64", INTEGER64); - add_space2("Last", LAST); + add_space2("INTEGER64", INTEGER64); + add_space2("LAST", LAST); - PyDict_SetItemString(d, "ElementType", d1); + PyDict_SetItemString(d, "element_type", d1); Py_DECREF(d1); /* ---- */ @@ -1432,7 +1432,7 @@ initalsahcontrol(void) Py_DECREF(o); } - PyDict_SetItemString(d, "ElementTypeName", l1); + PyDict_SetItemString(d, "element_type_name", l1); Py_DECREF(l1); /* ---- */ @@ -1444,10 +1444,10 @@ initalsahcontrol(void) PyDict_SetItemString(d1, pname, o); \ Py_DECREF(o); } - add_space3("Element", ELEM); - add_space3("Last", LAST); + add_space3("ELEMENT", ELEM); + add_space3("LAST", LAST); - PyDict_SetItemString(d, "EventClass", d1); + PyDict_SetItemString(d, "event_class", d1); Py_DECREF(d1); /* ---- */ @@ -1459,16 +1459,16 @@ initalsahcontrol(void) PyDict_SetItemString(d1, pname, o); \ Py_DECREF(o); } - add_space4("Value", VALUE); - add_space4("Info", INFO); - add_space4("Add", ADD); + add_space4("VALUS", VALUE); + add_space4("INFO", INFO); + add_space4("ADD", ADD); add_space4("TLV", TLV); - PyDict_SetItemString(d, "EventMask", d1); + PyDict_SetItemString(d, "event_mask", d1); Py_DECREF(d1); o = PyInt_FromLong(SND_CTL_EVENT_MASK_REMOVE); - PyDict_SetItemString(d, "EventMaskRemove", o); + PyDict_SetItemString(d, "event_mask_remove", o); Py_DECREF(o); /* ---- */ @@ -1480,11 +1480,11 @@ initalsahcontrol(void) PyDict_SetItemString(d1, pname, o); \ Py_DECREF(o); } - add_space5("NonBlock", NONBLOCK); - add_space5("Async", ASYNC); - add_space5("ReadOnly", READONLY); + add_space5("NONBLOCK", NONBLOCK); + add_space5("ASYNC", ASYNC); + add_space5("READONLY", READONLY); - PyDict_SetItemString(d, "OpenMode", d1); + PyDict_SetItemString(d, "open_mode", d1); Py_DECREF(d1); /* ---- */ diff --git a/pyalsa/alsamixer.c b/pyalsa/alsamixer.c index a2d5097..316d86d 100644 --- a/pyalsa/alsamixer.c +++ b/pyalsa/alsamixer.c @@ -132,7 +132,7 @@ pyalsamixer_free(struct pyalsamixer *self, PyObject *args) } PyDoc_STRVAR(handlevents__doc__, -"handleEvents() -- Process waiting mixer events (and call appropriate callbacks)."); +"handle_events() -- Process waiting mixer events (and call appropriate callbacks)."); static PyObject * pyalsamixer_handleevents(struct pyalsamixer *self, PyObject *args) @@ -149,7 +149,7 @@ pyalsamixer_handleevents(struct pyalsamixer *self, PyObject *args) } PyDoc_STRVAR(registerpoll__doc__, -"registerPoll(pollObj) -- Register poll file descriptors."); +"register_poll(pollObj) -- Register poll file descriptors."); static PyObject * pyalsamixer_registerpoll(struct pyalsamixer *self, PyObject *args) @@ -268,8 +268,8 @@ static PyMethodDef pyalsamixer_methods[] = { {"load", (PyCFunction)pyalsamixer_load, METH_NOARGS, load__doc__}, {"free", (PyCFunction)pyalsamixer_free, METH_NOARGS, free__doc__}, {"list", (PyCFunction)pyalsamixer_list, METH_NOARGS, list__doc__}, - {"handleEvents",(PyCFunction)pyalsamixer_handleevents, METH_NOARGS, handlevents__doc__}, - {"registerPoll",(PyCFunction)pyalsamixer_registerpoll, METH_VARARGS, registerpoll__doc__}, + {"handle_events",(PyCFunction)pyalsamixer_handleevents, METH_NOARGS, handlevents__doc__}, + {"register_poll",(PyCFunction)pyalsamixer_registerpoll, METH_VARARGS, registerpoll__doc__}, {NULL} }; @@ -334,7 +334,7 @@ pyalsamixerelement_getcapgroup(struct pyalsamixerelement *pyelem, void *priv) } PyDoc_STRVAR(ismono__doc__, -"isMono([capture=False]]) -- Return if this control is mono."); +"is_mono([capture=False]]) -- Return if this control is mono."); static PyObject * pyalsamixerelement_ismono(struct pyalsamixerelement *pyelem, PyObject *args) @@ -355,7 +355,7 @@ pyalsamixerelement_ismono(struct pyalsamixerelement *pyelem, PyObject *args) } PyDoc_STRVAR(haschannel__doc__, -"hasChannel([channel=ChannelId['MONO'], [capture=False]]) -- Return if channel exists."); +"has_channel([channel=channel_id['MONO'], [capture=False]]) -- Return if channel exists."); static PyObject * pyalsamixerelement_haschannel(struct pyalsamixerelement *pyelem, PyObject *args) @@ -376,7 +376,7 @@ pyalsamixerelement_haschannel(struct pyalsamixerelement *pyelem, PyObject *args) } PyDoc_STRVAR(hasvolume__doc__, -"hasVolume([capture=False]]) -- Return if volume exists.\n" +"has_volume([capture=False]]) -- Return if volume exists.\n" "Note: String 'Joined' is returned when volume is joined."); static PyObject * @@ -405,7 +405,7 @@ pyalsamixerelement_hasvolume(struct pyalsamixerelement *pyelem, PyObject *args) } PyDoc_STRVAR(hasswitch__doc__, -"hasSwitch([capture=False]) -- Return if switch exists." +"has_switch([capture=False]) -- Return if switch exists." "Note: String 'Joined' is returned when switch is joined."); static PyObject * @@ -434,7 +434,7 @@ pyalsamixerelement_hasswitch(struct pyalsamixerelement *pyelem, PyObject *args) } PyDoc_STRVAR(getvolume__doc__, -"getVolume([channel=ChannelId['MONO'], [capture=False]]) -- Get volume."); +"get_volume([channel=ChannelId['MONO'], [capture=False]]) -- Get volume."); static PyObject * pyalsamixerelement_getvolume(struct pyalsamixerelement *pyelem, PyObject *args) @@ -457,7 +457,7 @@ pyalsamixerelement_getvolume(struct pyalsamixerelement *pyelem, PyObject *args) } PyDoc_STRVAR(getvolumetuple__doc__, -"getVolumeTuple([capture=False]]) -- Get volume and store result to tuple."); +"get_volume_tuple([capture=False]]) -- Get volume and store result to tuple."); static PyObject * pyalsamixerelement_getvolumetuple(struct pyalsamixerelement *pyelem, PyObject *args) @@ -531,7 +531,7 @@ pyalsamixerelement_getvolumetuple(struct pyalsamixerelement *pyelem, PyObject *a } PyDoc_STRVAR(getvolumearray__doc__, -"getVolumeArray([capture=False]]) -- Get volume and store result to array."); +"get_volume_array([capture=False]]) -- Get volume and store result to array."); static PyObject * pyalsamixerelement_getvolumearray(struct pyalsamixerelement *pyelem, PyObject *args) @@ -609,7 +609,7 @@ pyalsamixerelement_getvolumearray(struct pyalsamixerelement *pyelem, PyObject *a } PyDoc_STRVAR(setvolume__doc__, -"setVolume(value, [channel=ChannelId['MONO'], [capture=False]]) -- Set volume."); +"set_volume(value, [channel=ChannelId['MONO'], [capture=False]]) -- Set volume."); static PyObject * pyalsamixerelement_setvolume(struct pyalsamixerelement *pyelem, PyObject *args) @@ -629,10 +629,10 @@ pyalsamixerelement_setvolume(struct pyalsamixerelement *pyelem, PyObject *args) } PyDoc_STRVAR(setvolumetuple__doc__, -"setVolumeTuple(value, [capture=False]]) -- Set volume level from tuple."); +"set_volume_tuple(value, [capture=False]]) -- Set volume level from tuple."); PyDoc_STRVAR(setvolumearray__doc__, -"setVolumeArray(value, [capture=False]]) -- Set volume level from array."); +"set_volume_array(value, [capture=False]]) -- Set volume level from array."); static PyObject * pyalsamixerelement_setvolumetuple(struct pyalsamixerelement *pyelem, PyObject *args) @@ -685,7 +685,7 @@ pyalsamixerelement_setvolumetuple(struct pyalsamixerelement *pyelem, PyObject *a } PyDoc_STRVAR(setvolumeall__doc__, -"setVolumeAll(value, [capture=False]]) -- Set volume for all channels."); +"set_volume_all(value, [capture=False]]) -- Set volume for all channels."); static PyObject * pyalsamixerelement_setvolumeall(struct pyalsamixerelement *pyelem, PyObject *args) @@ -705,7 +705,7 @@ pyalsamixerelement_setvolumeall(struct pyalsamixerelement *pyelem, PyObject *arg } PyDoc_STRVAR(getrange__doc__, -"getVolumeRange([capture=False]]) -- Get volume range in (min,max) tuple."); +"get_volume_range([capture=False]]) -- Get volume range in (min,max) tuple."); static PyObject * pyalsamixerelement_getrange(struct pyalsamixerelement *pyelem, PyObject *args) @@ -731,7 +731,7 @@ pyalsamixerelement_getrange(struct pyalsamixerelement *pyelem, PyObject *args) } PyDoc_STRVAR(setrange__doc__, -"setVolumeRange(min, max, [capture=False]]) -- Set volume range limits."); +"set_volume_range(min, max, [capture=False]]) -- Set volume range limits."); static PyObject * pyalsamixerelement_setrange(struct pyalsamixerelement *pyelem, PyObject *args) @@ -751,7 +751,7 @@ pyalsamixerelement_setrange(struct pyalsamixerelement *pyelem, PyObject *args) } PyDoc_STRVAR(getswitch__doc__, -"getSwitch([channel=ChannelId['MONO'], [capture=False]]) -- Get switch state."); +"get_switch([channel=ChannelId['MONO'], [capture=False]]) -- Get switch state."); static PyObject * pyalsamixerelement_getswitch(struct pyalsamixerelement *pyelem, PyObject *args) @@ -777,7 +777,7 @@ pyalsamixerelement_getswitch(struct pyalsamixerelement *pyelem, PyObject *args) } PyDoc_STRVAR(getswitchtuple__doc__, -"getSwitchTuple([capture=False]]) -- Get switch state and store result to tuple."); +"get_switch_tuple([capture=False]]) -- Get switch state and store result to tuple."); static PyObject * pyalsamixerelement_getswitchtuple(struct pyalsamixerelement *pyelem, PyObject *args) @@ -850,7 +850,7 @@ pyalsamixerelement_getswitchtuple(struct pyalsamixerelement *pyelem, PyObject *a } PyDoc_STRVAR(setswitch__doc__, -"setSwitch(value, [channel=ChannelId['MONO'], [capture=False]]) -- Set switch state."); +"set_switch(value, [channel=ChannelId['MONO'], [capture=False]]) -- Set switch state."); static PyObject * pyalsamixerelement_setswitch(struct pyalsamixerelement *pyelem, PyObject *args) @@ -869,7 +869,7 @@ pyalsamixerelement_setswitch(struct pyalsamixerelement *pyelem, PyObject *args) } PyDoc_STRVAR(setswitchtuple__doc__, -"setSwitchTuple(value, [capture=False]]) -- Set switch state from tuple."); +"set_switch_tuple(value, [capture=False]]) -- Set switch state from tuple."); static PyObject * pyalsamixerelement_setswitchtuple(struct pyalsamixerelement *pyelem, PyObject *args) @@ -898,7 +898,7 @@ pyalsamixerelement_setswitchtuple(struct pyalsamixerelement *pyelem, PyObject *a } PyDoc_STRVAR(setswitchall__doc__, -"setSwitchAll(value, [capture=False]]) -- Set switch for all channels."); +"set_switch_all(value, [capture=False]]) -- Set switch for all channels."); static PyObject * pyalsamixerelement_setswitchall(struct pyalsamixerelement *pyelem, PyObject *args) @@ -917,7 +917,7 @@ pyalsamixerelement_setswitchall(struct pyalsamixerelement *pyelem, PyObject *arg } PyDoc_STRVAR(getvolumedb__doc__, -"getVolume_dB([channel=ChannelId['MONO'], [capture=False]]) -- Get volume in dB."); +"get_volume_dB([channel=ChannelId['MONO'], [capture=False]]) -- Get volume in dB."); static PyObject * pyalsamixerelement_getvolumedb(struct pyalsamixerelement *pyelem, PyObject *args) @@ -940,7 +940,7 @@ pyalsamixerelement_getvolumedb(struct pyalsamixerelement *pyelem, PyObject *args } PyDoc_STRVAR(setvolumedb__doc__, -"setVolume_dB(value, [channel=ChannelId['MONO'], [capture=False], [dir=0]]) -- Set volume in dB."); +"set_volume_dB(value, [channel=ChannelId['MONO'], [capture=False], [dir=0]]) -- Set volume in dB."); static PyObject * pyalsamixerelement_setvolumedb(struct pyalsamixerelement *pyelem, PyObject *args) @@ -960,7 +960,7 @@ pyalsamixerelement_setvolumedb(struct pyalsamixerelement *pyelem, PyObject *args } PyDoc_STRVAR(setvolumealldb__doc__, -"setVolumeAll_dB(value, [[capture=False], [dir=0]]) -- Set volume for all channels in dB."); +"set_volume_all_dB(value, [[capture=False], [dir=0]]) -- Set volume for all channels in dB."); static PyObject * pyalsamixerelement_setvolumealldb(struct pyalsamixerelement *pyelem, PyObject *args) @@ -980,7 +980,7 @@ pyalsamixerelement_setvolumealldb(struct pyalsamixerelement *pyelem, PyObject *a } PyDoc_STRVAR(getrangedb__doc__, -"getVolumeRange_dB([capture=False]]) -- Get volume range in dB in (min,max) tuple."); +"get_volume_range_dB([capture=False]]) -- Get volume range in dB in (min,max) tuple."); static PyObject * pyalsamixerelement_getrangedb(struct pyalsamixerelement *pyelem, PyObject *args) @@ -1006,7 +1006,7 @@ pyalsamixerelement_getrangedb(struct pyalsamixerelement *pyelem, PyObject *args) } PyDoc_STRVAR(setcallback__doc__, -"setCallback(callObj) -- Set callback object.\n" +"set_callback(callObj) -- Set callback object.\n" "Note: callObj might have callObj.callback attribute.\n"); static PyObject * @@ -1094,46 +1094,46 @@ static PyGetSetDef pyalsamixerelement_getseters[] = { {"name", (getter)pyalsamixerelement_getname, NULL, "mixer element name", NULL}, {"index", (getter)pyalsamixerelement_getindex, NULL, "mixer element index", NULL}, - {"isActive", (getter)pyalsamixerelement_bool, NULL, "element is in active status", snd_mixer_selem_is_active}, - {"isEnumerated",(getter)pyalsamixerelement_bool, NULL, "element is enumerated type", snd_mixer_selem_is_enumerated}, - {"hasCommonVolume",(getter)pyalsamixerelement_bool, NULL, "element has common volume control", snd_mixer_selem_has_common_volume}, - {"hasCommonSwitch",(getter)pyalsamixerelement_bool, NULL, "element has common switch control", snd_mixer_selem_has_common_switch}, - {"hasCaptureSwitchExclusive", (getter)pyalsamixerelement_bool, NULL, "element has exclusive capture switch", snd_mixer_selem_has_capture_switch_exclusive}, + {"is_active", (getter)pyalsamixerelement_bool, NULL, "element is in active status", snd_mixer_selem_is_active}, + {"is_enumerated",(getter)pyalsamixerelement_bool, NULL, "element is enumerated type", snd_mixer_selem_is_enumerated}, + {"has_common_volume",(getter)pyalsamixerelement_bool, NULL, "element has common volume control", snd_mixer_selem_has_common_volume}, + {"has_common_switch",(getter)pyalsamixerelement_bool, NULL, "element has common switch control", snd_mixer_selem_has_common_switch}, + {"has_capture_switch_exclusive", (getter)pyalsamixerelement_bool, NULL, "element has exclusive capture switch", snd_mixer_selem_has_capture_switch_exclusive}, - {"getCaptureGroup",(getter)pyalsamixerelement_getcapgroup, NULL, "element get capture group", NULL}, + {"get_capture_group",(getter)pyalsamixerelement_getcapgroup, NULL, "element get capture group", NULL}, {NULL} }; static PyMethodDef pyalsamixerelement_methods[] = { - {"getVolume", (PyCFunction)pyalsamixerelement_getvolume, METH_VARARGS, getvolume__doc__}, - {"getVolumeTuple", (PyCFunction)pyalsamixerelement_getvolumetuple, METH_VARARGS,getvolumetuple__doc__}, - {"getVolumeArray", (PyCFunction)pyalsamixerelement_getvolumearray, METH_VARARGS,getvolumearray__doc__}, - {"setVolume", (PyCFunction)pyalsamixerelement_setvolume, METH_VARARGS, setvolume__doc__}, - {"setVolumeTuple", (PyCFunction)pyalsamixerelement_setvolumetuple, METH_VARARGS,setvolumetuple__doc__}, - {"setVolumeArray", (PyCFunction)pyalsamixerelement_setvolumetuple, METH_VARARGS,setvolumearray__doc__}, - {"setVolumeAll",(PyCFunction)pyalsamixerelement_setvolumeall, METH_VARARGS, setvolumeall__doc__}, - {"getVolumeRange", (PyCFunction)pyalsamixerelement_getrange, METH_VARARGS, getrange__doc__}, - {"setVolumeRange", (PyCFunction)pyalsamixerelement_setrange, METH_VARARGS, setrange__doc__}, - - {"getVolume_dB",(PyCFunction)pyalsamixerelement_getvolumedb, METH_VARARGS, getvolumedb__doc__}, - {"setVolume_dB",(PyCFunction)pyalsamixerelement_setvolumedb, METH_VARARGS, setvolumedb__doc__}, - {"setVolumeAll_dB",(PyCFunction)pyalsamixerelement_setvolumealldb,METH_VARARGS, setvolumealldb__doc__}, - {"getVolumeRange_dB", (PyCFunction)pyalsamixerelement_getrangedb, METH_VARARGS, getrangedb__doc__}, - - {"getSwitch", (PyCFunction)pyalsamixerelement_getswitch, METH_VARARGS, getswitch__doc__}, - {"getSwitchTuple", (PyCFunction)pyalsamixerelement_getswitchtuple, METH_VARARGS,getswitchtuple__doc__}, - {"setSwitch", (PyCFunction)pyalsamixerelement_setswitch, METH_VARARGS, setswitch__doc__}, - {"setSwitchTuple", (PyCFunction)pyalsamixerelement_setswitchtuple, METH_VARARGS,setswitchtuple__doc__}, - {"setSwitchAll",(PyCFunction)pyalsamixerelement_setswitchall, METH_VARARGS, setswitchall__doc__}, - - {"isMono", (PyCFunction)pyalsamixerelement_ismono, METH_VARARGS, ismono__doc__}, - {"hasChannel", (PyCFunction)pyalsamixerelement_haschannel, METH_VARARGS, haschannel__doc__}, - {"hasVolume", (PyCFunction)pyalsamixerelement_hasvolume, METH_VARARGS, hasvolume__doc__}, - {"hasSwitch", (PyCFunction)pyalsamixerelement_hasswitch, METH_VARARGS, hasswitch__doc__}, - - {"setCallback", (PyCFunction)pyalsamixerelement_setcallback, METH_VARARGS, setcallback__doc__}, + {"get_volume", (PyCFunction)pyalsamixerelement_getvolume, METH_VARARGS, getvolume__doc__}, + {"get_volume_tuple", (PyCFunction)pyalsamixerelement_getvolumetuple, METH_VARARGS,getvolumetuple__doc__}, + {"get_volume_array", (PyCFunction)pyalsamixerelement_getvolumearray, METH_VARARGS,getvolumearray__doc__}, + {"set_volume", (PyCFunction)pyalsamixerelement_setvolume, METH_VARARGS, setvolume__doc__}, + {"set_volume_tuple", (PyCFunction)pyalsamixerelement_setvolumetuple, METH_VARARGS,setvolumetuple__doc__}, + {"set_volume_array", (PyCFunction)pyalsamixerelement_setvolumetuple, METH_VARARGS,setvolumearray__doc__}, + {"set_volume_all",(PyCFunction)pyalsamixerelement_setvolumeall, METH_VARARGS, setvolumeall__doc__}, + {"get_volume_range", (PyCFunction)pyalsamixerelement_getrange, METH_VARARGS, getrange__doc__}, + {"set_volume_range", (PyCFunction)pyalsamixerelement_setrange, METH_VARARGS, setrange__doc__}, + + {"get_volume_dB",(PyCFunction)pyalsamixerelement_getvolumedb, METH_VARARGS, getvolumedb__doc__}, + {"set_volume_dB",(PyCFunction)pyalsamixerelement_setvolumedb, METH_VARARGS, setvolumedb__doc__}, + {"set_volume_all_dB",(PyCFunction)pyalsamixerelement_setvolumealldb,METH_VARARGS, setvolumealldb__doc__}, + {"get_volume_range_dB", (PyCFunction)pyalsamixerelement_getrangedb, METH_VARARGS, getrangedb__doc__}, + + {"get_switch", (PyCFunction)pyalsamixerelement_getswitch, METH_VARARGS, getswitch__doc__}, + {"get_switch_tuple", (PyCFunction)pyalsamixerelement_getswitchtuple, METH_VARARGS,getswitchtuple__doc__}, + {"set_switch", (PyCFunction)pyalsamixerelement_setswitch, METH_VARARGS, setswitch__doc__}, + {"set_switch_tuple", (PyCFunction)pyalsamixerelement_setswitchtuple, METH_VARARGS,setswitchtuple__doc__}, + {"set_switch_all",(PyCFunction)pyalsamixerelement_setswitchall, METH_VARARGS, setswitchall__doc__}, + + {"is_mono", (PyCFunction)pyalsamixerelement_ismono, METH_VARARGS, ismono__doc__}, + {"has_channel", (PyCFunction)pyalsamixerelement_haschannel, METH_VARARGS, haschannel__doc__}, + {"has_volume", (PyCFunction)pyalsamixerelement_hasvolume, METH_VARARGS, hasvolume__doc__}, + {"has_switch", (PyCFunction)pyalsamixerelement_hasswitch, METH_VARARGS, hasswitch__doc__}, + + {"set_callback",(PyCFunction)pyalsamixerelement_setcallback, METH_VARARGS, setcallback__doc__}, {NULL} }; @@ -1201,20 +1201,20 @@ initalsamixer(void) PyDict_SetItemString(d1, pname, o); \ Py_DECREF(o); } - add_space1("Unknown", UNKNOWN); - add_space1("FrontLeft", FRONT_LEFT); - add_space1("FrontRight", FRONT_RIGHT); - add_space1("RearLeft", REAR_LEFT); - add_space1("RearRight", REAR_RIGHT); - add_space1("FrontCenter", FRONT_CENTER); - add_space1("Woofer", WOOFER); - add_space1("SideLeft", SIDE_LEFT); - add_space1("SideRight", SIDE_RIGHT); - add_space1("RearCenter", REAR_CENTER); - add_space1("Last", LAST); - add_space1("Mono", MONO); - - PyDict_SetItemString(d, "ChannelId", d1); + add_space1("UNKNOWN", UNKNOWN); + add_space1("FRONT_LEFT", FRONT_LEFT); + add_space1("FRONT_RIGHT", FRONT_RIGHT); + add_space1("REAR_LEFT", REAR_LEFT); + add_space1("REAR_RIGHT", REAR_RIGHT); + add_space1("FRONT_CENTER", FRONT_CENTER); + add_space1("WOOFER", WOOFER); + add_space1("SIDE_LEFT", SIDE_LEFT); + add_space1("SIDE_RIGHT", SIDE_RIGHT); + add_space1("REAR_CENTER", REAR_CENTER); + add_space1("LAST", LAST); + add_space1("MONO", MONO); + + PyDict_SetItemString(d, "channel_id", d1); Py_DECREF(d1); /* ---- */ @@ -1227,7 +1227,7 @@ initalsamixer(void) Py_DECREF(o); } - PyDict_SetItemString(d, "ChannelName", l1); + PyDict_SetItemString(d, "channel_name", l1); Py_DECREF(l1); /* ---- */ @@ -1239,10 +1239,10 @@ initalsamixer(void) PyDict_SetItemString(d1, pname, o); \ Py_DECREF(o); } - add_space2("None", NONE); - add_space2("Basic", BASIC); + add_space2("NONE", NONE); + add_space2("BASIC", BASIC); - PyDict_SetItemString(d, "RegoptAbstract", d1); + PyDict_SetItemString(d, "regopt_abstract", d1); Py_DECREF(d1); /* ---- */ @@ -1254,16 +1254,16 @@ initalsamixer(void) PyDict_SetItemString(d1, pname, o); \ Py_DECREF(o); } - add_space3("Value", VALUE); - add_space3("Info", INFO); - add_space3("Add", ADD); + add_space3("VALUE", VALUE); + add_space3("INFO", INFO); + add_space3("ADD", ADD); add_space3("TLV", TLV); - PyDict_SetItemString(d, "EventMask", d1); + PyDict_SetItemString(d, "event_mask", d1); Py_DECREF(d1); o = PyInt_FromLong(SND_CTL_EVENT_MASK_REMOVE); - PyDict_SetItemString(d, "EventMaskRemove", o); + PyDict_SetItemString(d, "event_mask_remove", o); Py_DECREF(o); /* ---- */ diff --git a/test/cardtest1.py b/test/cardtest1.py index 8c2eba7..5dd389d 100755 --- a/test/cardtest1.py +++ b/test/cardtest1.py @@ -6,11 +6,11 @@ sys.path.insert(0, '../pyalsa') del sys import alsacard -print 'asoundlibVersion:', alsacard.asoundlibVersion() -print 'cardLoad:', alsacard.cardLoad(0) -print 'cardList:', alsacard.cardList() +print 'asoundlibVersion:', alsacard.asoundlib_version() +print 'cardLoad:', alsacard.card_load(0) +print 'cardList:', alsacard.card_list() print 'deviceNameHint for all cards:' -print alsacard.deviceNameHint(-1, "pcm") -for card in alsacard.cardList(): +print alsacard.device_name_hint(-1, "pcm") +for card in alsacard.card_list(): print 'deviceNameHint for card #%i:' % card - print alsacard.deviceNameHint(card, "pcm") + print alsacard.device_name_hint(card, "pcm") diff --git a/test/hctltest1.py b/test/hctltest1.py index d656b78..a169500 100755 --- a/test/hctltest1.py +++ b/test/hctltest1.py @@ -8,13 +8,13 @@ import alsahcontrol def info(element): info = alsahcontrol.Info(element) - enumerated = alsahcontrol.ElementType['Enumerated'] - integer = alsahcontrol.ElementType['Integer'] - integer64 = alsahcontrol.ElementType['Integer64'] + enumerated = alsahcontrol.element_type['ENUMERATED'] + integer = alsahcontrol.element_type['INTEGER'] + integer64 = alsahcontrol.element_type['INTEGER64'] for a in dir(info): if a.startswith('__'): continue - if a in ['items', 'itemNames'] and info.type != enumerated: + if a in ['items', 'item_names'] and info.type != enumerated: continue if a in ['min', 'max', 'step'] and info.type != integer: continue @@ -22,7 +22,7 @@ def info(element): continue extra = '' if a == 'type': - extra = ' (%s)' % alsahcontrol.ElementTypeName[info.type] + extra = ' (%s)' % alsahcontrol.element_type_name[info.type] print ' %s: %s%s' % (a, getattr(info, a), extra) def value(element): @@ -32,28 +32,28 @@ def value(element): if a.startswith('__'): continue print ' %s: %s' % (a, getattr(value, a)) - values = value.getTuple(info.type, info.count) + values = value.get_tuple(info.type, info.count) print ' Values: ', values - value.setTuple(info.type, values) + value.set_tuple(info.type, values) value.read() - if info.isWritable: + if info.is_writable: value.write() -print 'InterfaceId:' -print ' ', alsahcontrol.InterfaceId -print 'InterfaceName:' -print ' ', alsahcontrol.InterfaceName -print 'ElementType:' -print ' ', alsahcontrol.ElementType -print 'ElementTypeName:' -print ' ', alsahcontrol.ElementTypeName -print 'EventClass:' -print ' ', alsahcontrol.EventClass -print 'EventMask:' -print ' ', alsahcontrol.EventMask -print 'EventMaskRemove:', alsahcontrol.EventMaskRemove -print ' ', alsahcontrol.OpenMode -print 'EventMaskRemove:', alsahcontrol.OpenMode +print 'interface_id:' +print ' ', alsahcontrol.interface_id +print 'interface_name:' +print ' ', alsahcontrol.interface_name +print 'element_type:' +print ' ', alsahcontrol.element_type +print 'element_type_name:' +print ' ', alsahcontrol.element_type_name +print 'event_class:' +print ' ', alsahcontrol.event_class +print 'event_mask:' +print ' ', alsahcontrol.event_mask +print 'event_mask_remove:', alsahcontrol.event_mask_remove +print ' ', alsahcontrol.open_mode +print 'event_mask_remove:', alsahcontrol.open_mode hctl = alsahcontrol.HControl() print 'Count: ', hctl.count diff --git a/test/hctltest2.py b/test/hctltest2.py index 7a255a5..b388550 100755 --- a/test/hctltest2.py +++ b/test/hctltest2.py @@ -10,11 +10,11 @@ import alsahcontrol def parse_event_mask(events): if events == 0: return 'None' - if events == alsahcontrol.EventMaskRemove: + if events == alsahcontrol.event_mask_remove: return 'Removed' s = '' - for i in alsahcontrol.EventMask.keys(): - if events & alsahcontrol.EventMask[i]: + for i in alsahcontrol.event_mask.keys(): + if events & alsahcontrol.event_mask[i]: s += '%s ' % i return s[:-1] @@ -23,7 +23,7 @@ def event_callback(element, events): info = alsahcontrol.Info(element) value = alsahcontrol.Value(element) print 'CALLBACK (DEF)! [%s] %s:%i' % (parse_event_mask(events), element.name, element.index) - print ' ', value.getTuple(info.type, info.count) + print ' ', value.get_tuple(info.type, info.count) class MyElementEvent: @@ -32,32 +32,32 @@ class MyElementEvent: info = alsahcontrol.Info(element) value = alsahcontrol.Value(element) print 'CALLBACK (CLASS)! [%s] %s:%i' % (parse_event_mask(events), element.name, element.index) - print ' ', value.getTuple(info.type, info.count) + print ' ', value.get_tuple(info.type, info.count) -hctl = alsahcontrol.HControl(mode=alsahcontrol.OpenMode['NonBlock']) +hctl = alsahcontrol.HControl(mode=alsahcontrol.open_mode['NONBLOCK']) list = hctl.list() element1 = alsahcontrol.Element(hctl, list[0][1:]) -element1.setCallback(event_callback) +element1.set_callback(event_callback) element2 = alsahcontrol.Element(hctl, list[1][1:]) -element2.setCallback(MyElementEvent()) -nelementid = (alsahcontrol.InterfaceId['Mixer'], 0, 0, "Z Test Volume", 1) +element2.set_callback(MyElementEvent()) +nelementid = (alsahcontrol.interface_id['MIXER'], 0, 0, "Z Test Volume", 1) try: - hctl.elementRemove(nelementid) + hctl.element_remove(nelementid) except IOError: pass -hctl.elementNew(alsahcontrol.ElementType['Integer'], +hctl.element_new(alsahcontrol.element_type['INTEGER'], nelementid, 2, 0, 100, 1) -hctl.elementUnlock(nelementid) +hctl.element_unlock(nelementid) # handleEvents() must be here to update internal alsa-lib's element list -hctl.handleEvents() +hctl.handle_events() element3 = alsahcontrol.Element(hctl, nelementid) -element3.setCallback(event_callback) +element3.set_callback(event_callback) print 'Watching (DEF): %s,%i' % (element1.name, element1.index) print 'Watching (CLASS): %s,%i' % (element2.name, element2.index) print 'Watching (DEF): %s,%i' % (element3.name, element3.index) poller = select.poll() -hctl.registerPoll(poller) +hctl.register_poll(poller) while True: poller.poll() print 'Poll OK!' - hctl.handleEvents() + hctl.handle_events() diff --git a/test/mixertest1.py b/test/mixertest1.py index bf8ec1e..4c4f664 100755 --- a/test/mixertest1.py +++ b/test/mixertest1.py @@ -8,46 +8,46 @@ from alsamemdebug import debuginit, debug, debugdone import alsamixer def print_elem(e): - direction = ["Playback", "Capture"] + direction = ["playback", "capture"] print "Mixer Element '%s:%i':" % (e.name, e.index) - print ' isActive: %s' % e.isActive - print ' isEnumerated: %s' % e.isEnumerated - print ' hasCommonVolume: %s' % e.hasCommonVolume - print ' hasCommonSwitch: %s' % e.hasCommonSwitch - print ' hasCaptureSwitchExclusive: %s' % e.hasCaptureSwitchExclusive - if e.hasSwitch(True): - print ' getCaptureGroup: %s' % e.getCaptureGroup + print ' is_active: %s' % e.is_active + print ' is_enumerated: %s' % e.is_enumerated + print ' has_common_volume: %s' % e.has_common_volume + print ' has_common_switch: %s' % e.has_common_switch + print ' has_capture_switch_exclusive: %s' % e.has_capture_switch_exclusive + if e.has_switch(True): + print ' getCaptureGroup: %s' % e.get_capture_group for capture in [False, True]: - print ' is%sMono: %s' % (direction[capture], e.isMono(capture)) - print ' has%sVolume: %s' % (direction[capture], e.hasVolume(capture)) - if e.hasVolume(capture): - print ' get%sVolumeRange: %s' % (direction[capture], e.getVolumeRange(capture)) - print ' get%sVolumeRange_dB: %s' % (direction[capture], e.getVolumeRange_dB(capture)) - print ' get%sVolumeTuple: %s' % (direction[capture], e.getVolumeTuple(capture)) - print ' get%sVolumeArray: %s' % (direction[capture], e.getVolumeArray(capture)) - print ' has%sSwitch: %s' % (direction[capture], e.hasSwitch(capture)) - if e.hasSwitch(capture): - print ' get%sSwitchTuple: %s' % (direction[capture], e.getSwitchTuple(capture)) - for channel in range(alsamixer.ChannelId['Last']+1): - if e.hasChannel(channel, capture): - print ' has%sChannel%s: %s' % (direction[capture], channel, alsamixer.ChannelName[channel]) + print ' is_%s_mono: %s' % (direction[capture], e.is_mono(capture)) + print ' has_%s_volume: %s' % (direction[capture], e.has_volume(capture)) + if e.has_volume(capture): + print ' get_%s_volume_range: %s' % (direction[capture], e.get_volume_range(capture)) + print ' get_%s_volume_range_dB: %s' % (direction[capture], e.get_volume_range_dB(capture)) + print ' get_%s_volume_tuple: %s' % (direction[capture], e.get_volume_tuple(capture)) + print ' get_%s_volume_array: %s' % (direction[capture], e.get_volume_array(capture)) + print ' has_%s_switch: %s' % (direction[capture], e.has_switch(capture)) + if e.has_switch(capture): + print ' get_%s_switch_tuple: %s' % (direction[capture], e.get_switch_tuple(capture)) + for channel in range(alsamixer.channel_id['LAST']+1): + if e.has_channel(channel, capture): + print ' has_%s_channel%s: %s' % (direction[capture], channel, alsamixer.channel_name[channel]) debuginit() -print 'ChannelId:' -print alsamixer.ChannelId +print 'channel_id:' +print alsamixer.channel_id -print 'ChannelName:' -print alsamixer.ChannelName +print 'channel_name:' +print alsamixer.channel_name -print 'RegoptAbstracts:' -print alsamixer.RegoptAbstract +print 'regopt_abstracts:' +print alsamixer.regopt_abstract -print 'EventMask:' -print alsamixer.EventMask +print 'event_mask:' +print alsamixer.event_mask -print 'EventMaskRemove:', alsamixer.EventMaskRemove +print 'event_mask_remove:', alsamixer.event_mask_remove mixer = alsamixer.Mixer() mixer.attach() @@ -56,9 +56,9 @@ print 'Element Count:', mixer.count print 'Elements:' print mixer.list() element = alsamixer.Element(mixer, "PCM") -element.setVolumeArray([128, 128]) +element.set_volume_array([128, 128]) print_elem(element) -element.setVolumeTuple([127, 127]) +element.set_volume_tuple([127, 127]) print_elem(element) print_elem(alsamixer.Element(mixer, "Off-hook"))