text: /****************************************************************************
   * Copyright (c) 1998-2012,2014 Free Software Foundation, Inc.              *
   *                                                                          *
   * Permission is hereby granted, free of charge, to any person obtaining a  *
   * copy of this software and associated documentation files (the            *
   * "Software"), to deal in the Software without restriction, including      *
   * without limitation the rights to use, copy, modify, merge, publish,      *
   * distribute, distribute with modifications, sublicense, and/or sell       *
   * copies of the Software, and to permit persons to whom the Software is    *
   * furnished to do so, subject to the following conditions:                 *
   *                                                                          *
   * The above copyright notice and this permission notice shall be included  *
   * in all copies or substantial portions of the Software.                   *
   *                                                                          *
   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
   * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
   * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
   * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
   * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
   * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
   * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
   *                                                                          *
   * Except as contained in this notice, the name(s) of the above copyright   *
   * holders shall not be used in advertising or otherwise to promote the     *
   * sale, use or other dealings in this Software without prior written       *
   * authorization.                                                           *
   ****************************************************************************/
  /*
   * $Id: rain.c,v 1.41 2014/08/02 17:24:07 tom Exp $
   */
  #include <test.priv.h>
  
  /* rain 11/3/1980 EPS/CITHEP */
  
  #ifdef USE_PTHREADS
  #include <pthread.h>
  #endif
  
  WANT_USE_WINDOW();
  
  #define MAX_THREADS	10
  #define MAX_DROP	5
  
  struct DATA;
  
  typedef void (*DrawPart) (struct DATA *);
  
  typedef struct DATA {
      int y, x;
  #ifdef USE_PTHREADS
      DrawPart func;
      int state;
  #endif
  } DATA;
  
  #ifdef USE_PTHREADS
  pthread_cond_t cond_next_drop;
  pthread_mutex_t mutex_next_drop;
  static int used_threads;
  
  typedef struct {
      pthread_t myself;
      long counter;
  } STATS;
  
  static STATS drop_threads[MAX_THREADS];
  #endif
  
  static void
  onsig(int n GCC_UNUSED)
  {
      curs_set(1);
      endwin();
      ExitProgram(EXIT_FAILURE);
  }
  
  static double
  ranf(void)
  {
      long r = (rand() & 077777);
      return ((double) r / 32768.);
  }
  
  static int
  random_x(void)
  {
      return (int) (((double) (COLS - 4) * ranf()) + 2);
  }
  
  static int
  random_y(void)
  {
      return (int) (((double) (LINES - 4) * ranf()) + 2);
  }
  
  static int
  next_j(int j)
  {
      if (j == 0)
  	j = MAX_DROP - 1;
      else
  	--j;
      if (has_colors()) {
  	int z = (int) (3 * ranf());
  	(void) attrset(AttrArg(COLOR_PAIR(z), (z ? A_BOLD : A_NORMAL)));
      }
      return j;
  }
  
  static void
  part1(DATA * drop)
  {
      MvAddCh(drop->y, drop->x, '.');
  }
  
  static void
  part2(DATA * drop)
  {
      MvAddCh(drop->y, drop->x, 'o');
  }
  
  static void
  part3(DATA * drop)
  {
      MvAddCh(drop->y, drop->x, 'O');
  }
  
  static void
  part4(DATA * drop)
  {
      MvAddCh(drop->y - 1, drop->x, '-');
      MvAddStr(drop->y, drop->x - 1, "|.|");
      MvAddCh(drop->y + 1, drop->x, '-');
  }
  
  static void
  part5(DATA * drop)
  {
      MvAddCh(drop->y - 2, drop->x, '-');
      MvAddStr(drop->y - 1, drop->x - 1, "/ \\");
      MvAddStr(drop->y, drop->x - 2, "| O |");
      MvAddStr(drop->y + 1, drop->x - 1, "\\ /");
      MvAddCh(drop->y + 2, drop->x, '-');
  }
  
  static void
  part6(DATA * drop)
  {
      MvAddCh(drop->y - 2, drop->x, ' ');
      MvAddStr(drop->y - 1, drop->x - 1, "   ");
      MvAddStr(drop->y, drop->x - 2, "     ");
      MvAddStr(drop->y + 1, drop->x - 1, "   ");
      MvAddCh(drop->y + 2, drop->x, ' ');
  }
  
  #ifdef USE_PTHREADS
  static void
  napsome(void)
  {
      napms(60);
  }
  
  /*
   * This runs inside the use_window() mutex.
   */
  static int
  really_draw(WINDOW *win, void *arg)
  {
      DATA *data = (DATA *) arg;
  
      (void) win;
      next_j(data->state);
      data->func(data);
      refresh();
      return OK;
  }
  
  static void
  draw_part(void (*func) (DATA *), int state, DATA * data)
  {
      data->func = func;
      data->state = state;
      use_window(stdscr, really_draw, (void *) data);
      napsome();
  }
  
  /*
   * Tell the threads that one of them can start work on a new raindrop.
   * They may all be busy if we're sending requests too rapidly.
   */
  static int
  put_next_drop(void)
  {
      pthread_cond_signal(&cond_next_drop);
      pthread_mutex_unlock(&mutex_next_drop);
  
      return 0;
  }
  
  /*
   * Wait until we're assigned the task of drawing a new raindrop.
   */
  static int
  get_next_drop(void)
  {
      pthread_mutex_lock(&mutex_next_drop);
      pthread_cond_wait(&cond_next_drop, &mutex_next_drop);
  
      return TRUE;
  }
  
  static void *
  draw_drop(void *arg)
  {
      DATA mydata;
      int mystats;
  
      /*
       * Find myself in the list of threads so we can count the number of loops.
       */
      for (mystats = 0; mystats < MAX_THREADS; ++mystats) {
  #if defined(__MINGW32__) && !defined(__WINPTHREADS_VERSION)
  	if (drop_threads[mystats].myself.p == pthread_self().p)
  #else
  	if (drop_threads[mystats].myself == pthread_self())
  #endif
  	    break;
      }
  
      do {
  	if (mystats < MAX_THREADS)
  	    drop_threads[mystats].counter++;
  
  	/*
  	 * Make a copy of caller's data.  We're cheating for the cases after
  	 * the first loop since we still have a pointer into the main thread
  	 * to the data which it uses for setting up this thread (but it has
  	 * been modified to use different coordinates).
  	 */
  	mydata = *(DATA *) arg;
  
  	draw_part(part1, 0, &mydata);
  	draw_part(part2, 1, &mydata);
  	draw_part(part3, 2, &mydata);
  	draw_part(part4, 3, &mydata);
  	draw_part(part5, 4, &mydata);
  	draw_part(part6, 0, &mydata);
      } while (get_next_drop());
  
      return NULL;
  }
  
  /*
   * The description of pthread_create() is misleading, since it implies that
   * threads will exit cleanly after their function returns.
   *
   * Since they do not (and the number of threads is limited by system
   * resources), make a limited number of threads, and signal any that are
   * waiting when we want a thread past that limit.
   */
  static int
  start_drop(DATA * data)
  {
      int rc;
  
      if (!used_threads) {
  	/* mutex and condition for signalling thread */
  	pthread_mutex_init(&mutex_next_drop, NULL);
  	pthread_cond_init(&cond_next_drop, NULL);
      }
  
      if (used_threads < MAX_THREADS) {
  	rc = pthread_create(&(drop_threads[used_threads].myself),
  			    NULL,
  			    draw_drop,
  			    data);
  	++used_threads;
      } else {
  	rc = put_next_drop();
      }
      return rc;
  }
  #endif
  
  static int
  get_input(void)
  {
      return USING_WINDOW(stdscr, wgetch);
  }
  
  int
  main(int argc GCC_UNUSED,
       char *argv[]GCC_UNUSED)
  {
      bool done = FALSE;
      DATA drop;
  #ifndef USE_PTHREADS
      DATA last[MAX_DROP];
  #endif
      int j = 0;
  
      setlocale(LC_ALL, "");
  
      CATCHALL(onsig);
  
      initscr();
      if (has_colors()) {
  	int bg = COLOR_BLACK;
  	start_color();
  #if HAVE_USE_DEFAULT_COLORS
  	if (use_default_colors() == OK)
  	    bg = -1;
  #endif
  	init_pair(1, COLOR_BLUE, (short) bg);
  	init_pair(2, COLOR_CYAN, (short) bg);
      }
      nl();
      noecho();
      curs_set(0);
      timeout(0);
  
  #ifndef USE_PTHREADS
      for (j = MAX_DROP; --j >= 0;) {
  	last[j].x = random_x();
  	last[j].y = random_y();
      }
      j = 0;
  #endif
  
      while (!done) {
  	drop.x = random_x();
  	drop.y = random_y();
  
  #ifdef USE_PTHREADS
  	if (start_drop(&drop) != 0) {
  	    beep();
  	}
  #else
  	/*
  	 * The non-threaded code draws parts of each drop on each loop.
  	 */
  	part1(&drop);
  
  	part2(&last[j]);
  
  	j = next_j(j);
  	part3(&last[j]);
  
  	j = next_j(j);
  	part4(&last[j]);
  
  	j = next_j(j);
  	part5(&last[j]);
  
  	j = next_j(j);
  	part6(&last[j]);
  
  	last[j] = drop;
  #endif
  
  	switch (get_input()) {
  	case ('q'):
  	case ('Q'):
  	    done = TRUE;
  	    break;
  	case 's':
  	    nodelay(stdscr, FALSE);
  	    break;
  	case ' ':
  	    nodelay(stdscr, TRUE);
  	    break;
  #ifdef KEY_RESIZE
  	case (KEY_RESIZE):
  	    break;
  #endif
  	}
  	napms(50);
      }
      curs_set(1);
      endwin();
  #ifdef USE_PTHREADS
      printf("Counts per thread:\n");
      for (j = 0; j < MAX_THREADS; ++j)
  	printf("  %d:%ld\n", j, drop_threads[j].counter);
  #endif
      ExitProgram(EXIT_SUCCESS);
  }
  