int nx_kbdin(NXHANDLE handle, uint8_t nch, FAR const uint8_t *ch) { FAR struct nxfe_conn_s *conn = (FAR struct nxfe_conn_s *)handle; FAR struct nxsvrmsg_kbdin_s *outmsg; int size; int ret; int i; /* Allocate a bigger message to account for the variable amount of character * data. */ size = sizeof(struct nxsvrmsg_kbdin_s) + nch - 1; outmsg = (FAR struct nxsvrmsg_kbdin_s *)kmalloc(size); if (!outmsg) { errno = ENOMEM; return ERROR; } /* Inform the server of the new keypad data */ outmsg->msgid = NX_SVRMSG_KBDIN; outmsg->nch = nch; for (i = 0; i < nch; i++) { outmsg->ch[i] = ch[i]; } ret = nxmu_sendserver(conn, outmsg, size); kfree(outmsg); return ret; }
int nxmu_sendwindow(FAR struct nxbe_window_s *wnd, FAR const void *msg, size_t msglen) { int ret = OK; /* Sanity checking */ #ifdef CONFIG_DEBUG if (!wnd || !wnd->conn) { set_errno(EINVAL); return ERROR; } #endif /* Ignore messages destined to a blocked window (no errors reported) */ if (!NXBE_ISBLOCKED(wnd)) { /* Send the message to the server */ ret = nxmu_sendserver(wnd->conn, msg, msglen); } return ret; }
int nx_closewindow(NXWINDOW hwnd) { FAR struct nxbe_window_s *wnd = (FAR struct nxbe_window_s *)hwnd; struct nxsvrmsg_closewindow_s outmsg; /* Request destruction of the window by the server */ outmsg.msgid = NX_SVRMSG_CLOSEWINDOW; outmsg.wnd = wnd; return nxmu_sendserver(wnd->conn, &outmsg, sizeof(struct nxsvrmsg_closewindow_s)); }
int nx_mousein(NXHANDLE handle, nxgl_coord_t x, nxgl_coord_t y, uint8_t buttons) { FAR struct nxfe_conn_s *conn = (FAR struct nxfe_conn_s *)handle; struct nxsvrmsg_mousein_s outmsg; /* Inform the server that this client no longer exists */ outmsg.msgid = NX_SVRMSG_MOUSEIN; outmsg.pt.x = x; outmsg.pt.y = y; outmsg.buttons = buttons; return nxmu_sendserver(conn, &outmsg, sizeof(struct nxsvrmsg_mousein_s)); }
void nx_disconnect(NXHANDLE handle) { FAR struct nxfe_conn_s *conn = (FAR struct nxfe_conn_s *)handle; struct nxsvrmsg_s outmsg; int ret; /* Inform the server that this client no longer exists */ outmsg.msgid = NX_SVRMSG_DISCONNECT; outmsg.conn = conn; /* We will finish the teardown upon receipt of the DISCONNECTED message */ ret = nxmu_sendserver(conn, &outmsg, sizeof(struct nxsvrmsg_s)); if (ret < 0) { gdbg("ERROR: nxmu_sendserver() returned %d\n", ret); } }
int nx_block(NXWINDOW hwnd, FAR void *arg) { FAR struct nxbe_window_s *wnd = (FAR struct nxbe_window_s *)hwnd; struct nxsvrmsg_blocked_s outmsg; int ret = OK; #ifdef CONFIG_DEBUG if (!hwnd) { set_errno(EINVAL); return ERROR; } #endif /* Ignore additional attempts to block messages (no errors reported) */ if (!NXBE_ISBLOCKED(wnd)) { /* Mark the window as blocked. This will stop all messages to the window * (EXCEPT the NX_SVRMSG_BLOCKED). Blocking the messages before sending the * blocked message is awkward but assures that no other messages sneak into * the message queue before we can set the blocked state. */ NXBE_SETBLOCKED(wnd); /* Send the message inicating that the window is blocked (and because of * queue also that there are no additional queue messages for the window) */ outmsg.msgid = NX_SVRMSG_BLOCKED; outmsg.wnd = wnd; outmsg.arg = arg; /* Send the window message via nxmu_sendserver (vs. nxmu_sendwindow) so * that it will not be blocked. */ ret = nxmu_sendserver(wnd->conn, &outmsg, sizeof(struct nxsvrmsg_blocked_s)); } return ret; }
int nx_setbgcolor(NXHANDLE handle, nxgl_mxpixel_t color[CONFIG_NX_NPLANES]) { FAR struct nxfe_conn_s *conn = (FAR struct nxfe_conn_s *)handle; struct nxsvrmsg_setbgcolor_s outmsg; #ifdef CONFIG_DEBUG if (!conn) { errno = EINVAL; return ERROR; } #endif /* Format the fill command */ outmsg.msgid = NX_SVRMSG_SETBGCOLOR; nxgl_colorcopy(outmsg.color, color); /* Forward the fill command to the server */ return nxmu_sendserver(conn, &outmsg, sizeof(struct nxsvrmsg_setbgcolor_s)); }
NXHANDLE nx_connectinstance(FAR const char *svrmqname) { FAR struct nxfe_conn_s *conn; struct nxsvrmsg_s outmsg; char climqname[NX_CLIENT_MXNAMELEN]; struct mq_attr attr; int ret; /* Sanity checking */ #ifdef CONFIG_DEBUG_FEATURES if (!svrmqname) { set_errno(EINVAL); return NULL; } #endif /* Allocate the NX client structure */ conn = (FAR struct nxfe_conn_s *)lib_uzalloc(sizeof(struct nxfe_conn_s)); if (!conn) { set_errno(ENOMEM); goto errout; } /* Create the client MQ name */ nxmu_semtake(&g_nxlibsem); conn->cid = g_nxcid++; nxmu_semgive(&g_nxlibsem); sprintf(climqname, NX_CLIENT_MQNAMEFMT, conn->cid); /* Open the client MQ for reading */ attr.mq_maxmsg = CONFIG_NX_MXCLIENTMSGS; attr.mq_msgsize = NX_MXCLIMSGLEN; attr.mq_flags = 0; #ifdef CONFIG_NX_BLOCKING conn->crdmq = mq_open(climqname, O_RDONLY|O_CREAT, 0666, &attr); #else conn->crdmq = mq_open(climqname, O_RDONLY|O_CREAT|O_NONBLOCK, 0666, &attr); #endif if (conn->crdmq == (mqd_t)-1) { gerr("ERROR: mq_open(%s) failed: %d\n", climqname, errno); goto errout_with_conn; } /* Open the server MQ for writing */ attr.mq_maxmsg = CONFIG_NX_MXSERVERMSGS; attr.mq_msgsize = NX_MXSVRMSGLEN; attr.mq_flags = 0; conn->cwrmq = mq_open(svrmqname, O_WRONLY|O_CREAT, 0666, &attr); if (conn->cwrmq == (mqd_t)-1) { gerr("ERROR: mq_open(%s) failed: %d\n", svrmqname, errno); goto errout_with_rmq; } /* Inform the server that this client exists */ outmsg.msgid = NX_SVRMSG_CONNECT; outmsg.conn = conn; ret = nxmu_sendserver(conn, &outmsg, sizeof(struct nxsvrmsg_s)); if (ret < 0) { gerr("ERROR: nxmu_sendserver failed: %d\n", errno); goto errout_with_wmq; } #if 0 /* Now read until we get a response to this message. The server will * respond with either (1) NX_CLIMSG_CONNECTED, in which case the state * will change to NX_CLISTATE_CONNECTED, or (2) NX_CLIMSG_DISCONNECTED * in which case, nx_message will fail with errno = EHOSTDOWN. */ do { ret = nx_eventhandler((NXHANDLE)conn); if (ret < 0) { gerr("ERROR: nx_message failed: %d\n", errno); goto errout_with_wmq; } usleep(300000); } while (conn->state != NX_CLISTATE_CONNECTED); #endif return (NXHANDLE)conn; errout_with_wmq: mq_close(conn->cwrmq); errout_with_rmq: mq_close(conn->crdmq); errout_with_conn: lib_ufree(conn); errout: return NULL; }