~ubuntu-branches/ubuntu/warty/pygame/warty

#ifdef Py_USING_UNICODE

 

static PyObject* our_unichr(long uni)

{

        static PyObject* bltin_unichr = NULL;

 

        if (bltin_unichr == NULL) {

                PyObject* bltins;

 

                bltins = PyImport_ImportModule("__builtin__");

                bltin_unichr = PyObject_GetAttrString(bltins, "unichr");

 

                Py_DECREF(bltins);

        }

 

        return PyEval_CallFunction(bltin_unichr, "(l)", uni);

}

 

static PyObject* our_empty_ustr(void)

{

        static PyObject* empty_ustr = NULL;

 

        if (empty_ustr == NULL) {

                PyObject* bltins;

                PyObject* bltin_unicode;

 

                bltins = PyImport_ImportModule("__builtin__");

                bltin_unicode = PyObject_GetAttrString(bltins, "unicode");

                empty_ustr = PyEval_CallFunction(bltin_unicode, "(s)", "");

 

                Py_DECREF(bltin_unicode);

                Py_DECREF(bltins);

        }

 

        Py_INCREF(empty_ustr);

 

        return empty_ustr;

}

 

#else

 

static PyObject* our_unichr(long uni)

{

        return PyInt_FromLong(uni);

}

 

static PyObject* our_empty_ustr(void)

{

        return PyInt_FromLong(0);

}

 

#endif /* Py_USING_UNICODE */

                        insobj(dict, "unicode", our_unichr(event->key.keysym.unicode));

                        insobj(dict, "unicode", our_empty_ustr());

                if(event->jhat.value&SDL_HAT_RIGHT) hx = 1;

        PyObject_DEL(self);

    /*DOC*/    "objects for a quick display of its type and members.\n" __SECRET_COLON__

static int event_nonzero(PyEventObject *self)

{

        return self->type != SDL_NOEVENT;

}

static PyNumberMethods event_as_number = {

        (binaryfunc)NULL,               /*add*/

        (binaryfunc)NULL,               /*subtract*/

        (binaryfunc)NULL,               /*multiply*/

        (binaryfunc)NULL,               /*divide*/

        (binaryfunc)NULL,               /*remainder*/

        (binaryfunc)NULL,               /*divmod*/

        (ternaryfunc)NULL,              /*power*/

        (unaryfunc)NULL,                /*negative*/

        (unaryfunc)NULL,                /*pos*/

        (unaryfunc)NULL,                /*abs*/

        (inquiry)event_nonzero, /*nonzero*/

        (unaryfunc)NULL,                /*invert*/

        (binaryfunc)NULL,               /*lshift*/

        (binaryfunc)NULL,               /*rshift*/

        (binaryfunc)NULL,               /*and*/

        (binaryfunc)NULL,               /*xor*/

        (binaryfunc)NULL,               /*or*/

        (coercion)NULL,                 /*coerce*/

        (unaryfunc)NULL,                /*int*/

        (unaryfunc)NULL,                /*long*/

        (unaryfunc)NULL,                /*float*/

        (unaryfunc)NULL,                /*oct*/

        (unaryfunc)NULL,                /*hex*/

};

        &event_as_number,               /*as_number*/

        if(!e) return NULL;

        if(event)

        else

        {

                e->type = SDL_NOEVENT;

                e->dict = PyDict_New();

        }

    /*DOC*/    "pygame.event.Event(type, [dict], [keyword_args]) -> Event\n"

    /*DOC*/    "members, you can pass keyword arguments that will become the\n"

    /*DOC*/    "attributes of the new event.\n"

    /*DOC*/    "For each frame of your game, you will need to make some sort\n"

    /*DOC*/    "of call to the event queue. This ensures your program can internally\n"

    /*DOC*/    "interact with the rest of the operating system. If you are not using\n"

    /*DOC*/    "other event functions in your game, you should call pump() to allow\n"

    /*DOC*/    "pygame to handle internal actions.\n"

    /*DOC*/    "\n"

    /*DOC*/    "There are important things that must be dealt with internally in the\n"

    /*DOC*/    "event queue. The main window may need to be repainted. Certain joysticks\n"

    /*DOC*/    "must be polled for their values. If you fail to make a call to the event\n"

    /*DOC*/    "queue for too long, the system may decide your program has locked up.\n"

 

        if(SDL_PollEvent(&event))

                return PyEvent_New(&event);

        return PyEvent_New(NULL);

}

 

 

    /*DOC*/ static char doc_event_clear[] =

    /*DOC*/    "pygame.event.clear([type]) -> None\n"

    /*DOC*/    "remove all of an event type from the queue\n"

    /*DOC*/    "\n"

    /*DOC*/    "Pass this a type of event to discard, and it will\n"

    /*DOC*/    "remove all matching event types from the queue. If no\n"

    /*DOC*/    "types are passed, this will remove all the events from the queue.\n"

    /*DOC*/    "You may also optionally pass a sequence of event types. For\n"

    /*DOC*/    "example, to remove all the mouse motion events from the queue, you\n"

    /*DOC*/    "would call, 'pygame.event.clear(MOUSEMOTION)'.\n"

    /*DOC*/ ;

 

