Example #1
0
void
input_internal_key(const char *key)
{
	if (is_menu_key(key) || screenlist_current() == menuscreen) {
		menuscreen_key_handler(key);
	}
	else {
		/* Keys are for scrolling or rotating */
		if (strcmp(key,toggle_rotate_key) == 0) {
			autorotate = !autorotate;
			if (autorotate) {
				server_msg("Rotate", 4);
			} else {
				server_msg("Hold", 4);
			}
		}
		else if (strcmp(key,prev_screen_key) == 0) {
			screenlist_goto_prev();
			server_msg("Prev", 4);
		}
		else if (strcmp(key,next_screen_key) == 0) {
			screenlist_goto_next();
			server_msg("Next", 4);
		}
		else if (strcmp(key,scroll_up_key) == 0) {
		}
		else if (strcmp(key,scroll_down_key) == 0) {
		}
	}
}
Example #2
0
int
handle_input(void)
{
	const char *key;
	Screen *current_screen;
	Client *current_client;
	Client *target;
	KeyReservation *kr;

	debug(RPT_DEBUG, "%s()", __FUNCTION__);

	current_screen = screenlist_current();
	if (current_screen)
		current_client = current_screen->client;
	else
		current_client = NULL;

	/* Handle all keypresses */
	while ((key = drivers_get_key()) != NULL) {

		/* Find what client wants the key */
		kr = input_find_key(key, current_client);
		if (kr) {
			/* A hit ! */
			report(RPT_DEBUG, "%s: reserved key: \"%.40s\"", __FUNCTION__, key);
			target = kr->client;
		} else {
			report(RPT_DEBUG, "%s: left over key: \"%.40s\"", __FUNCTION__, key);
			/*target = current_client;*/
			target = NULL; /* left-over keys are always for internal client */
		}
		if (target == NULL) {
			report(RPT_DEBUG, "%s: key is for internal client", __FUNCTION__);
			input_internal_key(key);
		} else {
			/* It's an external client */
			report(RPT_DEBUG, "%s: key is for external client on socket %d", __FUNCTION__, target->sock);
			input_send_to_client(target, key);
		}
	}
	return 0;
}
void
screenlist_process(void)
{
	Screen *s;
	Screen *f;

	report(RPT_DEBUG, "%s()", __FUNCTION__);

	if (!screenlist)
		return;
	/* Sort the list according to priority class */
	LL_Sort(screenlist, compare_priority);
	f = LL_GetFirst(screenlist);

	/**** First we need to check out the current situation. ****/

	/* Check whether there is an active screen */
	s = screenlist_current();
	if (!s) {
		/* We have no active screen yet.
		 * Try to switch to the first screen in the list... */

		s = f;
		if (!s) {
			/* There was no screen in the list */
			return;
		}
		screenlist_switch(s);
		return;
	}
	else {
		/* There already was an active screen.
		 * Check to see if it has an expiry time. If so, decrease it
		 * and then check to see if it has expired. Remove the screen
		 * if expired. */
		if (s->timeout != -1) {
			--(s->timeout);
			report(RPT_DEBUG, "Active screen [%.40s] has timeout->%d", s->id, s->timeout);
			if (s->timeout <= 0) {
				/* Expired, we can destroy it */
				report(RPT_DEBUG, "Removing expired screen [%.40s]", s->id);
				client_remove_screen(s->client, s);
				screen_destroy(s);
			}
		}
	}

	/**** OK, current situation examined. We can now see if we need to switch. */

	/* Is there a screen of a higher priority class than the
	 * current one ? */
	if (f->priority > s->priority) {
		/* Yes, switch to that screen, job done */
		report(RPT_DEBUG, "%s: High priority screen [%.40s] selected", __FUNCTION__, f->id);
		screenlist_switch(f);
		return;
	}

	/* Current screen has been visible long enough and is it of 'normal'
	 * priority ?
	 */
	if (autorotate && (timer - current_screen_start_time >= s->duration)
	&& s->priority > PRI_BACKGROUND && s->priority <= PRI_FOREGROUND) {
		/* Ah, rotate! */
		screenlist_goto_next();
	}
}
Example #4
0
static void
do_mainloop(void)
{
	Screen *s;
	struct timeval t;
	struct timeval last_t;
	int sleeptime;
	long int process_lag = 0;
	long int render_lag = 0;
	long int t_diff;

	debug(RPT_DEBUG, "%s()", __FUNCTION__);

	gettimeofday(&t, NULL); /* Get initial time */

	while (1) {
		/* Get current time */
		last_t = t;
		gettimeofday(&t, NULL);
		t_diff = t.tv_sec - last_t.tv_sec;
		if ( ((t_diff + 1) > (LONG_MAX / 1e6)) || (t_diff < 0) ) {
			/* We're going to overflow the calculation - probably been to sleep, fudge the values */
			t_diff = 0;
			process_lag = 1;
			render_lag = (1e6/RENDER_FREQ);
		} else {
			t_diff *= 1e6;
			t_diff += t.tv_usec - last_t.tv_usec;
		}
                process_lag += t_diff;
		if (process_lag > 0) {
			/* Time for a processing stroke */
			sock_poll_clients();		/* poll clients for input*/
			parse_all_client_messages();	/* analyze input from network clients*/
			handle_input();		/* handle key input from devices*/

			/* We've done the job... */
			process_lag = 0 - (1e6/PROCESS_FREQ);
			/* Note : this does not make a fixed frequency */
		}

		render_lag += t_diff;
		if (render_lag > 0) {
			/* Time for a rendering stroke */
			timer ++;
			screenlist_process();
			s = screenlist_current();

			/* TODO: Move this call to every client connection
			 *       and every screen add...
			 */
			if (s == server_screen) {
				update_server_screen();
			}
			render_screen(s, timer);

			/* We've done the job... */
			if (render_lag > (1e6/RENDER_FREQ) * MAX_RENDER_LAG_FRAMES) {
				/* Cause rendering slowdown because too much lag */
				render_lag = (1e6/RENDER_FREQ) * MAX_RENDER_LAG_FRAMES;
			}
			render_lag -= (1e6/RENDER_FREQ);
			/* Note: this DOES make a fixed frequency (except with slowdown) */
		}

		/* Sleep just as long as needed */
		sleeptime = min(0-process_lag, 0-render_lag);
		if (sleeptime > 0) {
			usleep(sleeptime);
		}

		/* Check if a SIGHUP has been caught */
		if (got_reload_signal) {
			got_reload_signal = 0;
			do_reload();
		}
	}

	/* Quit! */
	exit_program(0);
}