norohind/kmscon
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

test_console: remove

Browse Source 
This test doesn't compile and is no longer needed. We can now use the
kmscon program or test_terminal for the same functionality.

Signed-off-by: David Herrmann <dh.herrmann@googlemail.com>
This commit is contained in:
David Herrmann 2012-04-22 16:42:25 +02:00
parent 6c23507910
commit a34a107723
1 changed files with 0 additions and 345 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

345
tests/test_console.c
View File

@ -1,345 +0,0 @@
/*
* test_console - Test Console
*
* Copyright (c) 2011 David Herrmann <dh.herrmann@googlemail.com>
* Copyright (c) 2011 University of Tuebingen
*
* 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, 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 AUTHORS OR 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.
*/
/*
* Test Console
* This prints a console onto all available outputs. The console is not
* interactive, but instead all input from stdin is read and printed as
* printable characters onto the console.
* This is no terminal emulation but instead an example how to print text with
* the console subsystem.
*
* This prints all text from stdin to all connected outputs:
* $ ./test_console
*
* This prints the text from the command "ls -la" to all outptus:
* $ ls -la | ./test_console
*/
#include <errno.h>
#include <inttypes.h>
#include <locale.h>
#include <signal.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "console.h"
#include "eloop.h"
#include "font.h"
#include "log.h"
#include "unicode.h"
#include "uterm.h"
#include "vt.h"
static volatile sig_atomic_t terminate;
struct console {
struct ev_eloop *loop;
struct ev_signal *sig_term;
struct ev_signal *sig_int;
struct ev_fd *stdin_fd;
struct kmscon_symbol_table *st;
struct kmscon_font_factory *ff;
struct gl_shader *shader;
struct uterm_video *video;
struct kmscon_vt *vt;
struct kmscon_console *con;
struct ev_idle *idle;
uint32_t max_x;
uint32_t max_y;
};
static void stdin_cb(struct ev_fd *fd, int mask, void *data)
{
struct console *con = data;
char buf[512];
int ret;
unsigned int i, len;
kmscon_symbol_t ch;
if (!con || !fd)
return;
ret = read(0, buf, sizeof(buf));
if (ret < 0) {
log_info("stdin read error: %d\n", errno);
} else if (!ret) {
log_info("stdin closed\n");
ev_eloop_rm_fd(fd);
con->stdin_fd = NULL;
} else {
len = ret;
log_debug("stdin input read (len: %d)\n", len);
for (i = 0; i < len; ++i) {
if (buf[i] == '\n') {
kmscon_console_newline(con->con);
} else {
ch = buf[i];
kmscon_console_write(con->con, ch);
}
}
}
}
static void map_outputs(struct console *con)
{
int ret;
struct uterm_display *iter;
struct uterm_screen *screen;
if (!uterm_video_is_awake(con->video))
return;
iter = uterm_video_get_displays(con->video);
for ( ; iter; iter = uterm_display_next(iter)) {
if (uterm_display_get_state(iter) != UTERM_DISPLAY_ACTIVE)
continue;
/* We create a screen on every draw here to avoid keeping a
* global list of displays/screens. This is ugly but works.
*/
ret = uterm_screen_new_single(&screen, iter);
if (ret)
continue;
ret = uterm_screen_use(screen);
if (ret) {
uterm_screen_unref(screen);
continue;
}
gl_viewport(screen);
kmscon_console_map(con->con, con->shader);
uterm_screen_swap(screen);
uterm_screen_unref(screen);
}
}
static void draw(struct ev_idle *idle, void *data)
{
struct console *con = data;
ev_eloop_rm_idle(idle);
map_outputs(con);
}
static void schedule_draw(struct console *con)
{
int ret;
ret = ev_eloop_add_idle(con->loop, con->idle, draw, con);
if (ret && ret != -EALREADY)
log_warn("Cannot schedule draw function\n");
}
static void activate_outputs(struct console *con)
{
struct uterm_display *iter;
struct uterm_mode *mode;
int ret;
uint32_t y;
con->max_y = 0;
iter = uterm_video_get_displays(con->video);
for ( ; iter; iter = uterm_display_next(iter)) {
if (uterm_display_get_state(iter) == UTERM_DISPLAY_INACTIVE) {
ret = uterm_display_activate(iter, NULL);
if (ret)
continue;
}
mode = uterm_display_get_current(iter);
y = uterm_mode_get_height(mode);
if (y > con->max_y)
con->max_y = y;
}
kmscon_console_resize(con->con, 0, 0, con->max_y);
schedule_draw(con);
}
static void sig_term(struct ev_signal *sig, int signum, void *data)
{
terminate = 1;
}
static bool vt_switch(struct kmscon_vt *vt,
enum kmscon_vt_action action,
void *data)
{
struct console *con = data;
int ret;
if (action == KMSCON_VT_ENTER) {
ret = uterm_video_wake_up(con->video);
if (!ret)
activate_outputs(con);
} else {
uterm_video_sleep(con->video);
}
return true;
}
static const char help_text[] =
"test_console - KMS based console test\n"
"This application can be used to test the console subsystem. It copies stdin "
"to the console so you can use it to print arbitrary text like this:\n"
" ls -la / | sudo ./test_console\n"
"Please be aware that the application needs root rights to access the VT. "
"If no VT support is compiled in you can run it without root rights but you "
"should not start it from inside X!\n\n";
static void print_help(struct console *con)
{
unsigned int i, len;
kmscon_symbol_t ch;
len = sizeof(help_text) - 1;
for (i = 0; i < len; ++i) {
if (help_text[i] == '\n') {
kmscon_console_newline(con->con);
} else {
ch = help_text[i];
kmscon_console_write(con->con, ch);
}
}
}
static void destroy_eloop(struct console *con)
{
ev_eloop_rm_idle(con->idle);
ev_idle_unref(con->idle);
kmscon_console_unref(con->con);
gl_shader_unref(con->shader);
uterm_video_unref(con->video);
kmscon_vt_unref(con->vt);
kmscon_font_factory_unref(con->ff);
kmscon_symbol_table_unref(con->st);
ev_eloop_rm_fd(con->stdin_fd);
ev_eloop_rm_signal(con->sig_int);
ev_eloop_rm_signal(con->sig_term);
ev_eloop_unref(con->loop);
}
static int setup_eloop(struct console *con)
{
int ret;
ret = ev_eloop_new(&con->loop);
if (ret)
return ret;
ret = ev_eloop_new_signal(con->loop, &con->sig_term, SIGTERM,
sig_term, NULL);
if (ret)
goto err_loop;
ret = ev_eloop_new_signal(con->loop, &con->sig_int, SIGINT,
sig_term, NULL);
if (ret)
goto err_loop;
ret = ev_eloop_new_fd(con->loop, &con->stdin_fd, 0,
EV_READABLE, stdin_cb, con);
if (ret)
goto err_loop;
ret = kmscon_symbol_table_new(&con->st);
if (ret)
goto err_loop;
ret = uterm_video_new(&con->video, UTERM_VIDEO_DRM, con->loop);
if (ret)
goto err_loop;
ret = gl_shader_new(&con->shader);
if (ret)
goto err_loop;
ret = kmscon_font_factory_new(&con->ff, con->st);
if (ret)
goto err_loop;
ret = kmscon_vt_new(&con->vt, vt_switch, con);
if (ret)
goto err_loop;
ret = kmscon_vt_open(con->vt, KMSCON_VT_NEW, con->loop);
if (ret)
goto err_loop;
ret = kmscon_console_new(&con->con, con->ff);
if (ret)
goto err_loop;
ret = ev_idle_new(&con->idle);
if (ret)
goto err_loop;
print_help(con);
return 0;
err_loop:
destroy_eloop(con);
return ret;
}
int main(int argc, char **argv)
{
struct console con;
int ret;
setlocale(LC_ALL, "");
memset(&con, 0, sizeof(con));
ret = setup_eloop(&con);
if (ret) {
log_err("Cannot setup eloop\n");
return abs(ret);
}
log_info("Starting console\n");
schedule_draw(&con);
while (!terminate) {
ret = ev_eloop_dispatch(con.loop, -1);
if (ret)
break;
}
log_info("Stopping console\n");
destroy_eloop(&con);
return abs(ret);
}