/*

* userui_text.c - Text mode userspace user interface module.

*

* Copyright (C) 2005, Bernard Blackham <bernard@blackham.com.au>

* Copyright (C) 2006-2009, Nigel Cunningham <nigel@tuxonice.net>

*

* Based on the suspend_text module from Suspend2, written by

* Nigel Cunningham <nigel@nigel.tuxonice.net>

*

* This file is subject to the terms and conditions of the GNU General Public

* License v2. See the file COPYING in the main directory of this archive for

* more details.

*

*/

#include <sys/ioctl.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <string.h>

#include <stdarg.h>

#include <stdio.h>

#include <stdlib.h>

#include <termios.h>

#include <unistd.h>

#include "userui.h"

/* We essentially cut and paste the suspend_text plugin */

static int barwidth = 0, barposn = -1;

static int draw_progress_bar = 1;

static struct termios termios;

static int lastloglevel = -1;

static int cur_x = -1, cur_y = -1;

static int vcsa_fd = -1;

static inline void clear_display() { if (write(1, "\033[2J", 4)) do {} while(0); }

static inline void reset_display() { if (write(1, "\033c", 2)) do {} while(0); }

static inline void clear_to_eol() { if (write(1, "\033K", 2)) do {} while(0); }

static inline void hide_cursor() { if (write(1, "\033[?25l\033[?1c", 11)) do {} while(0); }

static inline void show_cursor() { if (write(1, "\033[?25h\033[?0c", 11)) do {} while(0); }

static inline void move_cursor_to(int c, int r) { printf("\033[%d;%dH", r, c); }

static void flush_scrollback()

{

int i;

for (i = 0; i <= video_num_lines; i++)

if (write(1, "\n", 1)) do {

} while(0);

}

static int update_cursor_pos(void)

{

struct {

unsigned char lines, cols, x, y;

} screen;

if (vcsa_fd < 0)

return 0;

if (lseek(vcsa_fd, 0, SEEK_SET) == -1)

return 0;

if (read(vcsa_fd, &screen, sizeof(screen)) == -1)

return 0;

cur_x = screen.x+1;

cur_y = screen.y+1;

return 1;

}

/*

* Help text functions.

*/

static void update_help(int update_all)

{

char buf[200];

if (resuming)

snprintf(buf, 200, "%-22s",

(can_use_escape) ? "Esc: Abort resume" : "");

else

snprintf(buf, 200, "%-22s R: %s reboot after hibernating ",

(can_use_escape) ? "Esc: Abort hibernating" : "",

(suspend_action & (1 << SUSPEND_REBOOT)) ? "Disable":" Enable");

move_cursor_to(video_num_columns - strlen(buf), video_num_lines);

printf("%s", buf);

}

/* text_prepare_status

* Description: Prepare the 'nice display', drawing the header and version,

* along with the current action and perhaps also resetting the

* progress bar.

* Arguments: int printalways: Whether to print the action when debugging

* is on

* int clearbar: Whether to reset the progress bar.

* const char *fmt, ...: The action to be displayed.

*/

static void text_prepare_status_real(int printalways, int clearbar, int level, const char *msg)

{

int y, i;

if (msg) {

strncpy(lastheader, msg, 512);

lastheader[511] = '\0';

}

if (console_loglevel >= SUSPEND_ERROR) {

if (!(suspend_action & (1 << SUSPEND_LOGALL)) || level == SUSPEND_UI_MSG)

printf("\n** %s\n", lastheader);

return;

}

/* Remember where the cursor was */

if (cur_x != -1)

update_cursor_pos();

/* Print version */

move_cursor_to(0, video_num_lines);

printf("%s", software_suspend_version);

/* Update help text */

update_help(0);

/* Print header */

move_cursor_to((video_num_columns - 19) / 2, (video_num_lines / 3) - 3);

printf("T U X O N I C E");

/* Print action */

y = video_num_lines / 3;

move_cursor_to(0, y);

/* Clear old message */

for (i = 0; i < video_num_columns; i++)

printf(" ");

move_cursor_to((video_num_columns - strlen(lastheader)) / 2, y);

printf("%s", lastheader);

if (draw_progress_bar) {

/* Draw left bracket of progress bar. */

y++;

move_cursor_to(video_num_columns / 4, y);

printf("[");

/* Draw right bracket of progress bar. */

move_cursor_to(video_num_columns - (video_num_columns / 4) - 1, y);

printf("]");

if (clearbar) {

/* Position at start of progress */

move_cursor_to(video_num_columns / 4 + 1, y);

/* Clear bar */

for (i = 0; i < barwidth; i++)

printf(" ");

move_cursor_to(video_num_columns / 4 + 1, y);

barposn = 0;

}

}

if (cur_x == -1) {

cur_x = 1;

cur_y = y+2;

}

move_cursor_to(cur_x, cur_y);

hide_cursor();

}

static void text_prepare_status(int printalways, int clearbar, int level, const char *fmt, ...)

{

va_list va;

char buf[1024];

if (fmt) {

va_start(va, fmt);

vsnprintf(buf, 1024, fmt, va);

text_prepare_status_real(printalways, clearbar, level, buf);

va_end(va);

} else

text_prepare_status_real(printalways, clearbar, level, NULL);

}

/* text_loglevel_change

*

* Description: Update the display when the user changes the log level.

* Returns: Boolean indicating whether the level was changed.

*/

static void text_loglevel_change()

