blob: 37955474915f2708254b2fea7ffd91843b833f4f [file] [log] [blame]
/*******************************************************************************
* Copyright (C) 2010, Linaro Limited.
*
* This file is part of PowerDebug.
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Amit Arora <amit.arora@linaro.org> (IBM Corporation)
* - initial API and implementation
*******************************************************************************/
#include "powerdebug.h"
#include "regulator.h"
#include "display.h"
#define print(w, x, y, fmt, args...) do { mvwprintw(w, y, x, fmt, ##args); } while (0)
#define NUM_FOOTER_ITEMS 5
enum { PT_COLOR_DEFAULT = 1,
PT_COLOR_HEADER_BAR,
PT_COLOR_ERROR,
PT_COLOR_RED,
PT_COLOR_YELLOW,
PT_COLOR_GREEN,
PT_COLOR_BRIGHT,
PT_COLOR_BLUE,
};
static WINDOW *header_win;
static WINDOW *regulator_win;
static WINDOW *clock_pad;
static WINDOW *clock_labels;
static WINDOW *sensor_win;
static WINDOW *footer_win;
int maxx, maxy;
/* Number of lines in the virtual window */
static const int maxrows = 1024;
static char footer_items[NUM_FOOTER_ITEMS][64];
struct rowdata {
int attr;
void *data;
};
struct windata {
struct rowdata *rowdata;
char *name;
int nrdata;
int scrolling;
int cursor;
};
struct windata windata[TOTAL_FEATURE_WINS] = {
{ .name = "Clocks" },
{ .name = "Regulators" },
{ .name = "Sensors" },
};
static void display_fini(void)
{
endwin();
}
int display_init(void)
{
if (!initscr())
return -1;
start_color();
use_default_colors();
keypad(stdscr, TRUE);
noecho();
cbreak();
curs_set(0);
nonl();
if (init_pair(PT_COLOR_DEFAULT, COLOR_WHITE, COLOR_BLACK) ||
init_pair(PT_COLOR_ERROR, COLOR_BLACK, COLOR_RED) ||
init_pair(PT_COLOR_HEADER_BAR, COLOR_WHITE, COLOR_BLACK) ||
init_pair(PT_COLOR_YELLOW, COLOR_WHITE, COLOR_YELLOW) ||
init_pair(PT_COLOR_GREEN, COLOR_WHITE, COLOR_GREEN) ||
init_pair(PT_COLOR_BRIGHT, COLOR_WHITE, COLOR_BLACK) ||
init_pair(PT_COLOR_BLUE, COLOR_WHITE, COLOR_BLUE) ||
init_pair(PT_COLOR_RED, COLOR_WHITE, COLOR_RED))
return -1;
if (atexit(display_fini))
return -1;
getmaxyx(stdscr, maxy, maxx);
regulator_win = subwin(stdscr, maxy - 2, maxx, 1, 0);
if (!regulator_win)
return -1;
clock_labels = subwin(stdscr, maxy - 2, maxx, 1, 0);
if (!clock_labels)
return -1;
clock_pad = newpad(maxrows, maxx);
if (!clock_pad)
return -1;
sensor_win = subwin(stdscr, maxy - 2, maxx, 1, 0);
if (!sensor_win)
return -1;
header_win = subwin(stdscr, 1, maxx, 0, 0);
if (!header_win)
return -1;
footer_win = subwin(stdscr, 1, maxx, maxy-1, 0);
if (!footer_win)
return -1;
return 0;
}
void create_windows(int selectedwindow)
{
strcpy(footer_items[0], " Q (Quit) ");
strcpy(footer_items[1], " R (Refresh) ");
if (selectedwindow == CLOCK)
strcpy(footer_items[2], " Other Keys: 'Left', 'Right', 'Up', 'Down', 'enter', "
" '/', 'Esc' ");
else
strcpy(footer_items[2], " Other Keys: 'Left', 'Right' ");
strcpy(footer_items[3], "");
werase(stdscr);
refresh();
}
void create_selectedwindow(int selectedwindow)
{
switch (selectedwindow) {
case REGULATOR:
wrefresh(regulator_win);
break;
case SENSOR:
wrefresh(sensor_win);
break;
}
}
void show_header(int selectedwindow)
{
int i, j = 0;
int curr_pointer = 0;
wattrset(header_win, COLOR_PAIR(PT_COLOR_HEADER_BAR));
wbkgd(header_win, COLOR_PAIR(PT_COLOR_HEADER_BAR));
werase(header_win);
print(header_win, curr_pointer, 0, "PowerDebug %s", VERSION);
curr_pointer += 20;
for (i = 0; i < TOTAL_FEATURE_WINS; i++) {
if (selectedwindow == i)
wattron(header_win, A_REVERSE);
else
wattroff(header_win, A_REVERSE);
print(header_win, curr_pointer, 0, " %s ", windata[i].name);
curr_pointer += strlen(windata[i].name) + 2;
}
wrefresh(header_win);
werase(footer_win);
for (i = 0; i < NUM_FOOTER_ITEMS; i++) {
if (strlen(footer_items[i]) == 0)
continue;
wattron(footer_win, A_REVERSE);
print(footer_win, j, 0, "%s", footer_items[i]);
wattroff(footer_win, A_REVERSE);
j+= strlen(footer_items[i])+1;
}
wrefresh(footer_win);
}
void print_regulator_header(void)
{
werase(regulator_win);
wattron(regulator_win, A_BOLD);
print(regulator_win, 0, 0, "Name");
print(regulator_win, 12, 0, "Status");
print(regulator_win, 24, 0, "State");
print(regulator_win, 36, 0, "Type");
print(regulator_win, 48, 0, "Users");
print(regulator_win, 60, 0, "Microvolts");
print(regulator_win, 72, 0, "Min u-volts");
print(regulator_win, 84, 0, "Max u-volts");
wattroff(regulator_win, A_BOLD);
wrefresh(regulator_win);
}
void print_clock_header(void)
{
werase(clock_labels);
wattron(clock_labels, A_BOLD);
print(clock_labels, 0, 0, "Name");
print(clock_labels, 56, 0, "Flags");
print(clock_labels, 75, 0, "Rate");
print(clock_labels, 88, 0, "Usecount");
print(clock_labels, 98, 0, "Children");
wattroff(clock_labels, A_BOLD);
wrefresh(clock_labels);
}
#if 0
void show_regulator_info(struct regulator_info *reg_info, int nr_reg, int verbose)
{
int i, count = 1;
print_regulator_header();
wrefresh(regulator_win);
return;
(void)verbose;
for (i = 0; i < nr_reg; i++) {
int col = 0;
if ((i + 2) > (maxy-2))
break;
if (reg_info[i].num_users > 0)
wattron(regulator_win, WA_BOLD);
else
wattroff(regulator_win, WA_BOLD);
print(regulator_win, col, count, "%s",
reg_info[i].name);
col += 12;
print(regulator_win, col, count, "%s",
reg_info[i].status);
col += 12;
print(regulator_win, col, count, "%s",
reg_info[i].state);
col += 12;
print(regulator_win, col, count, "%s",
reg_info[i].type);
col += 12;
print(regulator_win, col, count, "%d",
reg_info[i].num_users);
col += 12;
print(regulator_win, col, count, "%d",
reg_info[i].microvolts);
col += 12;
print(regulator_win, col, count, "%d",
reg_info[i].min_microvolts);
col += 12;
print(regulator_win, col, count, "%d",
reg_info[i].max_microvolts);
count++;
}
wrefresh(regulator_win);
}
#endif
void print_sensor_header(void)
{
werase(sensor_win);
wattron(sensor_win, A_BOLD);
print(sensor_win, 0, 0, "Name");
print(sensor_win, 36, 0, "Temperature");
wattroff(sensor_win, A_BOLD);
wattron(sensor_win, A_BLINK);
print(sensor_win, 0, 1, "Currently Sensor information available"
" only in Dump mode!");
wattroff(sensor_win, A_BLINK);
wrefresh(sensor_win);
}
int display_refresh_pad(int win)
{
return prefresh(clock_pad, windata[win].scrolling,
0, 2, 0, maxy - 2, maxx);
}
static int inline display_clock_un_select(int win, int line,
bool highlight, bool bold)
{
if (mvwchgat(clock_pad, line, 0, -1,
highlight ? WA_STANDOUT :
bold ? WA_BOLD: WA_NORMAL, 0, NULL) < 0)
return -1;
return display_refresh_pad(win);
}
int display_select(int win, int line)
{
return display_clock_un_select(win, line, true, false);
}
int display_unselect(int win, int line, bool bold)
{
return display_clock_un_select(win, line, false, bold);
}
void *display_get_row_data(int win)
{
return windata[win].rowdata[windata[win].cursor].data;
}
int display_set_row_data(int win, int line, void *data, int attr)
{
struct rowdata *rowdata = windata[win].rowdata;
if (line >= windata[win].nrdata) {
rowdata = realloc(rowdata, sizeof(struct rowdata) * (line + 1));
if (!rowdata)
return -1;
windata[win].nrdata = line + 1;
}
rowdata[line].data = data;
rowdata[line].attr = attr;
windata[win].rowdata = rowdata;
return 0;
}
int display_reset_cursor(win)
{
windata[win].nrdata = 0;
werase(clock_pad);
return wmove(clock_pad, 0, 0);
}
int display_print_line(int win, int line, char *str, int bold, void *data)
{
int attr = 0;
if (bold)
attr |= WA_BOLD;
if (line == windata[win].cursor)
attr |= WA_STANDOUT;
if (display_set_row_data(win, line, data, attr))
return -1;
if (attr)
wattron(clock_pad, attr);
wprintw(clock_pad, "%s\n", str);
if (attr)
wattroff(clock_pad, attr);
return 0;
}
int display_next_line(int win)
{
int cursor = windata[win].cursor;
int nrdata = windata[win].nrdata;
int scrolling = windata[win].scrolling;
struct rowdata *rowdata = windata[win].rowdata;
if (cursor >= nrdata)
return cursor;
display_unselect(win, cursor, rowdata[cursor].attr);
if (cursor < nrdata - 1) {
if (cursor >= (maxy - 4 + scrolling))
scrolling++;
cursor++;
}
display_select(win, cursor);
windata[win].scrolling = scrolling;
windata[win].cursor = cursor;
return cursor;
}
int display_prev_line(int win)
{
int cursor = windata[win].cursor;
int nrdata = windata[win].nrdata;
int scrolling = windata[win].scrolling;
struct rowdata *rowdata = windata[win].rowdata;
if (cursor >= nrdata)
return cursor;
display_unselect(win, cursor, rowdata[cursor].attr);
if (cursor > 0) {
if (cursor <= scrolling)
scrolling--;
cursor--;
}
display_select(win, cursor);
windata[win].scrolling = scrolling;
windata[win].cursor = cursor;
return cursor;
}