static PyObject* event_clear(PyObject* self, PyObject* args)

{

        SDL_Event event;

        int mask = 0;

        int loop, num;

        PyObject* type;

        int val;

 

        if(PyTuple_Size(args) != 0 && PyTuple_Size(args) != 1)

                return RAISE(PyExc_ValueError, "get requires 0 or 1 argument");

 

        VIDEO_INIT_CHECK();

 

        if(PyTuple_Size(args) == 0)

                mask = SDL_ALLEVENTS;

        else

        {

                type = PyTuple_GET_ITEM(args, 0);

                if(PySequence_Check(type))

                {

                        num = PySequence_Size(type);

                        for(loop=0; loop<num; ++loop)

                        {

                                if(!IntFromObjIndex(type, loop, &val))

                                        return RAISE(PyExc_TypeError, "type sequence must contain valid event types");

                                mask |= SDL_EVENTMASK(val);

                        }

                }

                else if(IntFromObj(type, &val))

                        mask = SDL_EVENTMASK(val);

                else

                        return RAISE(PyExc_TypeError, "get type must be numeric or a sequence");

        }

 

        SDL_PumpEvents();

 

        while(SDL_PeepEvents(&event, 1, SDL_GETEVENT, mask) == 1)

        {}

 

        RETURN_NONE;

}

 

 

    /*DOC*/ static char doc_event_get[] =

static PyObject* event_get(PyObject* self, PyObject* args)

        int val;

                return RAISE(PyExc_ValueError, "get requires 0 or 1 argument");

                                if(!IntFromObjIndex(type, loop, &val))

                else if(IntFromObj(type, &val))

                        return RAISE(PyExc_TypeError, "get type must be numeric or a sequence");

 

    /*DOC*/    "If no types are passed, this will return the next event on the queue\n"

    /*DOC*/    "without removing it. You may also optionally pass a sequence of event\n"

        int loop, num, noargs=0;

        int val;

        {

                noargs=1;

        }

                                if(!IntFromObjIndex(type, loop, &val))

                else if(IntFromObj(type, &val))

 

 

        if(noargs)

                return PyEvent_New(&event);

                return RAISE(PyExc_SDLError, "Event queue full");

        int val;

                        if(!IntFromObjIndex(type, loop, &val))

        else if(IntFromObj(type, &val))

        int val;

                        if(!IntFromObjIndex(type, loop, &val))

        else if(IntFromObj(type, &val))

        int val;

                        if(!IntFromObjIndex(type, loop, &val))

        else if(IntFromObj(type, &val))

        { "clear", event_clear, 1, doc_event_clear },

        { "get", event_get, 1, doc_event_get },