{

/* Only reset the display if we're switching between nice display

* and displaying debugging output */

if (console_loglevel >= SUSPEND_ERROR) {

if (lastloglevel < SUSPEND_ERROR)

clear_display();

show_cursor();

if (lastloglevel > -1)

printf("\nSwitched to console loglevel %d.\n", console_loglevel);

if (lastloglevel > -1 && lastloglevel < SUSPEND_ERROR) {

printf("\n** %s\n", lastheader);

}

} else if (lastloglevel >= SUSPEND_ERROR || lastloglevel == -1) {

clear_display();

hide_cursor();

/* Get the nice display or last action [re]drawn */

text_prepare_status(1, 0, SUSPEND_UI_MSG, NULL);

}

lastloglevel = console_loglevel;

}

/* text_update_progress

*

* Description: Update the progress bar and (if on) in-bar message.

* Arguments: U32 value, maximum: Current progress percentage (value/max).

* const char *fmt, ...: Message to be displayed in the middle

* of the progress bar.

* Note that a NULL message does not mean that any previous

* message is erased! For that, you need prepare_status with

* clearbar on.

* Returns: Unsigned long: The next value where status needs to be updated.

* This is to reduce unnecessary calls to text_update_progress.

*/

void text_update_progress(uint32_t value, uint32_t maximum, char *msg)

{

int bitshift = generic_fls(maximum) - 16, i;

int msg_len = msg ? strlen(msg) : 0;

int msg_start = (video_num_columns - msg_len - 2) / 2 -

(video_num_columns / 4 + 1);

char bar_char = '-';

if (!maximum)

return /* maximum */;

if (value < 0)

value = 0;

if (value > maximum)

value = maximum;

/* Try to avoid math problems - we can't do 64 bit math here

* (and shouldn't need it - anyone got screen resolution

* of 65536 pixels or more?) */

if (bitshift > 0) {

uint32_t temp_maximum = maximum >> bitshift;

uint32_t temp_value = value >> bitshift;

barposn = (uint32_t) (temp_value * barwidth / temp_maximum);

} else

barposn = (uint32_t) (value * barwidth / maximum);

if ((console_loglevel >= SUSPEND_ERROR) || (!draw_progress_bar))

return;

/* Remember where the cursor was */

if (cur_x != -1)

update_cursor_pos();

/* Update bar */

if (msg_start < 0) {

move_cursor_to((video_num_columns - msg_len) / 2,

(video_num_lines / 3) + 1);

printf(" %s ", msg);

} else {

move_cursor_to(video_num_columns / 4 + 1, (video_num_lines / 3) + 1);

for (i = 0; i < barwidth; i++) {

if (i == barposn)

bar_char = ' ';

if (i == msg_start && msg_len && console_loglevel) {

printf(" %s ", msg);

i += msg_len + 2;

if (i >= barposn)

bar_char = ' ';

} else

printf("%c", bar_char);

}

}

if (cur_x != -1)

move_cursor_to(cur_x, cur_y);

hide_cursor();

}

static void text_message(uint32_t section, uint32_t level,

uint32_t normally_logged, char *msg)

{

if (section && !((1 << section) & suspend_debug))

return;

if (level > console_loglevel)

return;

text_prepare_status_real(1, 0, level, msg);

}

static int text_load()

{

struct winsize winsz;

struct termios new_termios;

lastloglevel = SUSPEND_ERROR; /* start in verbose mode */

setvbuf(stdout, NULL, _IONBF, 0);

/* Turn off canonical mode */

ioctl(STDOUT_FILENO, TCGETS, (long)&termios);

new_termios = termios;

new_termios.c_lflag &= ~ICANON;

ioctl(STDOUT_FILENO, TCSETSF, (long)&new_termios);

/* Find out the screen size */

video_num_lines = 24;

video_num_columns = 80;

if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &winsz) != -1 &&

winsz.ws_row > 0 && winsz.ws_col > 0) {

video_num_lines = winsz.ws_row;

video_num_columns = winsz.ws_col;

printk("Console is %dx%d.\n", video_num_lines, video_num_columns);

}

/* Calculate progress bar width. Note that whether the

* splash screen is on might have changed (this might be

* the first call in a new cycle), so we can't take it

* for granted that the width is the same as last time

* we came in here */

barwidth = (video_num_columns - 2 * (video_num_columns / 4) - 2);

/* Open /dev/vcsa0 so we can find out the cursor position when we need to */

vcsa_fd = open("/dev/vcsa0", O_RDONLY);

/* if it errors, don't worry. we'll check later */

return 0;

}

static void text_prepare()

{

clear_display();

lastloglevel = -1;

text_loglevel_change();

}

static void text_unprepare()

{

clear_display();

move_cursor_to(0, 0);

}

static void text_cleanup()

{

text_unprepare();

show_cursor();

if (vcsa_fd >= 0)

close(vcsa_fd);

ioctl(STDOUT_FILENO, TCSETSF, (long)&termios);

/* chvt back? */

}

static void text_redraw()

{

clear_display();

reset_display();

flush_scrollback();

cur_x = -1;

}

static void text_keypress(int key)

{

if (common_keypress_handler(key))

return;

switch (key) {

}

}

struct userui_ops userui_text_ops = {

.name = "text",

.load = text_load,

.prepare = text_prepare,

.unprepare = text_unprepare,

.cleanup = text_cleanup,

.message = text_message,

.update_progress = text_update_progress,

.log_level_change = text_loglevel_change,

.redraw = text_redraw,

.keypress = text_keypress,

};