540 lines
15 KiB
C
540 lines
15 KiB
C
/****************************************************************************
|
|
* examples/pwlines/pwlines_main.c
|
|
*
|
|
* Copyright (C) 2019 Gregory Nutt. All rights reserved.
|
|
* Author: Gregory Nutt <gnutt@nuttx.org>
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in
|
|
* the documentation and/or other materials provided with the
|
|
* distribution.
|
|
* 3. Neither the name NuttX nor the names of its contributors may be
|
|
* used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
|
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
|
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
|
|
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
|
|
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
|
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* Included Files
|
|
****************************************************************************/
|
|
|
|
#include <nuttx/config.h>
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/boardctl.h>
|
|
|
|
#include <stdint.h>
|
|
#include <stdbool.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <string.h>
|
|
#include <sched.h>
|
|
#include <pthread.h>
|
|
#include <fixedmath.h>
|
|
#include <errno.h>
|
|
#include <debug.h>
|
|
|
|
#include <nuttx/arch.h>
|
|
#include <nuttx/board.h>
|
|
|
|
#include <nuttx/nx/nx.h>
|
|
#include <nuttx/nx/nxtk.h>
|
|
#include <nuttx/nx/nxbe.h>
|
|
|
|
#include "pwlines_internal.h"
|
|
|
|
/****************************************************************************
|
|
* Private Functions
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* Name: pwlines_server_initialize
|
|
****************************************************************************/
|
|
|
|
static bool pwlines_server_initialize(FAR struct pwlines_state_s *st)
|
|
{
|
|
struct sched_param param;
|
|
int ret;
|
|
|
|
/* Set the client task priority */
|
|
|
|
param.sched_priority = CONFIG_EXAMPLES_PWLINES_CLIENT_PRIO;
|
|
ret = sched_setparam(0, ¶m);
|
|
if (ret < 0)
|
|
{
|
|
printf("pwlines_server_initialize: ERROR: "
|
|
"sched_setparam failed: %d\n" ,
|
|
ret);
|
|
return false;
|
|
}
|
|
|
|
/* Start the NX server kernel thread */
|
|
|
|
ret = boardctl(BOARDIOC_NX_START, 0);
|
|
if (ret < 0)
|
|
{
|
|
printf("pwlines_server_initialize: ERROR: "
|
|
"Failed to start the NX server: %d\n",
|
|
errno);
|
|
return false;
|
|
}
|
|
|
|
/* Connect to the server */
|
|
|
|
st->hnx = nx_connect();
|
|
if (st->hnx)
|
|
{
|
|
#ifdef CONFIG_VNCSERVER
|
|
/* Setup the VNC server to support keyboard/mouse inputs */
|
|
|
|
struct boardioc_vncstart_s vnc =
|
|
{
|
|
0, st->hnx
|
|
};
|
|
|
|
ret = boardctl(BOARDIOC_VNC_START, (uintptr_t)&vnc);
|
|
if (ret < 0)
|
|
{
|
|
printf("pwlines_server_initialize: ERROR: "
|
|
"boardctl(BOARDIOC_VNC_START) failed: %d\n",
|
|
ret);
|
|
|
|
nx_disconnect(st->hnx);
|
|
return false;
|
|
}
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
printf("pwlines_server_initialize: ERROR: "
|
|
"nx_connect failed: %d\n",
|
|
errno);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: pwlines_listener_initialize
|
|
****************************************************************************/
|
|
|
|
static bool pwlines_listener_initialize(FAR struct pwlines_state_s *st)
|
|
{
|
|
struct sched_param param;
|
|
pthread_attr_t attr;
|
|
pthread_t thread;
|
|
int ret;
|
|
|
|
/* Start a separate thread to listen for server events. This is probably
|
|
* the least efficient way to do this, but it makes this example flow more
|
|
* smoothly.
|
|
*/
|
|
|
|
(void)pthread_attr_init(&attr);
|
|
param.sched_priority = CONFIG_EXAMPLES_PWLINES_LISTENER_PRIO;
|
|
(void)pthread_attr_setschedparam(&attr, ¶m);
|
|
(void)pthread_attr_setstacksize(&attr, CONFIG_EXAMPLES_PWLINES_LISTENER_STACKSIZE);
|
|
|
|
ret = pthread_create(&thread, &attr, pwlines_listener, st);
|
|
if (ret != 0)
|
|
{
|
|
printf("pwlines_listener_initialize: ERROR: "
|
|
"pthread_create failed: %d\n",
|
|
ret);
|
|
return false;
|
|
}
|
|
|
|
/* Don't return until we are connected to the server */
|
|
|
|
while (!st->connected)
|
|
{
|
|
/* Wait for the listener thread to wake us up when we really
|
|
* are connected.
|
|
*/
|
|
|
|
(void)sem_wait(&st->semevent);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: pwlines_state_initialize
|
|
****************************************************************************/
|
|
|
|
static bool pwlines_state_initialize(FAR struct pwlines_state_s *st)
|
|
{
|
|
/* Initialize semaphores */
|
|
|
|
sem_init(&st->semevent, 0, 0);
|
|
|
|
/* Initialize color information (only a single color plane supported) */
|
|
|
|
st->wndo[0].color[0] = CONFIG_EXAMPLES_PWLINES_COLOR1;
|
|
st->wndo[1].color[0] = CONFIG_EXAMPLES_PWLINES_COLOR2;
|
|
st->wndo[2].color[0] = CONFIG_EXAMPLES_PWLINES_COLOR3;
|
|
|
|
st->facecolor[0] = CONFIG_EXAMPLES_PWLINES_FACECOLOR;
|
|
st->bordercolor[0] = CONFIG_EXAMPLES_PWLINES_BORDERCOLOR;
|
|
st->linecolor[0] = CONFIG_EXAMPLES_PWLINES_LINECOLOR;
|
|
|
|
return true;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: pwlines_configure_window
|
|
****************************************************************************/
|
|
|
|
static bool pwlines_configure_window(FAR struct pwlines_state_s *st, int wndx,
|
|
FAR struct nxgl_size_s *size,
|
|
FAR struct nxgl_point_s *pos,
|
|
double deltax, double deltay)
|
|
{
|
|
FAR struct pwlines_window_s *wndo = &st->wndo[wndx];
|
|
struct nxgl_rect_s rect;
|
|
int ret;
|
|
|
|
/* Set the total size of the window */
|
|
|
|
printf("pwlines_configure_window: Set window %d size to (%d,%d)\n",
|
|
wndx + 1, size->w, size->h);
|
|
|
|
ret = nxtk_setsize(wndo->hwnd, size);
|
|
if (ret < 0)
|
|
{
|
|
printf("pwlines_configure_window: ERROR: "
|
|
"nxtk_setsize failed: %d\n", errno);
|
|
goto errout_with_hwnd;
|
|
}
|
|
|
|
/* Set the drawable size (excludes borders) */
|
|
|
|
wndo->size.h = size->h - 2 * CONFIG_NXTK_BORDERWIDTH;
|
|
wndo->size.w = size->w - 2 * CONFIG_NXTK_BORDERWIDTH;
|
|
|
|
/* Set the position of window */
|
|
|
|
printf("pwlines_configure_window: Set window %d position to (%d,%d)\n",
|
|
wndx + 1, pos->x, pos->y);
|
|
|
|
ret = nxtk_setposition(wndo->hwnd, pos);
|
|
if (ret < 0)
|
|
{
|
|
printf("pwlines_configure_window: ERROR: "
|
|
"nxtk_setposition failed: %d\n",
|
|
errno);
|
|
goto errout_with_hwnd;
|
|
}
|
|
|
|
/* Create a bounding box. This is actually too large because it does not
|
|
* account for the boarder widths. However, NX should clip the fill to
|
|
* stay within the frame.
|
|
*
|
|
* There is a race condition here we resolve by making the main thread
|
|
* lowest in priority. In order for the size and position to take effect,
|
|
* a command is sent to server which responds with an event. So we need
|
|
* to be synchronized at this point or the following fill will fail because
|
|
* it depends on current knowlede of the size and position.
|
|
* REVISIT: Use nx_synch()!
|
|
*/
|
|
|
|
rect.pt1.x = 0;
|
|
rect.pt1.y = 0;
|
|
rect.pt2.x = size->w - 1;
|
|
rect.pt2.y = size->h - 1;
|
|
|
|
/* Fill the window with the selected color */
|
|
|
|
ret = nxtk_fillwindow(wndo->hwnd, &rect, wndo->color);
|
|
if (ret < 0)
|
|
{
|
|
printf("pwlines_configure_window: ERROR: "
|
|
"nxtk_fillwindow failed: %d\n",
|
|
errno);
|
|
goto errout_with_hwnd;
|
|
}
|
|
|
|
/* Set up for motion */
|
|
|
|
wndo->xmax = itob16(st->xres - size->w - 1);
|
|
wndo->ymax = itob16(st->yres - size->h - 1);
|
|
wndo->ypos = itob16(pos->y);
|
|
wndo->xpos = itob16(pos->x);
|
|
wndo->deltax = dtob16(deltax);
|
|
wndo->deltay = dtob16(deltay);
|
|
|
|
return true;
|
|
|
|
errout_with_hwnd:
|
|
printf("pwlines_configure_window: Close window %d\n", wndx + 1);
|
|
|
|
ret = nxtk_closewindow(wndo->hwnd);
|
|
if (ret < 0)
|
|
{
|
|
printf("pwlines_configure_window: ERROR: "
|
|
"nxtk_closewindow failed: %d\n",
|
|
errno);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Public Functions
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* Name: pwlines_main
|
|
****************************************************************************/
|
|
|
|
#ifdef BUILD_MODULE
|
|
int main(int argc, FAR char *argv[])
|
|
#else
|
|
int pwlines_main(int argc, char *argv[])
|
|
#endif
|
|
{
|
|
struct pwlines_state_s wstate;
|
|
struct nxgl_size_s size;
|
|
struct nxgl_point_s pos;
|
|
nxgl_coord_t mindim;
|
|
nxgl_mxpixel_t color;
|
|
unsigned int elapsed;
|
|
int errcode = EXIT_SUCCESS;
|
|
int ret;
|
|
|
|
/* Connect to the NX server */
|
|
|
|
memset(&wstate, 0, sizeof(struct pwlines_state_s));
|
|
if (!pwlines_server_initialize(&wstate) || wstate.hnx == NULL)
|
|
{
|
|
printf("pwlines_main: ERROR: "
|
|
"Failed to get NX handle\n");
|
|
goto errout;
|
|
}
|
|
|
|
printf("pwlines_main: NX handle=%p\n", wstate.hnx);
|
|
|
|
/* Start the listener thread */
|
|
|
|
if (!pwlines_listener_initialize(&wstate))
|
|
{
|
|
printf("pwlines_main: ERROR: "
|
|
"pwlines_listener_initialize failed\n");
|
|
goto errout_with_nx;
|
|
}
|
|
|
|
/* Initialize the window state, colors, cache, etc. */
|
|
|
|
if (!pwlines_state_initialize(&wstate))
|
|
{
|
|
printf("pwlines_main: ERROR: "
|
|
"pwlines_state_initialize failed\n");
|
|
goto errout_with_nx;
|
|
}
|
|
|
|
/* Set the background to the configured background color */
|
|
|
|
printf("pwlines_main: Set background color=%d\n",
|
|
CONFIG_EXAMPLES_PWLINES_BGCOLOR);
|
|
|
|
color = CONFIG_EXAMPLES_PWLINES_BGCOLOR;
|
|
ret = nx_setbgcolor(wstate.hnx, &color);
|
|
if (ret < 0)
|
|
{
|
|
printf("pwlines_main: nx_setbgcolor failed: %d\n", errno);
|
|
goto errout_with_nx;
|
|
}
|
|
|
|
/* Open window 1 */
|
|
|
|
printf("pwlines_main: Open window 1\n");
|
|
|
|
wstate.wndo[0].hwnd = nxtk_openwindow(wstate.hnx, NXBE_WINDOW_RAMBACKED,
|
|
&g_pwlines_wncb, (FAR void *)&wstate);
|
|
if (wstate.wndo[0].hwnd == NULL)
|
|
{
|
|
printf("pwlines_main: ERROR: "
|
|
"nxtk_openwindow failed: %d\n",
|
|
errno);
|
|
goto errout_with_nx;
|
|
}
|
|
|
|
printf("pwlines_main: hwnd1=%p\n", wstate.wndo[0].hwnd);
|
|
|
|
/* Wait until we receive the screen resolution from the server. We only
|
|
* need to do this once after opening the first window.
|
|
*/
|
|
|
|
while (!wstate.haveres)
|
|
{
|
|
(void)sem_wait(&wstate.semevent);
|
|
}
|
|
|
|
printf("pwlines_main: Screen resolution (%d,%d)\n",
|
|
wstate.xres, wstate.yres);
|
|
|
|
/* Configure window 1 */
|
|
|
|
mindim = MIN(wstate.xres, wstate.yres);
|
|
size.w = mindim / 2;
|
|
size.h = size.w;
|
|
|
|
pos.x = wstate.xres / 8;
|
|
pos.y = wstate.yres / 8;
|
|
|
|
if (!pwlines_configure_window(&wstate, 0, &size, &pos, 4.200, 4.285))
|
|
{
|
|
printf("pwlines_main: ERROR: "
|
|
"pwlines_configure_window failed for window 1\n");
|
|
goto errout_with_hwnd1;
|
|
}
|
|
|
|
/* Open window 2 */
|
|
|
|
printf("pwlines_main: Open window 2\n");
|
|
|
|
wstate.wndo[1].hwnd = nxtk_openwindow(wstate.hnx, NXBE_WINDOW_RAMBACKED,
|
|
&g_pwlines_wncb, (FAR void *)&wstate);
|
|
if (wstate.wndo[1].hwnd == NULL)
|
|
{
|
|
printf("pwlines_main: ERROR: "
|
|
"nxtk_openwindow failed: %d\n",
|
|
errno);
|
|
goto errout_with_hwnd1;
|
|
}
|
|
|
|
printf("pwlines_main: hwnd1=%p\n", wstate.wndo[1].hwnd);
|
|
|
|
/* Configure window 2 (same size) */
|
|
|
|
pos.x = wstate.xres / 4;
|
|
pos.y = wstate.yres / 4;
|
|
|
|
if (!pwlines_configure_window(&wstate, 1, &size, &pos, -3.317, 5.0))
|
|
{
|
|
printf("pwlines_main: ERROR: "
|
|
"pwlines_configure_window failed for window 2\n");
|
|
goto errout_with_hwnd2;
|
|
}
|
|
|
|
/* Open window 3 */
|
|
|
|
printf("pwlines_main: Open window 3\n");
|
|
|
|
wstate.wndo[2].hwnd = nxtk_openwindow(wstate.hnx, NXBE_WINDOW_RAMBACKED,
|
|
&g_pwlines_wncb, (FAR void *)&wstate);
|
|
if (wstate.wndo[2].hwnd == NULL)
|
|
{
|
|
printf("pwlines_main: ERROR: "
|
|
"nxtk_openwindow failed: %d\n",
|
|
errno);
|
|
goto errout_with_hwnd2;
|
|
}
|
|
|
|
printf("pwlines_main: hwnd2=%p\n", wstate.wndo[2].hwnd);
|
|
|
|
/* Configure window 3 (same size) */
|
|
|
|
pos.x = (3 * wstate.xres) / 8;
|
|
pos.y = (3 * wstate.yres) / 8;
|
|
|
|
if (!pwlines_configure_window(&wstate, 2, &size, &pos, 4.600, -3.852))
|
|
{
|
|
printf("pwlines_main: ERROR: "
|
|
"pwlines_configure_window failed for window 2\n");
|
|
goto errout_with_hwnd3;
|
|
}
|
|
|
|
/* Apply the initial graphics */
|
|
|
|
pwlines_circle(&wstate);
|
|
pwlines_update(&wstate);
|
|
|
|
/* Now loop animating the windows */
|
|
|
|
elapsed = 0;
|
|
for (; ; )
|
|
{
|
|
usleep(CONFIG_EXAMPLES_PWLINES_RATECONTROL * 1000);
|
|
|
|
if (!pwlines_motion(&wstate))
|
|
{
|
|
printf("pwlines_main: ERROR:"
|
|
"pwlines_motion failed\n");
|
|
goto errout_with_hwnd3;
|
|
}
|
|
|
|
elapsed += CONFIG_EXAMPLES_PWLINES_RATECONTROL;
|
|
if (elapsed >= 1000)
|
|
{
|
|
pwlines_update(&wstate);
|
|
elapsed = 0;
|
|
}
|
|
}
|
|
|
|
errcode = EXIT_SUCCESS;
|
|
|
|
/* Close window 3 */
|
|
|
|
errout_with_hwnd3:
|
|
printf("pwlines_main: Close window #2\n");
|
|
|
|
ret = nxtk_closewindow(wstate.wndo[2].hwnd);
|
|
if (ret < 0)
|
|
{
|
|
printf("pwlines_main: ERROR: nxtk_closewindow failed: %d\n", errno);
|
|
}
|
|
|
|
/* Close window 2 */
|
|
|
|
errout_with_hwnd2:
|
|
printf("pwlines_main: Close window #2\n");
|
|
|
|
ret = nxtk_closewindow(wstate.wndo[1].hwnd);
|
|
if (ret < 0)
|
|
{
|
|
printf("pwlines_main: ERROR: nxtk_closewindow failed: %d\n", errno);
|
|
}
|
|
|
|
/* Close window1 */
|
|
|
|
errout_with_hwnd1:
|
|
printf("pwlines_main: Close window #1\n");
|
|
|
|
ret = nxtk_closewindow(wstate.wndo[0].hwnd);
|
|
if (ret < 0)
|
|
{
|
|
printf("pwlines_main: ERROR: nxtk_closewindow failed: %d\n", errno);
|
|
}
|
|
|
|
errout_with_nx:
|
|
/* Disconnect from the server */
|
|
|
|
printf("pwlines_main: Disconnect from the server\n");
|
|
nx_disconnect(wstate.hnx);
|
|
|
|
errout:
|
|
return errcode;
|
|
}
|