nuttx-apps/graphics/pdcurs34/pdcurses/pdc_inopts.c

/****************************************************************************
 * apps/graphics/pdcurses/pdc_inopts.c
 * Public Domain Curses
 * RCSID("$Id: inopts.c,v 1.43 2008/07/13 16:08:18 wmcbrine Exp $")
 *
 *   Copyright (C) 2017 Gregory Nutt. All rights reserved.
 *   Adapted by: Gregory Nutt <gnutt@nuttx.org>
 *
 * Adapted from the original public domain pdcurses by Gregory Nutt and
 * released as part of NuttX under the 3-clause BSD license:
 *
 * 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.
 *
 ****************************************************************************/

/* Name: inopts
 *
 * Synopsis:
 *       int cbreak(void);
 *       int nocbreak(void);
 *       int echo(void);
 *       int noecho(void);
 *       int halfdelay(int tenths);
 *       int intrflush(WINDOW *win, bool bf);
 *       int keypad(WINDOW *win, bool bf);
 *       int meta(WINDOW *win, bool bf);
 *       int nl(void);
 *       int nonl(void);
 *       int nodelay(WINDOW *win, bool bf);
 *       int notimeout(WINDOW *win, bool bf);
 *       int raw(void);
 *       int noraw(void);
 *       void noqiflush(void);
 *       void qiflush(void);
 *       void timeout(int delay);
 *       void wtimeout(WINDOW *win, int delay);
 *       int typeahead(int fildes);
 *
 *       int crmode(void);
 *       int nocrmode(void);
 *
 * Description:
 *       cbreak() and nocbreak() toggle cbreak mode. In cbreak mode,
 *       characters typed by the user are made available immediately, and
 *       erase/kill character processing is not performed.  In nocbreak
 *       mode, typed characters are buffered until a newline or carriage
 *       return. Interrupt and flow control characters are unaffected by
 *       this mode. PDCurses always starts in cbreak mode.
 *
 *       echo() and noecho() control whether typed characters are echoed
 *       by the input routine.  Initially, input characters are echoed.
 *       Subsequent calls to echo() and noecho() do not flush type-ahead.
 *
 *       halfdelay() is similar to cbreak(), but allows for a time limit
 *       to be specified, in tenths of a second. This causes getch() to
 *       block for that period before returning ERR if no key has been
 *       received.  tenths must be between 1 and 255.
 *
 *       keypad() controls whether getch() returns function/special keys
 *       as single key codes (e.g., the left arrow key as KEY_LEFT). Per
 *       X/Open, the default for keypad mode is OFF. You'll probably want
 *       it on. With keypad mode off, if a special key is pressed,
 *       getch() does nothing or returns ERR.
 *
 *       nodelay() controls whether wgetch() is a non-blocking call. If
 *       the option is enabled, and no input is ready, wgetch() will
 *       return ERR. If disabled, wgetch() will hang until input is
 *       ready.
 *
 *       nl() enables the translation of a carriage return into a newline
 *       on input. nonl() disables this. Initially, the translation does
 *       occur.
 *
 *       raw() and noraw() toggle raw mode. Raw mode is similar to cbreak
 *       mode, in that characters typed are immediately passed through to
 *       the user program.  The difference is that in raw mode, the INTR,
 *       QUIT, SUSP, and STOP characters are passed through without being
 *       interpreted, and without generating a signal.
 *
 *       In PDCurses, the meta() function sets raw mode on or off.
 *
 *       timeout() and wtimeout() set blocking or non-blocking reads for
 *       the specified window. The delay is measured in milliseconds. If
 *       it's negative, a blocking read is used; if zero, then non-
 *       blocking reads are done -- if no input is waiting, ERR is
 *       returned immediately. If the delay is positive, the read blocks
 *       for the delay period; if the period expires, ERR is returned.
 *
 *       intrflush(), notimeout(), noqiflush(), qiflush() and typeahead()
 *       do nothing in PDCurses, but are included for compatibility with
 *       other curses implementations.
 *
 *       crmode() and nocrmode() are archaic equivalents to cbreak() and
 *       nocbreak(), respectively.
 *
 * Return Value:
 *       All functions return OK on success and ERR on error.
 *
 * Portability                                X/Open    BSD    SYS V
 *       cbreak                                  Y       Y       Y
 *       nocbreak                                Y       Y       Y
 *       echo                                    Y       Y       Y
 *       noecho                                  Y       Y       Y
 *       halfdelay                               Y       -       Y
 *       intrflush                               Y       -       Y
 *       keypad                                  Y       -       Y
 *       meta                                    Y       -       Y
 *       nl                                      Y       Y       Y
 *       nonl                                    Y       Y       Y
 *       nodelay                                 Y       -       Y
 *       notimeout                               Y       -       Y
 *       raw                                     Y       Y       Y
 *       noraw                                   Y       Y       Y
 *       noqiflush                               Y       -       Y
 *       qiflush                                 Y       -       Y
 *       timeout                                 Y       -       Y
 *       wtimeout                                Y       -       Y
 *       typeahead                               Y       -       Y
 *       crmode                                  -
 *       nocrmode                                -
 */

/****************************************************************************
 * Included Files
 ****************************************************************************/

#include "curspriv.h"

