mirror of https://github.com/python/cpython
Removed: not carbon-compatible.
This commit is contained in:
Jack Jansen
parent
0847c5c6c7
commit
b132a39399
|
|
@ -1,609 +0,0 @@
|
|||
/***********************************************************
|
||||
Copyright 1991-1997 by Stichting Mathematisch Centrum, Amsterdam,
|
||||
The Netherlands.
|
||||
|
||||
All Rights Reserved
|
||||
|
||||
Permission to use, copy, modify, and distribute this software and its
|
||||
documentation for any purpose and without fee is hereby granted,
|
||||
provided that the above copyright notice appear in all copies and that
|
||||
both that copyright notice and this permission notice appear in
|
||||
supporting documentation, and that the names of Stichting Mathematisch
|
||||
Centrum or CWI not be used in advertising or publicity pertaining to
|
||||
distribution of the software without specific, written prior permission.
|
||||
|
||||
STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
|
||||
THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
||||
FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
|
||||
FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
|
||||
OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
|
||||
******************************************************************/
|
||||
|
||||
/* Note: This file is partially converted to the new naming standard */
|
||||
/* ctbcm objects */
|
||||
|
||||
|
||||
#include "Python.h"
|
||||
|
||||
#include "macglue.h"
|
||||
|
||||
#include <CommResources.h>
|
||||
#include <Connections.h>
|
||||
#include <CTBUtilities.h>
|
||||
#include <ToolUtils.h>
|
||||
#include <OSUtils.h>
|
||||
|
||||
|
||||
#define _UnimplementedToolTrap 0xA89F
|
||||
#define _CommToolboxTrap 0x8B
|
||||
#define _UnimplementedOSTrap 0x9F
|
||||
|
||||
static char *errornames[] = {
|
||||
"No Error",
|
||||
"Rejected", /* 1 */
|
||||
"Failed", /* 2 */
|
||||
"Timeout", /* 3 */
|
||||
"Not Open", /* 4 */
|
||||
"Not Closed", /* 5 */
|
||||
"No Request Pending", /* 6 */
|
||||
"Not Supported", /* 7 */
|
||||
"No Tools", /* 8 */
|
||||
"User Cancel", /* 9 */
|
||||
"Error 10", /* 10 */
|
||||
"Unknown Error", /* 11 */
|
||||
#define MAX_POS_ERROR 11
|
||||
};
|
||||
|
||||
extern PyObject *PyErr_Mac(PyObject *,int);
|
||||
|
||||
static PyObject *
|
||||
PyCtb_Error(PyObject *errobj, int errcode)
|
||||
{
|
||||
if ( errcode > 0 && errcode <= MAX_POS_ERROR ) {
|
||||
PyErr_SetString(errobj, errornames[errcode]);
|
||||
return NULL;
|
||||
} else {
|
||||
return PyErr_Mac(errobj, errcode);
|
||||
}
|
||||
}
|
||||
|
||||
static PyObject *ErrorObject;
|
||||
|
||||
typedef struct {
|
||||
PyObject_HEAD
|
||||
ConnHandle hdl; /* The handle to the connection */
|
||||
PyObject *callback; /* Python callback routine */
|
||||
int has_callback; /* True if callback not None */
|
||||
int err; /* Error to pass to the callback */
|
||||
} ctbcmobject;
|
||||
|
||||
static PyTypeObject ctbcmtype;
|
||||
|
||||
#define is_ctbcmobject(v) ((v)->ob_type == &ctbcmtype)
|
||||
|
||||
static
|
||||
TrapAvailable(short tNumber, TrapType tType)
|
||||
{
|
||||
short unImplemented;
|
||||
|
||||
if (tType == OSTrap)
|
||||
unImplemented = _UnimplementedOSTrap;
|
||||
else
|
||||
unImplemented = _UnimplementedToolTrap;
|
||||
|
||||
return NGetTrapAddress(tNumber, tType) != NGetTrapAddress(unImplemented, tType);
|
||||
}
|
||||
|
||||
static
|
||||
initialize_ctb()
|
||||
{
|
||||
OSErr err;
|
||||
static initialized = -1;
|
||||
|
||||
if ( initialized >= 0 )
|
||||
return initialized;
|
||||
initialized = 0;
|
||||
|
||||
if ( !TrapAvailable(_CommToolboxTrap, OSTrap) ) {
|
||||
PyErr_SetString(ErrorObject, "CTB not available");
|
||||
return 0;
|
||||
}
|
||||
if ( (err=InitCTBUtilities()) ) {
|
||||
PyCtb_Error(ErrorObject, (int)err);
|
||||
return 0;
|
||||
}
|
||||
if ( (err=InitCRM()) ) {
|
||||
PyCtb_Error(ErrorObject, (int)err);
|
||||
return 0;
|
||||
}
|
||||
if ( (err=InitCM()) ) {
|
||||
PyCtb_Error(ErrorObject, (int)err);
|
||||
return 0;
|
||||
}
|
||||
initialized = 1;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int
|
||||
ctbcm_pycallback(arg)
|
||||
void *arg;
|
||||
{
|
||||
ctbcmobject *self = (ctbcmobject *)arg;
|
||||
PyObject *args, *rv;
|
||||
|
||||
if ( !self->has_callback ) /* It could have been removed in the meantime */
|
||||
return 0;
|
||||
args = Py_BuildValue("(i)", self->err);
|
||||
rv = PyEval_CallObject(self->callback, args);
|
||||
Py_DECREF(args);
|
||||
if( rv == NULL )
|
||||
return -1;
|
||||
Py_DECREF(rv);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*DBG*/int ncallback;
|
||||
static pascal void
|
||||
ctbcm_ctbcallback(hconn)
|
||||
ConnHandle hconn;
|
||||
{
|
||||
ctbcmobject *self;
|
||||
|
||||
/* XXXX Do I have to do the A5 mumbo-jumbo? */
|
||||
ncallback++; /*DBG*/
|
||||
self = (ctbcmobject *)CMGetUserData(hconn);
|
||||
self->err = (int)((*hconn)->errCode);
|
||||
Py_AddPendingCall(ctbcm_pycallback, (void *)self);
|
||||
}
|
||||
|
||||
static ctbcmobject *
|
||||
newctbcmobject(arg)
|
||||
PyObject *arg;
|
||||
{
|
||||
ctbcmobject *self;
|
||||
self = PyObject_NEW(ctbcmobject, &ctbcmtype);
|
||||
if (self == NULL)
|
||||
return NULL;
|
||||
self->hdl = NULL;
|
||||
Py_INCREF(Py_None);
|
||||
self->callback = Py_None;
|
||||
self->has_callback = 0;
|
||||
return self;
|
||||
}
|
||||
|
||||
/* ctbcm methods */
|
||||
|
||||
static void
|
||||
ctbcm_dealloc(self)
|
||||
ctbcmobject *self;
|
||||
{
|
||||
if ( self->hdl ) {
|
||||
(void)CMClose(self->hdl, 0, (ConnectionCompletionUPP)0, 0, 1);
|
||||
/*XXXX Is this safe? */
|
||||
CMDispose(self->hdl);
|
||||
self->hdl = NULL;
|
||||
}
|
||||
PyObject_DEL(self);
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
ctbcm_open(self, args)
|
||||
ctbcmobject *self;
|
||||
PyObject *args;
|
||||
{
|
||||
long timeout;
|
||||
OSErr err;
|
||||
ConnectionCompletionUPP cb_upp = NewConnectionCompletionProc(ctbcm_ctbcallback);
|
||||
|
||||
if (!PyArg_Parse(args, "l", &timeout))
|
||||
return NULL;
|
||||
if ( (err=CMOpen(self->hdl, self->has_callback, cb_upp, timeout)) != 0)
|
||||
return PyCtb_Error(ErrorObject, (int)err);
|
||||
Py_INCREF(Py_None);
|
||||
return Py_None;
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
ctbcm_listen(self, args)
|
||||
ctbcmobject *self;
|
||||
PyObject *args;
|
||||
{
|
||||
long timeout;
|
||||
OSErr err;
|
||||
ConnectionCompletionUPP cb_upp = NewConnectionCompletionProc(ctbcm_ctbcallback);
|
||||
|
||||
if (!PyArg_Parse(args, "l", &timeout))
|
||||
return NULL;
|
||||
if ( (err=CMListen(self->hdl,self->has_callback, cb_upp, timeout)) != 0)
|
||||
return PyCtb_Error(ErrorObject, (int)err);
|
||||
Py_INCREF(Py_None);
|
||||
return Py_None;
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
ctbcm_accept(self, args)
|
||||
ctbcmobject *self;
|
||||
PyObject *args;
|
||||
{
|
||||
int accept;
|
||||
OSErr err;
|
||||
|
||||
if (!PyArg_Parse(args, "i", &accept))
|
||||
return NULL;
|
||||
if ( (err=CMAccept(self->hdl, accept)) != 0)
|
||||
return PyCtb_Error(ErrorObject, (int)err);
|
||||
Py_INCREF(Py_None);
|
||||
return Py_None;
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
ctbcm_close(self, args)
|
||||
ctbcmobject *self;
|
||||
PyObject *args;
|
||||
{
|
||||
int now;
|
||||
long timeout;
|
||||
OSErr err;
|
||||
ConnectionCompletionUPP cb_upp = NewConnectionCompletionProc(ctbcm_ctbcallback);
|
||||
|
||||
if (!PyArg_Parse(args, "(li)", &timeout, &now))
|
||||
return NULL;
|
||||
if ( (err=CMClose(self->hdl, self->has_callback, cb_upp, timeout, now)) != 0)
|
||||
return PyCtb_Error(ErrorObject, (int)err);
|
||||
Py_INCREF(Py_None);
|
||||
return Py_None;
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
ctbcm_read(self, args)
|
||||
ctbcmobject *self;
|
||||
PyObject *args;
|
||||
{
|
||||
long timeout, len;
|
||||
int chan;
|
||||
CMFlags flags;
|
||||
OSErr err;
|
||||
PyObject *rv, *rrv;
|
||||
ConnectionCompletionUPP cb_upp = NewConnectionCompletionProc(ctbcm_ctbcallback);
|
||||
|
||||
if (!PyArg_Parse(args, "(lil)", &len, &chan, &timeout))
|
||||
return NULL;
|
||||
if ((rv=PyString_FromStringAndSize(NULL, len)) == NULL)
|
||||
return NULL;
|
||||
if ((err=CMRead(self->hdl, (Ptr)PyString_AsString(rv), &len, (CMChannel)chan,
|
||||
self->has_callback, cb_upp, timeout, &flags)) != 0 && err != cmTimeOut)
|
||||
return PyCtb_Error(ErrorObject, (int)err);
|
||||
_PyString_Resize(&rv, len);
|
||||
rrv = Py_BuildValue("(Oi)", rv, (int)flags);
|
||||
Py_DECREF(rv);
|
||||
return rrv;
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
ctbcm_write(self, args)
|
||||
ctbcmobject *self;
|
||||
PyObject *args;
|
||||
{
|
||||
long timeout, len;
|
||||
int chan, ilen, flags;
|
||||
OSErr err;
|
||||
char *buf;
|
||||
ConnectionCompletionUPP cb_upp = NewConnectionCompletionProc(ctbcm_ctbcallback);
|
||||
|
||||
if (!PyArg_Parse(args, "(s#ili)", &buf, &ilen, &chan, &timeout, &flags))
|
||||
return NULL;
|
||||
len = ilen;
|
||||
if ((err=CMWrite(self->hdl, (Ptr)buf, &len, (CMChannel)chan,
|
||||
self->has_callback, cb_upp, timeout, (CMFlags)flags)) != 0 && err != cmTimeOut)
|
||||
return PyCtb_Error(ErrorObject, (int)err);
|
||||
return PyInt_FromLong((int)len);
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
ctbcm_status(self, args)
|
||||
ctbcmobject *self;
|
||||
PyObject *args;
|
||||
{
|
||||
CMBufferSizes sizes;
|
||||
CMStatFlags flags;
|
||||
OSErr err;
|
||||
PyObject *rv, *rrv;
|
||||
|
||||
if (!PyArg_NoArgs(args))
|
||||
return NULL;
|
||||
if ((err=CMStatus(self->hdl, sizes, &flags)) != 0)
|
||||
return PyCtb_Error(ErrorObject, (int)err);
|
||||
rv = Py_BuildValue("(llllll)", sizes[0], sizes[1], sizes[2], sizes[3], sizes[4], sizes[5]);
|
||||
if ( rv == NULL )
|
||||
return NULL;
|
||||
rrv = Py_BuildValue("(Ol)", rv, (long)flags);
|
||||
Py_DECREF(rv);
|
||||
return rrv;
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
ctbcm_getconfig(self, args)
|
||||
ctbcmobject *self;
|
||||
PyObject *args;
|
||||
{
|
||||
char *rv;
|
||||
|
||||
if (!PyArg_NoArgs(args))
|
||||
return NULL;
|
||||
if ((rv=(char *)CMGetConfig(self->hdl)) == NULL ) {
|
||||
PyErr_SetString(ErrorObject, "CMGetConfig failed");
|
||||
return NULL;
|
||||
}
|
||||
return PyString_FromString(rv);
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
ctbcm_setconfig(self, args)
|
||||
ctbcmobject *self;
|
||||
PyObject *args;
|
||||
{
|
||||
char *cfg;
|
||||
short rv;
|
||||
|
||||
if (!PyArg_Parse(args, "s", &cfg))
|
||||
return NULL;
|
||||
rv=CMSetConfig(self->hdl, (Ptr)cfg);
|
||||
return PyInt_FromLong((long)rv);
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
ctbcm_choose(self, args)
|
||||
ctbcmobject *self;
|
||||
PyObject *args;
|
||||
{
|
||||
int rv;
|
||||
Point pt;
|
||||
|
||||
if (!PyArg_NoArgs(args))
|
||||
return NULL;
|
||||
pt.v = 40;
|
||||
pt.h = 40;
|
||||
rv=CMChoose(&self->hdl, pt, (ConnectionChooseIdleUPP)0);
|
||||
return PyInt_FromLong(rv);
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
ctbcm_idle(self, args)
|
||||
ctbcmobject *self;
|
||||
PyObject *args;
|
||||
{
|
||||
if (!PyArg_NoArgs(args))
|
||||
return NULL;
|
||||
CMIdle(self->hdl);
|
||||
Py_INCREF(Py_None);
|
||||
return Py_None;
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
ctbcm_abort(self, args)
|
||||
ctbcmobject *self;
|
||||
PyObject *args;
|
||||
{
|
||||
if (!PyArg_NoArgs(args))
|
||||
return NULL;
|
||||
CMAbort(self->hdl);
|
||||
Py_INCREF(Py_None);
|
||||
return Py_None;
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
ctbcm_reset(self, args)
|
||||
ctbcmobject *self;
|
||||
PyObject *args;
|
||||
{
|
||||
if (!PyArg_NoArgs(args))
|
||||
return NULL;
|
||||
CMReset(self->hdl);
|
||||
Py_INCREF(Py_None);
|
||||
return Py_None;
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
ctbcm_break(self, args)
|
||||
ctbcmobject *self;
|
||||
PyObject *args;
|
||||
{
|
||||
long duration;
|
||||
ConnectionCompletionUPP cb_upp = NewConnectionCompletionProc(ctbcm_ctbcallback);
|
||||
|
||||
if (!PyArg_Parse(args, "l", &duration))
|
||||
return NULL;
|
||||
CMBreak(self->hdl, duration,self->has_callback, cb_upp);
|
||||
Py_INCREF(Py_None);
|
||||
return Py_None;
|
||||
}
|
||||
|
||||
static struct PyMethodDef ctbcm_methods[] = {
|
||||
{"Open", (PyCFunction)ctbcm_open},
|
||||
{"Close", (PyCFunction)ctbcm_close},
|
||||
{"Read", (PyCFunction)ctbcm_read},
|
||||
{"Write", (PyCFunction)ctbcm_write},
|
||||
{"Status", (PyCFunction)ctbcm_status},
|
||||
{"GetConfig", (PyCFunction)ctbcm_getconfig},
|
||||
{"SetConfig", (PyCFunction)ctbcm_setconfig},
|
||||
{"Choose", (PyCFunction)ctbcm_choose},
|
||||
{"Idle", (PyCFunction)ctbcm_idle},
|
||||
{"Listen", (PyCFunction)ctbcm_listen},
|
||||
{"Accept", (PyCFunction)ctbcm_accept},
|
||||
{"Abort", (PyCFunction)ctbcm_abort},
|
||||
{"Reset", (PyCFunction)ctbcm_reset},
|
||||
{"Break", (PyCFunction)ctbcm_break},
|
||||
{NULL, NULL} /* sentinel */
|
||||
};
|
||||
|
||||
static PyObject *
|
||||
ctbcm_getattr(self, name)
|
||||
ctbcmobject *self;
|
||||
char *name;
|
||||
{
|
||||
if ( strcmp(name, "callback") == 0 ) {
|
||||
Py_INCREF(self->callback);
|
||||
return self->callback;
|
||||
}
|
||||
return Py_FindMethod(ctbcm_methods, (PyObject *)self, name);
|
||||
}
|
||||
|
||||
static int
|
||||
ctbcm_setattr(self, name, v)
|
||||
ctbcmobject *self;
|
||||
char *name;
|
||||
PyObject *v;
|
||||
{
|
||||
if ( strcmp(name, "callback") != 0 ) {
|
||||
PyErr_SetString(PyExc_AttributeError, "ctbcm objects have callback attr only");
|
||||
return -1;
|
||||
}
|
||||
if ( v == NULL ) {
|
||||
v = Py_None;
|
||||
}
|
||||
Py_INCREF(v);
|
||||
self->callback = v;
|
||||
self->has_callback = (v != Py_None);
|
||||
return 0;
|
||||
}
|
||||
|
||||
statichere PyTypeObject ctbcmtype = {
|
||||
PyObject_HEAD_INIT(&PyType_Type)
|
||||
0, /*ob_size*/
|
||||
"ctb.CTBConnectionMgr", /*tp_name*/
|
||||
sizeof(ctbcmobject), /*tp_basicsize*/
|
||||
0, /*tp_itemsize*/
|
||||
/* methods */
|
||||
(destructor)ctbcm_dealloc, /*tp_dealloc*/
|
||||
0, /*tp_print*/
|
||||
(getattrfunc)ctbcm_getattr, /*tp_getattr*/
|
||||
(setattrfunc)ctbcm_setattr, /*tp_setattr*/
|
||||
0, /*tp_compare*/
|
||||
0, /*tp_repr*/
|
||||
0, /*tp_as_number*/
|
||||
0, /*tp_as_sequence*/
|
||||
0, /*tp_as_mapping*/
|
||||
0, /*tp_hash*/
|
||||
};
|
||||
/* --------------------------------------------------------------------- */
|
||||
|
||||
/* Function of no arguments returning new ctbcm object */
|
||||
|
||||
static PyObject *
|
||||
ctb_cmnew(self, args)
|
||||
PyObject *self; /* Not used */
|
||||
PyObject *args;
|
||||
{
|
||||
int strlen;
|
||||
PyObject *sizes_obj;
|
||||
char *c_str;
|
||||
unsigned char p_str[255];
|
||||
CMBufferSizes sizes;
|
||||
short procid;
|
||||
ConnHandle hdl;
|
||||
ctbcmobject *rv;
|
||||
|
||||
if (!PyArg_Parse(args, "(s#O)", &c_str, &strlen, &sizes_obj))
|
||||
return NULL;
|
||||
strncpy((char *)p_str+1, c_str, strlen);
|
||||
p_str[0] = strlen;
|
||||
if (!initialize_ctb())
|
||||
return NULL;
|
||||
if ( sizes_obj == Py_None ) {
|
||||
memset(sizes, '\0', sizeof sizes);
|
||||
} else {
|
||||
if ( !PyArg_Parse(sizes_obj, "(llllll)", &sizes[0], &sizes[1], &sizes[2],
|
||||
&sizes[3], &sizes[4], &sizes[5]))
|
||||
return NULL;
|
||||
}
|
||||
if ( (procid=CMGetProcID(p_str)) < 0 )
|
||||
return PyCtb_Error(ErrorObject, procid);
|
||||
hdl = CMNew(procid, cmNoMenus|cmQuiet, sizes, 0, 0);
|
||||
if ( hdl == NULL ) {
|
||||
PyErr_SetString(ErrorObject, "CMNew failed");
|
||||
return NULL;
|
||||
}
|
||||
rv = newctbcmobject(args);
|
||||
if ( rv == NULL )
|
||||
return NULL; /* XXXX Should dispose of hdl */
|
||||
rv->hdl = hdl;
|
||||
CMSetUserData(hdl, (long)rv);
|
||||
return (PyObject *)rv;
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
ctb_available(self, args)
|
||||
PyObject *self;
|
||||
PyObject *args;
|
||||
{
|
||||
int ok;
|
||||
|
||||
if (!PyArg_NoArgs(args))
|
||||
return NULL;
|
||||
ok = initialize_ctb();
|
||||
PyErr_Clear();
|
||||
return PyInt_FromLong(ok);
|
||||
}
|
||||
|
||||
/* List of functions defined in the module */
|
||||
|
||||
static struct PyMethodDef ctb_methods[] = {
|
||||
{"CMNew", ctb_cmnew},
|
||||
{"available", ctb_available},
|
||||
{NULL, NULL} /* sentinel */
|
||||
};
|
||||
|
||||
|
||||
/* Initialization function for the module (*must* be called initctb) */
|
||||
|
||||
void
|
||||
initctb()
|
||||
{
|
||||
PyObject *m, *d, *o;
|
||||
|
||||
/* Create the module and add the functions */
|
||||
m = Py_InitModule("ctb", ctb_methods);
|
||||
|
||||
/* Add some symbolic constants to the module */
|
||||
d = PyModule_GetDict(m);
|
||||
|
||||
#define CMCONST(name, value) o = PyInt_FromLong(value); PyDict_SetItemString(d, name, o)
|
||||
|
||||
CMCONST("cmData", 1);
|
||||
CMCONST("cmCntl", 2);
|
||||
CMCONST("cmAttn", 3);
|
||||
|
||||
CMCONST("cmFlagsEOM", 1);
|
||||
|
||||
CMCONST("chooseDisaster", -2);
|
||||
CMCONST("chooseFailed", -1);
|
||||
CMCONST("chooseAborted", 0);
|
||||
CMCONST("chooseOKMinor", 1);
|
||||
CMCONST("chooseOKMajor", 2);
|
||||
CMCONST("chooseCancel", 3);
|
||||
|
||||
CMCONST("cmStatusOpening", 1);
|
||||
CMCONST("cmStatusOpen", 2);
|
||||
CMCONST("cmStatusClosing", 4);
|
||||
CMCONST("cmStatusDataAvail", 8);
|
||||
CMCONST("cmStatusCntlAvail", 0x10);
|
||||
CMCONST("cmStatusAttnAvail", 0x20);
|
||||
CMCONST("cmStatusDRPend", 0x40);
|
||||
CMCONST("cmStatusDWPend", 0x80);
|
||||
CMCONST("cmStatusCWPend", 0x100);
|
||||
CMCONST("cmStatusCWPend", 0x200);
|
||||
CMCONST("cmStatusARPend", 0x400);
|
||||
CMCONST("cmStatusAWPend", 0x800);
|
||||
CMCONST("cmStatusBreakPending", 0x1000);
|
||||
CMCONST("cmStatusListenPend", 0x2000);
|
||||
CMCONST("cmStatusIncomingCallPresent", 0x4000);
|
||||
|
||||
ErrorObject = PyErr_NewException("ctb.error", NULL, NULL);
|
||||
PyDict_SetItemString(d, "error", ErrorObject);
|
||||
ctbcmtype.ob_type = &PyType_Type;
|
||||
Py_INCREF(&ctbcmtype);
|
||||
PyDict_SetItemString(d, "CTBConnectionMgrType", (PyObject *)&ctbcmtype);
|
||||
}
|
||||
|
|
@ -1,546 +0,0 @@
|
|||
/***********************************************************
|
||||
Copyright 1991-1997 by Stichting Mathematisch Centrum, Amsterdam,
|
||||
The Netherlands.
|
||||
|
||||
All Rights Reserved
|
||||
|
||||
Permission to use, copy, modify, and distribute this software and its
|
||||
documentation for any purpose and without fee is hereby granted,
|
||||
provided that the above copyright notice appear in all copies and that
|
||||
both that copyright notice and this permission notice appear in
|
||||
supporting documentation, and that the names of Stichting Mathematisch
|
||||
Centrum or CWI not be used in advertising or publicity pertaining to
|
||||
distribution of the software without specific, written prior permission.
|
||||
|
||||
STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
|
||||
THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
||||
FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
|
||||
FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
|
||||
OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
|
||||
******************************************************************/
|
||||
|
||||
|
||||
#include "Python.h"
|
||||
#include "macglue.h"
|
||||
|
||||
#include <Gestalt.h>
|
||||
#include "Speech.h"
|
||||
|
||||
#ifdef __MWERKS__
|
||||
#define OLDP2C 1
|
||||
#include <TextUtils.h>
|
||||
#ifndef c2pstr
|
||||
#define c2pstr C2PStr
|
||||
#endif
|
||||
#ifndef p2cstr
|
||||
#define p2cstr P2CStr
|
||||
#endif
|
||||
#else
|
||||
#include "pascal.h"
|
||||
#endif /* __MWERKS__ */
|
||||
|
||||
#include <CodeFragments.h>
|
||||
int lib_available;
|
||||
|
||||
/* Somehow the Apple Fix2X and X2Fix don't do what I expect */
|
||||
#define fixed2double(x) (((double)(x))/32768.0)
|
||||
#define double2fixed(x) ((Fixed)((x)*32768.0))
|
||||
|
||||
char *CurrentSpeech;
|
||||
PyObject *ms_error_object;
|
||||
int speech_available;
|
||||
|
||||
static
|
||||
init_available() {
|
||||
OSErr err;
|
||||
long result;
|
||||
|
||||
lib_available = ((ProcPtr)SpeakString != (ProcPtr)0);
|
||||
err = Gestalt(gestaltSpeechAttr, &result);
|
||||
if ( err == noErr && (result & (1<<gestaltSpeechMgrPresent)))
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static
|
||||
check_available() {
|
||||
if ( !speech_available ) {
|
||||
PyErr_SetString(ms_error_object, "Speech Mgr not available");
|
||||
return 0;
|
||||
}
|
||||
if ( !lib_available ) {
|
||||
PyErr_SetString(ms_error_object, "Speech Mgr available, but shared lib missing");
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* -------------
|
||||
**
|
||||
** Part one - the speech channel object
|
||||
*/
|
||||
typedef struct {
|
||||
PyObject_HEAD
|
||||
SpeechChannel chan;
|
||||
PyObject *curtext; /* If non-NULL current text being spoken */
|
||||
} scobject;
|
||||
|
||||
static PyTypeObject sctype;
|
||||
|
||||
#define is_scobject(v) ((v)->ob_type == &sctype)
|
||||
|
||||
static scobject *
|
||||
newscobject(arg)
|
||||
VoiceSpec *arg;
|
||||
{
|
||||
scobject *self;
|
||||
OSErr err;
|
||||
|
||||
self = PyObject_NEW(scobject, &sctype);
|
||||
if (self == NULL)
|
||||
return NULL;
|
||||
if ( (err=NewSpeechChannel(arg, &self->chan)) != 0) {
|
||||
Py_DECREF(self);
|
||||
return (scobject *)PyErr_Mac(ms_error_object, err);
|
||||
}
|
||||
self->curtext = NULL;
|
||||
return self;
|
||||
}
|
||||
|
||||
/* sc methods */
|
||||
|
||||
static void
|
||||
sc_dealloc(self)
|
||||
scobject *self;
|
||||
{
|
||||
DisposeSpeechChannel(self->chan);
|
||||
PyObject_DEL(self);
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
sc_Stop(self, args)
|
||||
scobject *self;
|
||||
PyObject *args;
|
||||
{
|
||||
OSErr err;
|
||||
|
||||
if (!PyArg_NoArgs(args))
|
||||
return NULL;
|
||||
if ((err=StopSpeech(self->chan)) != 0) {
|
||||
PyErr_Mac(ms_error_object, err);
|
||||
return NULL;
|
||||
}
|
||||
if ( self->curtext ) {
|
||||
Py_DECREF(self->curtext);
|
||||
self->curtext = NULL;
|
||||
}
|
||||
Py_INCREF(Py_None);
|
||||
return Py_None;
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
sc_SpeakText(self, args)
|
||||
scobject *self;
|
||||
PyObject *args;
|
||||
{
|
||||
OSErr err;
|
||||
char *str;
|
||||
int len;
|
||||
|
||||
if (!PyArg_Parse(args, "s#", &str, &len))
|
||||
return NULL;
|
||||
if ( self->curtext ) {
|
||||
StopSpeech(self->chan);
|
||||
Py_DECREF(self->curtext);
|
||||
self->curtext = NULL;
|
||||
}
|
||||
if ((err=SpeakText(self->chan, (Ptr)str, (long)len)) != 0) {
|
||||
PyErr_Mac(ms_error_object, err);
|
||||
return 0;
|
||||
}
|
||||
(void)PyArg_Parse(args, "O", &self->curtext); /* Or should I check this? */
|
||||
Py_INCREF(self->curtext);
|
||||
Py_INCREF(Py_None);
|
||||
return Py_None;
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
sc_GetRate(self, args)
|
||||
scobject *self;
|
||||
PyObject *args;
|
||||
{
|
||||
OSErr err;
|
||||
Fixed farg;
|
||||
|
||||
if (!PyArg_NoArgs(args))
|
||||
return NULL;
|
||||
if ((err=GetSpeechRate(self->chan, &farg)) != 0) {
|
||||
PyErr_Mac(ms_error_object, err);
|
||||
return 0;
|
||||
}
|
||||
return PyFloat_FromDouble(fixed2double(farg));
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
sc_GetPitch(self, args)
|
||||
scobject *self;
|
||||
PyObject *args;
|
||||
{
|
||||
OSErr err;
|
||||
Fixed farg;
|
||||
|
||||
if (!PyArg_NoArgs(args))
|
||||
return NULL;
|
||||
if ((err=GetSpeechPitch(self->chan, &farg)) != 0) {
|
||||
PyErr_Mac(ms_error_object, err);
|
||||
return 0;
|
||||
}
|
||||
return PyFloat_FromDouble(fixed2double(farg));
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
sc_SetRate(self, args)
|
||||
scobject *self;
|
||||
PyObject *args;
|
||||
{
|
||||
OSErr err;
|
||||
double darg;
|
||||
|
||||
if (!PyArg_Parse(args, "d", &darg))
|
||||
return NULL;
|
||||
if ((err=SetSpeechRate(self->chan, double2fixed(darg))) != 0) {
|
||||
PyErr_Mac(ms_error_object, err);
|
||||
return 0;
|
||||
}
|
||||
Py_INCREF(Py_None);
|
||||
return Py_None;
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
sc_SetPitch(self, args)
|
||||
scobject *self;
|
||||
PyObject *args;
|
||||
{
|
||||
OSErr err;
|
||||
double darg;
|
||||
|
||||
if (!PyArg_Parse(args, "d", &darg))
|
||||
return NULL;
|
||||
if ((err=SetSpeechPitch(self->chan, double2fixed(darg))) != 0) {
|
||||
PyErr_Mac(ms_error_object, err);
|
||||
return NULL;
|
||||
}
|
||||
Py_INCREF(Py_None);
|
||||
return Py_None;
|
||||
}
|
||||
|
||||
static struct PyMethodDef sc_methods[] = {
|
||||
{"Stop", (PyCFunction)sc_Stop},
|
||||
{"SetRate", (PyCFunction)sc_SetRate},
|
||||
{"GetRate", (PyCFunction)sc_GetRate},
|
||||
{"SetPitch", (PyCFunction)sc_SetPitch},
|
||||
{"GetPitch", (PyCFunction)sc_GetPitch},
|
||||
{"SpeakText", (PyCFunction)sc_SpeakText},
|
||||
{NULL, NULL} /* sentinel */
|
||||
};
|
||||
|
||||
static PyObject *
|
||||
sc_getattr(self, name)
|
||||
scobject *self;
|
||||
char *name;
|
||||
{
|
||||
return Py_FindMethod(sc_methods, (PyObject *)self, name);
|
||||
}
|
||||
|
||||
static PyTypeObject sctype = {
|
||||
PyObject_HEAD_INIT(&PyType_Type)
|
||||
0, /*ob_size*/
|
||||
"macspeech.MacSpeechChannel", /*tp_name*/
|
||||
sizeof(scobject), /*tp_basicsize*/
|
||||
0, /*tp_itemsize*/
|
||||
/* methods */
|
||||
(destructor)sc_dealloc, /*tp_dealloc*/
|
||||
0, /*tp_print*/
|
||||
(getattrfunc)sc_getattr, /*tp_getattr*/
|
||||
0, /*tp_setattr*/
|
||||
0, /*tp_compare*/
|
||||
0, /*tp_repr*/
|
||||
0, /*tp_as_number*/
|
||||
0, /*tp_as_sequence*/
|
||||
0, /*tp_as_mapping*/
|
||||
0, /*tp_hash*/
|
||||
};
|
||||
|
||||
/* -------------
|
||||
**
|
||||
** Part two - the voice object
|
||||
*/
|
||||
typedef struct {
|
||||
PyObject_HEAD
|
||||
int initialized;
|
||||
VoiceSpec vs;
|
||||
VoiceDescription vd;
|
||||
} mvobject;
|
||||
|
||||
static PyTypeObject mvtype;
|
||||
|
||||
#define is_mvobject(v) ((v)->ob_type == &mvtype)
|
||||
|
||||
static mvobject *
|
||||
newmvobject()
|
||||
{
|
||||
mvobject *self;
|
||||
self = PyObject_NEW(mvobject, &mvtype);
|
||||
if (self == NULL)
|
||||
return NULL;
|
||||
self->initialized = 0;
|
||||
return self;
|
||||
}
|
||||
|
||||
static int
|
||||
initmvobject(self, ind)
|
||||
mvobject *self;
|
||||
int ind;
|
||||
{
|
||||
OSErr err;
|
||||
|
||||
if ( (err=GetIndVoice((short)ind, &self->vs)) != 0 ) {
|
||||
PyErr_Mac(ms_error_object, err);
|
||||
return 0;
|
||||
}
|
||||
if ( (err=GetVoiceDescription(&self->vs, &self->vd, sizeof self->vd)) != 0) {
|
||||
PyErr_Mac(ms_error_object, err);
|
||||
return 0;
|
||||
}
|
||||
self->initialized = 1;
|
||||
return 1;
|
||||
}
|
||||
/* mv methods */
|
||||
|
||||
static void
|
||||
mv_dealloc(self)
|
||||
mvobject *self;
|
||||
{
|
||||
PyObject_DEL(self);
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
mv_getgender(self, args)
|
||||
mvobject *self;
|
||||
PyObject *args;
|
||||
{
|
||||
PyObject *rv;
|
||||
|
||||
if (!PyArg_NoArgs(args))
|
||||
return NULL;
|
||||
if (!self->initialized) {
|
||||
PyErr_SetString(ms_error_object, "Uninitialized voice");
|
||||
return NULL;
|
||||
}
|
||||
rv = PyInt_FromLong(self->vd.gender);
|
||||
return rv;
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
mv_newchannel(self, args)
|
||||
mvobject *self;
|
||||
PyObject *args;
|
||||
{
|
||||
if (!PyArg_NoArgs(args))
|
||||
return NULL;
|
||||
if (!self->initialized) {
|
||||
PyErr_SetString(ms_error_object, "Uninitialized voice");
|
||||
return NULL;
|
||||
}
|
||||
return (PyObject *)newscobject(&self->vs);
|
||||
}
|
||||
|
||||
static struct PyMethodDef mv_methods[] = {
|
||||
{"GetGender", (PyCFunction)mv_getgender},
|
||||
{"NewChannel", (PyCFunction)mv_newchannel},
|
||||
{NULL, NULL} /* sentinel */
|
||||
};
|
||||
|
||||
static PyObject *
|
||||
mv_getattr(self, name)
|
||||
mvobject *self;
|
||||
char *name;
|
||||
{
|
||||
return Py_FindMethod(mv_methods, (PyObject *)self, name);
|
||||
}
|
||||
|
||||
static PyTypeObject mvtype = {
|
||||
PyObject_HEAD_INIT(&PyType_Type)
|
||||
0, /*ob_size*/
|
||||
"macspeech.MacVoice", /*tp_name*/
|
||||
sizeof(mvobject), /*tp_basicsize*/
|
||||
0, /*tp_itemsize*/
|
||||
/* methods */
|
||||
(destructor)mv_dealloc, /*tp_dealloc*/
|
||||
0, /*tp_print*/
|
||||
(getattrfunc)mv_getattr, /*tp_getattr*/
|
||||
0, /*tp_setattr*/
|
||||
0, /*tp_compare*/
|
||||
0, /*tp_repr*/
|
||||
0, /*tp_as_number*/
|
||||
0, /*tp_as_sequence*/
|
||||
0, /*tp_as_mapping*/
|
||||
0, /*tp_hash*/
|
||||
};
|
||||
|
||||
|
||||
/* -------------
|
||||
**
|
||||
** Part three - The module interface
|
||||
*/
|
||||
|
||||
/* See if Speech manager available */
|
||||
|
||||
static PyObject *
|
||||
ms_Available(self, args)
|
||||
PyObject *self; /* Not used */
|
||||
PyObject *args;
|
||||
{
|
||||
|
||||
if (!PyArg_NoArgs(args))
|
||||
return NULL;
|
||||
return PyInt_FromLong(speech_available);
|
||||
}
|
||||
|
||||
/* Count number of busy speeches */
|
||||
|
||||
static PyObject *
|
||||
ms_Busy(self, args)
|
||||
PyObject *self; /* Not used */
|
||||
PyObject *args;
|
||||
{
|
||||
short result;
|
||||
|
||||
if (!PyArg_NoArgs(args))
|
||||
return NULL;
|
||||
if ( !check_available() )
|
||||
return NULL;
|
||||
result = SpeechBusy();
|
||||
return PyInt_FromLong(result);
|
||||
}
|
||||
|
||||
/* Say something */
|
||||
|
||||
static PyObject *
|
||||
ms_SpeakString(self, args)
|
||||
PyObject *self; /* Not used */
|
||||
PyObject *args;
|
||||
{
|
||||
OSErr err;
|
||||
char *str;
|
||||
int len;
|
||||
|
||||
if (!PyArg_Parse(args, "s", &str))
|
||||
return NULL;
|
||||
if ( !check_available())
|
||||
return NULL;
|
||||
if (CurrentSpeech) {
|
||||
/* Free the old speech, after killing it off
|
||||
** (note that speach is async and c2pstr works inplace)
|
||||
*/
|
||||
SpeakString("\p");
|
||||
free(CurrentSpeech);
|
||||
}
|
||||
len = strlen(str);
|
||||
CurrentSpeech = malloc(len+1);
|
||||
strcpy(CurrentSpeech, str);
|
||||
err = SpeakString(c2pstr(CurrentSpeech));
|
||||
if ( err ) {
|
||||
PyErr_Mac(ms_error_object, err);
|
||||
return NULL;
|
||||
}
|
||||
Py_INCREF(Py_None);
|
||||
return Py_None;
|
||||
}
|
||||
|
||||
|
||||
/* Count number of available voices */
|
||||
|
||||
static PyObject *
|
||||
ms_CountVoices(self, args)
|
||||
PyObject *self; /* Not used */
|
||||
PyObject *args;
|
||||
{
|
||||
short result;
|
||||
|
||||
if (!PyArg_NoArgs(args))
|
||||
return NULL;
|
||||
if ( !check_available())
|
||||
return NULL;
|
||||
CountVoices(&result);
|
||||
return PyInt_FromLong(result);
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
ms_GetIndVoice(self, args)
|
||||
PyObject *self; /* Not used */
|
||||
PyObject *args;
|
||||
{
|
||||
mvobject *rv;
|
||||
long ind;
|
||||
|
||||
if( !PyArg_Parse(args, "i", &ind))
|
||||
return NULL;
|
||||
if ( !check_available() )
|
||||
return NULL;
|
||||
rv = newmvobject();
|
||||
if ( !initmvobject(rv, ind) ) {
|
||||
Py_DECREF(rv);
|
||||
return NULL;
|
||||
}
|
||||
return (PyObject *)rv;
|
||||
}
|
||||
|
||||
|
||||
static PyObject *
|
||||
ms_Version(self, args)
|
||||
PyObject *self; /* Not used */
|
||||
PyObject *args;
|
||||
{
|
||||
NumVersion v;
|
||||
|
||||
if (!PyArg_NoArgs(args))
|
||||
return NULL;
|
||||
if ( !check_available())
|
||||
return NULL;
|
||||
v = SpeechManagerVersion();
|
||||
return PyInt_FromLong(*(int *)&v);
|
||||
}
|
||||
|
||||
|
||||
/* List of functions defined in the module */
|
||||
|
||||
static struct PyMethodDef ms_methods[] = {
|
||||
{"Available", ms_Available},
|
||||
{"CountVoices", ms_CountVoices},
|
||||
{"Busy", ms_Busy},
|
||||
{"SpeakString", ms_SpeakString},
|
||||
{"GetIndVoice", ms_GetIndVoice},
|
||||
{"Version", ms_Version},
|
||||
{NULL, NULL} /* sentinel */
|
||||
};
|
||||
|
||||
/* Initialization function for the module (*must* be called initmacspeech) */
|
||||
|
||||
void
|
||||
initmacspeech()
|
||||
{
|
||||
PyObject *m, *d;
|
||||
|
||||
speech_available = init_available();
|
||||
/* Create the module and add the functions */
|
||||
m = Py_InitModule("macspeech", ms_methods);
|
||||
|
||||
/* Add some symbolic constants to the module */
|
||||
d = PyModule_GetDict(m);
|
||||
ms_error_object = PyErr_NewException("macspeech.error", NULL, NULL);
|
||||
PyDict_SetItemString(d, "error", ms_error_object);
|
||||
}
|
||||
Loading…
Reference in New Issue