dispatch.cc

QNX实时操作系统里的GUI是c格式的

#include <unistd.h>
#include <sys/neutrino.h>

#include <cerrno>
#include <cstring>

#include <iostream>
using namespace std;


#include <photon/PtProto.h>

#include "photonmm/Dispatch.h"


// namespace PtApp {


        static int chid;
        static pid_t pid;

        static PtInputId_t* input_id = 0;

        int coid = -1;


        struct Msg {
                size_t msg_len;
                void* msg;
        };


#ifdef NDISPATCH_USE_MESSAGE
        void
        Dispatcher::connect (const SigC::Slot0<void>& slot  ) 
        {
                Msg m;

                m.msg_len = sizeof (SigC::Slot0<void>);
                m.msg = calloc (1, m.msg_len);

                int len = offsetof (struct Msg, msg) + m.msg_len;

                memcpy (m.msg, &slot, m.msg_len);

                if (MsgSend (coid, &m, len, 0, 0) == -1  ) {


                }
        }
#else
        void
        Dispatcher::send    (Dispatcher_Message*      msg   )
        {
                Msg m;

                m.msg_len = sizeof (Dispatcher_Message*); // 4
                m.msg = calloc (1, m.msg_len);

                int len = offsetof (struct Msg, msg) + m.msg_len;

                memcpy (m.msg, &msg , m.msg_len);

                if (MsgSend (coid, &m, len, 0, 0) == -1  ) {


                }
		
		
		
		
        }


#endif

        int 
        Dispatcher::count = 0;


        static int proc (void* not_used, int rcvid, void* msg, size_t msglen)
        {
                Msg* incoming = (Msg*) msg;
                Msg hdr;
        
                unsigned int msg_offset = offsetof(struct Msg, msg);
        
                unsigned int incoming_len;

                if (msglen < msg_offset) {

                        if (-1 == MsgRead (rcvid, &hdr, msg_offset, 0) ) {
                                MsgError (rcvid, errno);
                                return Pt_HALT;
                        }

                        incoming = &hdr;
                }

                incoming_len = msg_offset + incoming->msg_len;

                if (msglen < incoming_len) {
                
                        struct Msg *ptr = (struct Msg*) alloca (incoming_len);

                        if (ptr == NULL 
                            || MsgRead (rcvid, ptr, incoming_len, 0) == -1) {

                                MsgError (rcvid, errno);
                                return Pt_HALT;
                        }
                
                        incoming = ptr;
                }

                MsgReply (rcvid, 0, 0, 0); // unblock
		
#ifdef NDISPATCH_USE_MESSAGE
                SigC::Slot0<void> incoming_msg;
                memcpy (&incoming_msg, incoming->msg, sizeof (SigC::Slot0<void>  )  );

                incoming_msg ();




#else
                Dispatcher_Message* user_msg;
                memcpy (&user_msg, incoming->msg, 4);

                user_msg->operator () (); // XXX

#endif // NDISPATCH_USE_MESSAGE

                free (incoming->msg );

                return Pt_HALT;
        }


        Dispatcher::Dispatcher ()
        {
                if (count++ == 0  ) {
                        if (-1 == (chid = PtChannelCreate ()  )  ) {

                        }

                        pid = getpid ();

                        if (NULL == (input_id = PtAppAddInput (NULL, 0, proc, NULL)  )  ) {

                                cerr<<"Warning: PtAppAddInput: error occurs\n";

                        }

                        if (coid == -1  ) {
                                coid = ConnectAttach (0, pid, chid, _NTO_SIDE_CHANNEL, 0);

                                if (coid == -1  ) {

                                        cerr<<"ConnectAttach: " << strerror (errno) << "\n";

                                        exit (2  ); // XXX

                                }


                        }
                }
        }


        Dispatcher::~Dispatcher ()
        {
                count--;
                if (count == 0  )
                        PtAppRemoveInput (NULL, input_id);

        }


// } // namespace PtApp