/****************************************************************************
 * Public Functions
 ****************************************************************************/

int cbreak(void)
{
#ifdef CONFIG_PDCURSES_MULTITHREAD
  FAR struct pdc_context_s *ctx = PDC_ctx();
#endif
  PDC_LOG(("cbreak() - called\n"));

  SP->cbreak = true;
  return OK;
}

int nocbreak(void)
{
#ifdef CONFIG_PDCURSES_MULTITHREAD
  FAR struct pdc_context_s *ctx = PDC_ctx();
#endif
  PDC_LOG(("nocbreak() - called\n"));

  SP->cbreak = false;
  SP->delaytenths = 0;

  return OK;
}

int echo(void)
{
#ifdef CONFIG_PDCURSES_MULTITHREAD
  FAR struct pdc_context_s *ctx = PDC_ctx();
#endif
  PDC_LOG(("echo() - called\n"));

  SP->echo = true;
  return OK;
}

int noecho(void)
{
#ifdef CONFIG_PDCURSES_MULTITHREAD
  FAR struct pdc_context_s *ctx = PDC_ctx();
#endif
  PDC_LOG(("noecho() - called\n"));

  SP->echo = false;
  return OK;
}

int halfdelay(int tenths)
{
#ifdef CONFIG_PDCURSES_MULTITHREAD
  FAR struct pdc_context_s *ctx = PDC_ctx();
#endif
  PDC_LOG(("halfdelay() - called\n"));

  if (tenths < 1 || tenths > 255)
    {
      return ERR;
    }

  SP->delaytenths = tenths;
  return OK;
}

int intrflush(WINDOW *win, bool bf)
{
  PDC_LOG(("intrflush() - called\n"));

  return OK;
}

int keypad(WINDOW *win, bool bf)
{
  PDC_LOG(("keypad() - called\n"));

  if (!win)
    {
      return ERR;
    }

  win->_use_keypad = bf;
  return OK;
}

int meta(WINDOW *win, bool bf)
{
#ifdef CONFIG_PDCURSES_MULTITHREAD
  FAR struct pdc_context_s *ctx = PDC_ctx();
#endif
  PDC_LOG(("meta() - called\n"));

  SP->raw_inp = bf;
  return OK;
}

int nl(void)
{
#ifdef CONFIG_PDCURSES_MULTITHREAD
  FAR struct pdc_context_s *ctx = PDC_ctx();
#endif
  PDC_LOG(("nl() - called\n"));

  SP->autocr = true;
  return OK;
}

int nonl(void)
{
#ifdef CONFIG_PDCURSES_MULTITHREAD
  FAR struct pdc_context_s *ctx = PDC_ctx();
#endif
  PDC_LOG(("nonl() - called\n"));

  SP->autocr = false;
  return OK;
}

int nodelay(WINDOW *win, bool flag)
{
  PDC_LOG(("nodelay() - called\n"));

  if (!win)
    {
      return ERR;
    }

  win->_nodelay = flag;
  return OK;
}

int notimeout(WINDOW *win, bool flag)
{
  PDC_LOG(("notimeout() - called\n"));

  return OK;
}

int raw(void)
{
#ifdef CONFIG_PDCURSES_MULTITHREAD
  FAR struct pdc_context_s *ctx = PDC_ctx();
#endif
  PDC_LOG(("raw() - called\n"));

  PDC_set_keyboard_binary(true);
  SP->raw_inp = true;
  return OK;
}

int noraw(void)
{
#ifdef CONFIG_PDCURSES_MULTITHREAD
  FAR struct pdc_context_s *ctx = PDC_ctx();
#endif
  PDC_LOG(("noraw() - called\n"));

  PDC_set_keyboard_binary(false);
  SP->raw_inp = false;
  return OK;
}

void noqiflush(void)
{
  PDC_LOG(("noqiflush() - called\n"));
}

void qiflush(void)
{
  PDC_LOG(("qiflush() - called\n"));
}

int typeahead(int fildes)
{
  PDC_LOG(("typeahead() - called\n"));

  return OK;
}

void wtimeout(WINDOW *win, int delay)
{
  PDC_LOG(("wtimeout() - called\n"));

  if (!win)
    {
      return;
    }

  if (delay < 0)
    {
      /* This causes a blocking read on the window, so turn on delay mode */

      win->_nodelay = false;
      win->_delayms = 0;
    }
  else if (!delay)
    {
      /* This causes a non-blocking read on the window, so turn off delay mode
       */

      win->_nodelay = true;
      win->_delayms = 0;
    }
  else
    {
      /* This causes the read on the window to delay for the number of
       * milliseconds. Also forces the window into non-blocking read mode */

      /* win->_nodelay = true; */
      win->_delayms = delay;
    }
}

void timeout(int delay)
{
#ifdef CONFIG_PDCURSES_MULTITHREAD
  FAR struct pdc_context_s *ctx = PDC_ctx();
#endif
  PDC_LOG(("timeout() - called\n"));

  wtimeout(stdscr, delay);
}

int crmode(void)
{
  PDC_LOG(("crmode() - called\n"));

  return cbreak();
}

int nocrmode(void)
{
  PDC_LOG(("nocrmode() - called\n"));

  return nocbreak();
}