Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 9f1362d4 in mainline


Ignore:
Timestamp:
2010-04-19T19:58:18Z (12 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master
Children:
369a5f8
Parents:
caad59a
Message:

console output improvements

  • define new generic styles (STYLE_INVERTED for inverted print and STYLE_SELECTION for selections), use them primarily instead of specifying colors or RGBs
  • use console_set_style(fphone(stdout), STYLE_NORMAL) as the correct mean for reseting console settings (instead of specifying conrete hardcoded colors)
  • rename console_goto() to console_set_pos() (consistency with console_get_pos())
  • use semantically correct unsigned types for console sizes and cursor positions (instead of signed types)
  • use unsigned types for sizes and positions in libclui
  • top: nicer screen redrawing (do not use console_clear() which causes flickering, but repaint the screen properly — not entirely finished yet)
  • initialize mouse pointer coordinates (so the mouse cursor does not behave erratic after boot, unfortunatelly this does not solve ticket #223)
Location:
uspace
Files:
19 edited

Legend:

Unmodified
Added
Removed
  • uspace/app/edit/edit.c

    rcaad59a r9f1362d4  
    4040#include <vfs/vfs.h>
    4141#include <io/console.h>
    42 #include <io/color.h>
     42#include <io/style.h>
    4343#include <io/keycode.h>
    4444#include <errno.h>
     
    100100static bool cursor_visible;
    101101
    102 static int scr_rows, scr_columns;
     102static ipcarg_t scr_rows;
     103static ipcarg_t scr_columns;
    103104
    104105#define ROW_BUF_SIZE 4096
     
    505506        asprintf(&str, "%s: %s", prompt, init_value);
    506507        status_display(str);
    507         console_goto(con, 1 + str_length(str), scr_rows - 1);
     508        console_set_pos(con, 1 + str_length(str), scr_rows - 1);
    508509        free(str);
    509510
    510         console_set_color(con, COLOR_WHITE, COLOR_BLACK, 0);
     511        console_set_style(con, STYLE_INVERTED);
    511512
    512513        max_len = min(INFNAME_MAX_LEN, scr_columns - 4 - str_length(prompt));
     
    552553        str = wstr_to_astr(buffer);
    553554
    554         console_set_color(con, COLOR_BLACK, COLOR_WHITE, 0);
     555        console_set_style(con, STYLE_NORMAL);
    555556
    556557        return str;
     
    671672{
    672673        int sh_rows, rows;
    673         int i, j;
    674674
    675675        sheet_get_num_rows(&doc.sh, &sh_rows);
     
    678678        /* Draw rows from the sheet. */
    679679
    680         console_goto(con, 0, 0);
     680        console_set_pos(con, 0, 0);
    681681        pane_row_range_display(0, rows);
    682682
    683683        /* Clear the remaining rows if file is short. */
    684 
     684       
     685        int i;
     686        ipcarg_t j;
    685687        for (i = rows; i < pane.rows; ++i) {
    686                 console_goto(con, 0, i);
     688                console_set_pos(con, 0, i);
    687689                for (j = 0; j < scr_columns; ++j)
    688690                        putchar(' ');
     
    736738        /* Draw rows from the sheet. */
    737739
    738         console_goto(con, 0, 0);
     740        console_set_pos(con, 0, 0);
    739741        for (i = r0; i < r1; ++i) {
    740742                /* Starting point for row display */
     
    756758                    coord_cmp(&rbc, &csel_end) < 0) {
    757759                        fflush(stdout);
    758                         console_set_color(con, COLOR_BLACK, COLOR_RED, 0);
     760                        console_set_style(con, STYLE_SELECTED);
    759761                        fflush(stdout);
    760762                }
    761763
    762                 console_goto(con, 0, i);
     764                console_set_pos(con, 0, i);
    763765                size = str_size(row_buf);
    764766                pos = 0;
     
    767769                        if ((csel_start.row == rbc.row) && (csel_start.column == s_column)) {
    768770                                fflush(stdout);
    769                                 console_set_color(con, COLOR_BLACK, COLOR_RED, 0);
     771                                console_set_style(con, STYLE_SELECTED);
    770772                                fflush(stdout);
    771773                        }
     
    773775                        if ((csel_end.row == rbc.row) && (csel_end.column == s_column)) {
    774776                                fflush(stdout);
    775                                 console_set_color(con, COLOR_BLACK, COLOR_WHITE, 0);
     777                                console_set_style(con, STYLE_NORMAL);
    776778                                fflush(stdout);
    777779                        }
     
    793795                if ((csel_end.row == rbc.row) && (csel_end.column == s_column)) {
    794796                        fflush(stdout);
    795                         console_set_color(con, COLOR_BLACK, COLOR_WHITE, 0);
     797                        console_set_style(con, STYLE_NORMAL);
    796798                        fflush(stdout);
    797799                }
     
    807809                        putchar(' ');
    808810                fflush(stdout);
    809                 console_set_color(con, COLOR_BLACK, COLOR_WHITE, 0);
     811                console_set_style(con, STYLE_NORMAL);
    810812        }
    811813
     
    824826        const char *fname = (doc.file_name != NULL) ? doc.file_name : "<unnamed>";
    825827
    826         console_goto(con, 0, scr_rows - 1);
    827         console_set_color(con, COLOR_WHITE, COLOR_BLACK, 0);
     828        console_set_pos(con, 0, scr_rows - 1);
     829        console_set_style(con, STYLE_INVERTED);
    828830        int n = printf(" %d, %d: File '%s'. Ctrl-Q Quit  Ctrl-S Save  "
    829831            "Ctrl-E Save As", coord.row, coord.column, fname);
    830832        printf("%*s", scr_columns - 1 - n, "");
    831833        fflush(stdout);
    832         console_set_color(con, COLOR_BLACK, COLOR_WHITE, 0);
     834        console_set_style(con, STYLE_NORMAL);
    833835
    834836        pane.rflags |= REDRAW_CARET;
     
    844846
    845847        spt_get_coord(&caret_pt, &coord);
    846         console_goto(con, coord.column - pane.sh_column,
     848        console_set_pos(con, coord.column - pane.sh_column,
    847849            coord.row - pane.sh_row);
    848850}
     
    11491151static void status_display(char const *str)
    11501152{
    1151         console_goto(con, 0, scr_rows - 1);
    1152         console_set_color(con, COLOR_WHITE, COLOR_BLACK, 0);
     1153        console_set_pos(con, 0, scr_rows - 1);
     1154        console_set_style(con, STYLE_INVERTED);
    11531155        printf(" %*s ", -(scr_columns - 3), str);
    11541156        fflush(stdout);
    1155         console_set_color(con, COLOR_BLACK, COLOR_WHITE, 0);
     1157        console_set_style(con, STYLE_NORMAL);
    11561158
    11571159        pane.rflags |= REDRAW_CARET;
  • uspace/app/tester/console/console1.c

    rcaad59a r9f1362d4  
    5353                fflush(stdout);
    5454                console_set_style(fphone(stdout), STYLE_NORMAL);
    55                 printf("normal ");
     55                printf(" normal ");
    5656                fflush(stdout);
    5757                console_set_style(fphone(stdout), STYLE_EMPHASIS);
    58                 printf("emphasized");
     58                printf(" emphasized ");
     59                fflush(stdout);
     60                console_set_style(fphone(stdout), STYLE_INVERTED);
     61                printf(" inverted ");
     62                fflush(stdout);
     63                console_set_style(fphone(stdout), STYLE_SELECTED);
     64                printf(" selected ");
    5965                fflush(stdout);
    6066                console_set_style(fphone(stdout), STYLE_NORMAL);
    61                 printf(".\n");
     67                printf("\n");
    6268               
    6369                unsigned int i;
     
    7379                        }
    7480                        fflush(stdout);
    75                         console_set_color(fphone(stdout), COLOR_BLACK, COLOR_WHITE, 0);
     81                        console_set_style(fphone(stdout), STYLE_NORMAL);
    7682                        putchar('\n');
    7783                }
     
    8692                        }
    8793                        fflush(stdout);
    88                         console_set_color(fphone(stdout), COLOR_BLACK, COLOR_WHITE, 0);
     94                        console_set_style(fphone(stdout), STYLE_NORMAL);
    8995                        putchar('\n');
    9096                }
     
    94100                for (i = 0; i < 255; i += 16) {
    95101                        fflush(stdout);
    96                         console_set_rgb_color(fphone(stdout), 0xffffff, i << 16);
     102                        console_set_rgb_color(fphone(stdout), (255 - i) << 16, i << 16);
    97103                        putchar('X');
    98104                }
     
    103109                for (i = 0; i < 255; i += 16) {
    104110                        fflush(stdout);
    105                         console_set_rgb_color(fphone(stdout), 0xffffff, i << 8);
     111                        console_set_rgb_color(fphone(stdout), (255 - i) << 8, i << 8);
    106112                        putchar('X');
    107113                }
     
    112118                for (i = 0; i < 255; i += 16) {
    113119                        fflush(stdout);
    114                         console_set_rgb_color(fphone(stdout), 0xffffff, i);
     120                        console_set_rgb_color(fphone(stdout), 255 - i, i);
    115121                        putchar('X');
    116122                }
    117123                fflush(stdout);
    118                 console_set_color(fphone(stdout), COLOR_BLACK, COLOR_WHITE, 0);
     124                console_set_style(fphone(stdout), STYLE_NORMAL);
    119125                putchar('\n');
    120126        }
  • uspace/app/tetris/screen.c

    rcaad59a r9f1362d4  
    5353#include <vfs/vfs.h>
    5454#include <async.h>
     55#include <bool.h>
     56#include <io/console.h>
     57#include <io/style.h>
    5558#include "screen.h"
    5659#include "tetris.h"
    57 #include <io/console.h>
    5860
    5961#define STOP  (B_COLS - 3)
     
    6365static int isset;               /* true => terminal is in game mode */
    6466
    65 static int use_color;           /* true => use colors */
     67static bool use_color;          /* true => use colors */
    6668
    6769static const struct shape *lastshape;
     
    8183{
    8284        fflush(stdout);
    83         console_set_rgb_color(fphone(stdout), 0xf0f0f0,
     85        console_set_rgb_color(fphone(stdout), 0xffffff,
    8486            use_color ? color : 0x000000);
    8587}
     
    8890{
    8991        fflush(stdout);
    90         console_set_rgb_color(fphone(stdout), 0, 0xf0f0f0);
     92        console_set_style(fphone(stdout), STYLE_NORMAL);
    9193}
    9294
     
    118120}
    119121
    120 void moveto(int r, int c)
     122void moveto(ipcarg_t r, ipcarg_t c)
    121123{
    122124        fflush(stdout);
    123         console_goto(fphone(stdout), c, r);
     125        console_set_pos(fphone(stdout), c, r);
    124126}
    125127
     
    131133}
    132134
    133 static int get_display_color_sup(void)
    134 {
    135         int rc;
    136         int ccap;
    137 
    138         rc = console_get_color_cap(fphone(stdout), &ccap);
     135static bool get_display_color_sup(void)
     136{
     137        ipcarg_t ccap;
     138        int rc = console_get_color_cap(fphone(stdout), &ccap);
     139       
    139140        if (rc != 0)
    140                 return 0;
    141 
     141                return false;
     142       
    142143        return (ccap >= CONSOLE_CCAP_RGB);
    143144}
     
    308309 * (We need its length in case we have to overwrite with blanks.)
    309310 */
    310 void scr_msg(char *s, int set)
     311void scr_msg(char *s, bool set)
    311312{
    312313        int l = str_size(s);
  • uspace/app/tetris/screen.h

    rcaad59a r9f1362d4  
    4848
    4949#include <sys/types.h>
     50#include <ipc/ipc.h>
    5051#include <async.h>
     52#include <bool.h>
    5153
    5254typedef struct {
    53         int ws_row;
    54         int ws_col;
     55        ipcarg_t ws_row;
     56        ipcarg_t ws_col;
    5557} winsize_t;
    5658
    5759extern winsize_t winsize;
    5860
    59 extern void moveto(int r, int c);
     61extern void moveto(ipcarg_t r, ipcarg_t c);
    6062extern void clear_screen(void);
    6163
     
    6567extern void scr_end(void);
    6668extern void scr_init(void);
    67 extern void scr_msg(char *, int);
     69extern void scr_msg(char *, bool);
    6870extern void scr_set(void);
    6971extern void scr_update(void);
  • uspace/app/top/screen.c

    rcaad59a r9f1362d4  
    3737
    3838#include <stdio.h>
     39#include <ipc/ipc.h>
    3940#include <io/console.h>
     41#include <io/style.h>
    4042#include <vfs/vfs.h>
    4143#include <stdarg.h>
     
    4547#include "top.h"
    4648
    47 #define WHITE  0xf0f0f0
    48 #define BLACK  0x000000
    49 
    50 static int rows;
    51 static int colls;
    52 static int up_rows;
     49static ipcarg_t warn_col = 0;
     50static ipcarg_t warn_row = 0;
     51
     52static void screen_style_normal(void)
     53{
     54        fflush(stdout);
     55        console_set_style(fphone(stdout), STYLE_NORMAL);
     56}
     57
     58static void screen_style_inverted(void)
     59{
     60        fflush(stdout);
     61        console_set_style(fphone(stdout), STYLE_INVERTED);
     62}
     63
     64static void screen_moveto(ipcarg_t col, ipcarg_t row)
     65{
     66        fflush(stdout);
     67        console_set_pos(fphone(stdout), col, row);
     68}
     69
     70static void screen_get_pos(ipcarg_t *col, ipcarg_t *row)
     71{
     72        fflush(stdout);
     73        console_get_pos(fphone(stdout), col, row);
     74}
     75
     76static void screen_get_size(ipcarg_t *col, ipcarg_t *row)
     77{
     78        fflush(stdout);
     79        console_get_size(fphone(stdout), col, row);
     80}
     81
     82static void screen_restart(bool clear)
     83{
     84        screen_style_normal();
     85       
     86        if (clear) {
     87                fflush(stdout);
     88                console_clear(fphone(stdout));
     89        }
     90       
     91        screen_moveto(0, 0);
     92}
     93
     94static void screen_newline(void)
     95{
     96        ipcarg_t cols;
     97        ipcarg_t rows;
     98        screen_get_size(&cols, &rows);
     99       
     100        ipcarg_t c;
     101        ipcarg_t r;
     102        screen_get_pos(&c, &r);
     103       
     104        ipcarg_t i;
     105        for (i = c + 1; i < cols; i++)
     106                puts(" ");
     107       
     108        if (r + 1 < rows)
     109                puts("\n");
     110}
     111
     112void screen_init(void)
     113{
     114        fflush(stdout);
     115        console_cursor_visibility(fphone(stdout), false);
     116       
     117        screen_restart(true);
     118}
     119
     120void screen_done(void)
     121{
     122        screen_restart(true);
     123       
     124        fflush(stdout);
     125        console_cursor_visibility(fphone(stdout), true);
     126}
    53127
    54128static void print_float(fixed_float ffloat, unsigned int precision)
     
    64138}
    65139
    66 static void screen_resume_normal(void)
    67 {
    68         fflush(stdout);
    69         console_set_rgb_color(fphone(stdout), 0, WHITE);
    70 }
    71 
    72 static void screen_moveto(int r, int c)
    73 {
    74         fflush(stdout);
    75         console_goto(fphone(stdout), c, r);
    76 }
    77 
    78 static void screen_clear(void)
    79 {
    80         console_clear(fphone(stdout));
    81         screen_moveto(0, 0);
    82         up_rows = 0;
    83         fflush(stdout);
    84 }
    85 
    86 void screen_init(void)
    87 {
    88         console_cursor_visibility(fphone(stdout), 0);
    89         screen_resume_normal();
    90         screen_clear();
    91        
    92         console_get_size(fphone(stdout), &colls, &rows);
    93 }
    94 
    95 void screen_done(void)
    96 {
    97         screen_resume_normal();
    98         screen_clear();
    99         console_cursor_visibility(fphone(stdout), 1);
    100 }
    101 
    102 static inline void print_time(data_t *data)
    103 {
    104         printf("%02lu:%02lu:%02lu ", data->hours, data->minutes, data->seconds);
    105 }
    106 
    107 static inline void print_uptime(data_t *data)
    108 {
    109         printf("up %u days, %02u:%02u:%02u, ", data->udays, data->uhours,
    110             data->uminutes, data->useconds);
    111 }
    112 
    113 static inline void print_load(data_t *data)
    114 {
    115         printf("load avarage: ");
     140static inline void print_global_head(data_t *data)
     141{
     142        printf("top - %02lu:%02lu:%02lu up %u days, %02u:%02u:%02u, load avarage:",
     143            data->hours, data->minutes, data->seconds,
     144            data->udays, data->uhours, data->uminutes, data->useconds);
    116145       
    117146        size_t i;
    118147        for (i = 0; i < data->load_count; i++) {
     148                puts(" ");
    119149                stats_print_load_fragment(data->load[i], 2);
    120                 printf(" ");
    121         }
     150        }
     151       
     152        screen_newline();
    122153}
    123154
     
    125156{
    126157        printf("tasks: %u total", data->tasks_count);
     158        screen_newline();
    127159}
    128160
     
    137169        size_t invalid = 0;
    138170       
    139        
    140171        size_t i;
    141172        for (i = 0; i < data->threads_count; i++) {
     
    167198            "%u other, %u invalid",
    168199            total, running, ready, sleeping, lingering, other, invalid);
     200        screen_newline();
    169201}
    170202
     
    178210                            data->cpus[i].id, data->cpus[i].frequency_mhz,
    179211                            data->cpus[i].busy_ticks, data->cpus[i].idle_ticks);
    180                         printf(", idle: ");
     212                        puts(", idle: ");
    181213                        print_float(data->cpus_perc[i].idle, 2);
    182                         printf("%%, busy: ");
     214                        puts("%, busy: ");
    183215                        print_float(data->cpus_perc[i].busy, 2);
    184                         printf("%%\n");
     216                        puts("%");
    185217                } else
    186                         printf("cpu%u inactive\n", data->cpus[i].id);
    187                
    188                 up_rows++;
     218                        printf("cpu%u inactive", data->cpus[i].id);
     219               
     220                screen_newline();
    189221        }
    190222}
     
    209241            PRIu64 "%c used, %" PRIu64 "%c free", total, total_suffix,
    210242            unavail, unavail_suffix, used, used_suffix, free, free_suffix);
    211 }
    212 
    213 static inline void print_tasks(data_t *data, int row)
    214 {
    215         size_t i;
    216         for (i = 0; i < data->tasks_count; i++, row++) {
    217                 if (row > rows)
    218                         break;
    219                
     243        screen_newline();
     244}
     245
     246static inline void print_task_head(void)
     247{
     248        screen_style_inverted();
     249        printf("      ID  Threads      Mem      %%Mem %%uCycles %%kCycles  Name");
     250        screen_newline();
     251        screen_style_normal();
     252}
     253
     254static inline void print_tasks(data_t *data)
     255{
     256        ipcarg_t cols;
     257        ipcarg_t rows;
     258        screen_get_size(&cols, &rows);
     259       
     260        ipcarg_t col;
     261        ipcarg_t row;
     262        screen_get_pos(&col, &row);
     263       
     264        size_t i;
     265        for (i = 0; (i < data->tasks_count) && (row < rows); i++, row++) {
    220266                uint64_t virtmem;
    221267                char virtmem_suffix;
     
    224270                printf("%8" PRIu64 " %8u %8" PRIu64 "%c ", data->tasks[i].task_id,
    225271                    data->tasks[i].threads, virtmem, virtmem_suffix);
    226                 printf("   ");
     272                puts("   ");
    227273                print_float(data->tasks_perc[i].virtmem, 2);
    228                 printf("%%   ");
     274                puts("%   ");
    229275                print_float(data->tasks_perc[i].ucycles, 2);
    230                 printf("%%   ");
     276                puts("%   ");
    231277                print_float(data->tasks_perc[i].kcycles, 2);
    232                 printf("%% %s\n", data->tasks[i].name);
    233         }
    234 }
    235 
    236 static inline void print_task_head(void)
    237 {
    238         fflush(stdout);
    239         console_set_rgb_color(fphone(stdout), WHITE, BLACK);
    240        
    241         printf("      ID  Threads      Mem      %%Mem %%uCycles %%kCycles  Name");
    242        
    243         int i;
    244         for (i = 61; i < colls; ++i)
    245                 printf(" ");
    246        
    247         fflush(stdout);
    248         console_set_rgb_color(fphone(stdout), BLACK, WHITE);
     278                printf("%% %s", data->tasks[i].name);
     279               
     280                screen_newline();
     281        }
    249282}
    250283
    251284static inline void print_ipc_head(void)
    252285{
    253         fflush(stdout);
    254         console_set_rgb_color(fphone(stdout), WHITE, BLACK);
    255        
     286        screen_style_inverted();
    256287        printf("      ID Calls sent Calls recv Answs sent Answs recv  IRQn recv       Forw Name");
    257        
    258         int i;
    259         for (i = 80; i < colls; ++i)
    260                 printf(" ");
    261        
    262         fflush(stdout);
    263         console_set_rgb_color(fphone(stdout), BLACK, WHITE);
    264 }
    265 
    266 static inline void print_ipc(data_t *data, int row)
    267 {
    268         size_t i;
    269         for (i = 0; i < data->tasks_count; i++, row++) {
    270                 if (row > rows)
    271                         break;
    272                
     288        screen_newline();
     289        screen_style_normal();
     290}
     291
     292static inline void print_ipc(data_t *data)
     293{
     294        ipcarg_t cols;
     295        ipcarg_t rows;
     296        screen_get_size(&cols, &rows);
     297       
     298        ipcarg_t col;
     299        ipcarg_t row;
     300        screen_get_pos(&col, &row);
     301       
     302        size_t i;
     303        for (i = 0; (i < data->tasks_count) && (row < rows); i++, row++) {
    273304                printf("%8" PRIu64 " %10" PRIu64 " %10" PRIu64 " %10" PRIu64
    274                      " %10" PRIu64 " %10" PRIu64 " %10" PRIu64 " %s\n",
     305                     " %10" PRIu64 " %10" PRIu64 " %10" PRIu64 " %s",
    275306                     data->tasks[i].task_id, data->tasks[i].ipc_info.call_sent,
    276307                     data->tasks[i].ipc_info.call_recieved,
     
    279310                     data->tasks[i].ipc_info.irq_notif_recieved,
    280311                     data->tasks[i].ipc_info.forwarded, data->tasks[i].name);
     312               
     313                screen_newline();
    281314        }
    282315}
     
    284317void print_data(data_t *data)
    285318{
    286         screen_clear();
    287         fflush(stdout);
    288        
    289         printf("top - ");
    290         print_time(data);
    291         print_uptime(data);
    292         print_load(data);
    293        
    294         printf("\n");
    295         up_rows++;
    296        
     319        screen_restart(false);
     320        print_global_head(data);
    297321        print_task_summary(data);
    298        
    299         printf("\n");
    300         up_rows++;
    301        
    302322        print_thread_summary(data);
    303        
    304         printf("\n");
    305         up_rows++;
    306        
    307323        print_cpu_info(data);
    308324        print_physmem_info(data);
    309325       
    310         printf("\n");
    311         up_rows++;
    312        
    313326        /* Empty row for warnings */
    314         printf("\n");
     327        screen_get_pos(&warn_col, &warn_row);
     328        screen_newline();
    315329       
    316330        if (operation_type == OP_IPC) {
    317331                print_ipc_head();
    318                 printf("\n");
    319                 print_ipc(data, up_rows);
     332                print_ipc(data);
    320333        } else {
    321334                print_task_head();
    322                 printf("\n");
    323                 print_tasks(data, up_rows);
     335                print_tasks(data);
    324336        }
    325337       
     
    329341void print_warning(const char *fmt, ...)
    330342{
    331         screen_moveto(up_rows, 0);
     343        screen_moveto(warn_col, warn_row);
    332344       
    333345        va_list args;
     
    336348        va_end(args);
    337349       
     350        screen_newline();
    338351        fflush(stdout);
    339352}
  • uspace/lib/c/generic/io/console.c

    rcaad59a r9f1362d4  
    4545}
    4646
    47 int console_get_size(int phone, int *cols, int *rows)
     47int console_get_size(int phone, ipcarg_t *cols, ipcarg_t *rows)
    4848{
    49         ipcarg_t cols_v;
    50         ipcarg_t rows_v;
    51         int rc;
    52 
    53         rc = async_req_0_2(phone, CONSOLE_GET_SIZE, &cols_v, &rows_v);
    54 
    55         *cols = (int) cols_v;
    56         *rows = (int) rows_v;
    57         return rc;
     49        return async_req_0_2(phone, CONSOLE_GET_SIZE, cols, rows);
    5850}
    5951
    60 void console_set_style(int phone, int style)
     52void console_set_style(int phone, uint8_t style)
    6153{
    6254        async_msg_1(phone, CONSOLE_SET_STYLE, style);
    6355}
    6456
    65 void console_set_color(int phone, int fg_color, int bg_color, int flags)
     57void console_set_color(int phone, uint8_t fg_color, uint8_t bg_color,
     58    uint8_t flags)
    6659{
    6760        async_msg_3(phone, CONSOLE_SET_COLOR, fg_color, bg_color, flags);
    6861}
    6962
    70 void console_set_rgb_color(int phone, int fg_color, int bg_color)
     63void console_set_rgb_color(int phone, uint32_t fg_color, uint32_t bg_color)
    7164{
    7265        async_msg_2(phone, CONSOLE_SET_RGB_COLOR, fg_color, bg_color);
     
    7568void console_cursor_visibility(int phone, bool show)
    7669{
    77         async_msg_1(phone, CONSOLE_CURSOR_VISIBILITY, show != false);
     70        async_msg_1(phone, CONSOLE_CURSOR_VISIBILITY, (show != false));
    7871}
    7972
    80 int console_get_color_cap(int phone, int *ccap)
     73int console_get_color_cap(int phone, ipcarg_t *ccap)
    8174{
    82         ipcarg_t ccap_tmp;
    83         int rc;
    84 
    85         rc = async_req_0_1(phone, CONSOLE_GET_COLOR_CAP, &ccap_tmp);
    86         *ccap = ccap_tmp;
    87 
    88         return rc;
     75        return async_req_0_1(phone, CONSOLE_GET_COLOR_CAP, ccap);
    8976}
    9077
     
    9481}
    9582
    96 int console_get_pos(int phone, int *col, int *row)
     83int console_get_pos(int phone, ipcarg_t *col, ipcarg_t *row)
    9784{
    98         ipcarg_t col_v;
    99         ipcarg_t row_v;
    100         int rc;
    101 
    102         rc = async_req_0_2(phone, CONSOLE_GET_POS, &col_v, &row_v);
    103 
    104         *col = (int) col_v;
    105         *row = (int) row_v;
    106         return rc;
     85        return async_req_0_2(phone, CONSOLE_GET_POS, col, row);
    10786}
    10887
    109 void console_goto(int phone, int col, int row)
     88void console_set_pos(int phone, ipcarg_t col, ipcarg_t row)
    11089{
    11190        async_msg_2(phone, CONSOLE_GOTO, col, row);
  • uspace/lib/c/include/io/console.h

    rcaad59a r9f1362d4  
    6868extern void console_clear(int phone);
    6969
    70 extern int console_get_size(int phone, int *cols, int *rows);
    71 extern int console_get_pos(int phone, int *col, int *row);
    72 extern void console_goto(int phone, int col, int row);
     70extern int console_get_size(int phone, ipcarg_t *cols, ipcarg_t *rows);
     71extern int console_get_pos(int phone, ipcarg_t *col, ipcarg_t *row);
     72extern void console_set_pos(int phone, ipcarg_t col, ipcarg_t row);
    7373
    74 extern void console_set_style(int phone, int style);
    75 extern void console_set_color(int phone, int fg_color, int bg_color, int flags);
    76 extern void console_set_rgb_color(int phone, int fg_color, int bg_color);
     74extern void console_set_style(int phone, uint8_t style);
     75extern void console_set_color(int phone, uint8_t fg_color, uint8_t bg_color,
     76    uint8_t flags);
     77extern void console_set_rgb_color(int phone, uint32_t fg_color, uint32_t bg_color);
    7778
    7879extern void console_cursor_visibility(int phone, bool show);
    79 extern int console_get_color_cap(int phone, int *ccap);
     80extern int console_get_color_cap(int phone, ipcarg_t *ccap);
    8081extern void console_kcon_enable(int phone);
    8182
  • uspace/lib/c/include/io/style.h

    rcaad59a r9f1362d4  
    3838enum console_style {
    3939        STYLE_NORMAL   = 0,
    40         STYLE_EMPHASIS = 1
     40        STYLE_EMPHASIS = 1,
     41        STYLE_INVERTED = 2,
     42        STYLE_SELECTED = 3
    4143};
    4244
  • uspace/lib/clui/Makefile

    rcaad59a r9f1362d4  
    2828
    2929USPACE_PREFIX = ../..
     30EXTRA_CFLAGS = -I.
    3031LIBRARY = libclui
    3132
  • uspace/lib/clui/tinput.c

    rcaad59a r9f1362d4  
    4040#include <assert.h>
    4141#include <bool.h>
    42 
    43 #include "tinput.h"
     42#include <tinput.h>
    4443
    4544/** Seek direction */
     
    4948} seek_dir_t;
    5049
    51 static void tinput_init(tinput_t *ti);
    52 static void tinput_insert_string(tinput_t *ti, const char *str);
    53 static void tinput_sel_get_bounds(tinput_t *ti, int *sa, int *sb);
    54 static bool tinput_sel_active(tinput_t *ti);
    55 static void tinput_sel_all(tinput_t *ti);
    56 static void tinput_sel_delete(tinput_t *ti);
    57 static void tinput_key_ctrl(tinput_t *ti, console_event_t *ev);
    58 static void tinput_key_shift(tinput_t *ti, console_event_t *ev);
    59 static void tinput_key_ctrl_shift(tinput_t *ti, console_event_t *ev);
    60 static void tinput_key_unmod(tinput_t *ti, console_event_t *ev);
    61 static void tinput_pre_seek(tinput_t *ti, bool shift_held);
    62 static void tinput_post_seek(tinput_t *ti, bool shift_held);
     50static void tinput_init(tinput_t *);
     51static void tinput_insert_string(tinput_t *, const char *);
     52static void tinput_sel_get_bounds(tinput_t *, size_t *, size_t *);
     53static bool tinput_sel_active(tinput_t *);
     54static void tinput_sel_all(tinput_t *);
     55static void tinput_sel_delete(tinput_t *);
     56static void tinput_key_ctrl(tinput_t *, console_event_t *);
     57static void tinput_key_shift(tinput_t *, console_event_t *);
     58static void tinput_key_ctrl_shift(tinput_t *, console_event_t *);
     59static void tinput_key_unmod(tinput_t *, console_event_t *);
     60static void tinput_pre_seek(tinput_t *, bool);
     61static void tinput_post_seek(tinput_t *, bool);
    6362
    6463/** Create a new text input field. */
     
    6665{
    6766        tinput_t *ti;
    68 
     67       
    6968        ti = malloc(sizeof(tinput_t));
    7069        if (ti == NULL)
    7170                return NULL;
    72 
     71       
    7372        tinput_init(ti);
    7473        return ti;
     
    8180}
    8281
    83 static void tinput_display_tail(tinput_t *ti, int start, int pad)
    84 {
    85         static wchar_t dbuf[INPUT_MAX_SIZE + 1];
    86         int sa, sb;
    87         int i, p;
    88 
     82static void tinput_display_tail(tinput_t *ti, size_t start, size_t pad)
     83{
     84        wchar_t dbuf[INPUT_MAX_SIZE + 1];
     85       
     86        size_t sa;
     87        size_t sb;
    8988        tinput_sel_get_bounds(ti, &sa, &sb);
    90 
    91         console_goto(fphone(stdout), (ti->col0 + start) % ti->con_cols,
     89       
     90        console_set_pos(fphone(stdout), (ti->col0 + start) % ti->con_cols,
    9291            ti->row0 + (ti->col0 + start) / ti->con_cols);
    93         console_set_color(fphone(stdout), COLOR_BLACK, COLOR_WHITE, 0);
    94 
    95         p = start;
     92        console_set_style(fphone(stdout), STYLE_NORMAL);
     93       
     94        size_t p = start;
    9695        if (p < sa) {
    9796                memcpy(dbuf, ti->buffer + p, (sa - p) * sizeof(wchar_t));
     
    10099                p = sa;
    101100        }
    102 
     101       
    103102        if (p < sb) {
    104103                fflush(stdout);
    105                 console_set_color(fphone(stdout), COLOR_BLACK, COLOR_RED, 0);
     104                console_set_style(fphone(stdout), STYLE_SELECTED);
    106105                memcpy(dbuf, ti->buffer + p,
    107106                    (sb - p) * sizeof(wchar_t));
     
    110109                p = sb;
    111110        }
    112 
     111       
    113112        fflush(stdout);
    114         console_set_color(fphone(stdout), COLOR_BLACK, COLOR_WHITE, 0);
    115 
     113        console_set_style(fphone(stdout), STYLE_NORMAL);
     114       
    116115        if (p < ti->nc) {
    117116                memcpy(dbuf, ti->buffer + p,
     
    120119                printf("%ls", dbuf);
    121120        }
    122 
    123         for (i = 0; i < pad; ++i)
     121       
     122        for (p = 0; p < pad; p++)
    124123                putchar(' ');
     124       
    125125        fflush(stdout);
    126126}
     
    133133static void tinput_position_caret(tinput_t *ti)
    134134{
    135         console_goto(fphone(stdout), (ti->col0 + ti->pos) % ti->con_cols,
     135        console_set_pos(fphone(stdout), (ti->col0 + ti->pos) % ti->con_cols,
    136136            ti->row0 + (ti->col0 + ti->pos) / ti->con_cols);
    137137}
     
    140140static void tinput_update_origin(tinput_t *ti)
    141141{
    142         int width, rows;
    143 
    144         width = ti->col0 + ti->nc;
    145         rows = (width / ti->con_cols) + 1;
    146 
     142        ipcarg_t width = ti->col0 + ti->nc;
     143        ipcarg_t rows = (width / ti->con_cols) + 1;
     144       
    147145        /* Update row0 if the screen scrolled. */
    148146        if (ti->row0 + rows > ti->con_rows)
    149                 ti->row0 = ti->con_rows - rows; 
     147                ti->row0 = ti->con_rows - rows;
    150148}
    151149
    152150static void tinput_insert_char(tinput_t *ti, wchar_t c)
    153151{
    154         int i;
    155         int new_width, new_height;
    156 
    157152        if (ti->nc == INPUT_MAX_SIZE)
    158153                return;
    159 
    160         new_width = ti->col0 + ti->nc + 1;
     154       
     155        ipcarg_t new_width = ti->col0 + ti->nc + 1;
    161156        if (new_width % ti->con_cols == 0) {
    162157                /* Advancing to new line. */
    163                 new_height = (new_width / ti->con_cols) + 1;
    164                 if (new_height >= ti->con_rows)
    165                         return; /* Disallow text longer than 1 page for now. */
    166         }
    167 
    168         for (i = ti->nc; i > ti->pos; --i)
     158                ipcarg_t new_height = (new_width / ti->con_cols) + 1;
     159                if (new_height >= ti->con_rows) {
     160                        /* Disallow text longer than 1 page for now. */
     161                        return;
     162                }
     163        }
     164       
     165        size_t i;
     166        for (i = ti->nc; i > ti->pos; i--)
    169167                ti->buffer[i] = ti->buffer[i - 1];
    170 
     168       
    171169        ti->buffer[ti->pos] = c;
    172170        ti->pos += 1;
     
    174172        ti->buffer[ti->nc] = '\0';
    175173        ti->sel_start = ti->pos;
    176 
     174       
    177175        tinput_display_tail(ti, ti->pos - 1, 0);
    178176        tinput_update_origin(ti);
     
    182180static void tinput_insert_string(tinput_t *ti, const char *str)
    183181{
    184         int i;
    185         int new_width, new_height;
    186         int ilen;
    187         wchar_t c;
    188         size_t off;
    189 
    190         ilen = min((ssize_t) str_length(str), INPUT_MAX_SIZE - ti->nc);
     182        size_t ilen = min(str_length(str), INPUT_MAX_SIZE - ti->nc);
    191183        if (ilen == 0)
    192184                return;
    193 
    194         new_width = ti->col0 + ti->nc + ilen;
    195         new_height = (new_width / ti->con_cols) + 1;
    196         if (new_height >= ti->con_rows)
    197                 return; /* Disallow text longer than 1 page for now. */
    198 
    199         for (i = ti->nc - 1; i >= ti->pos; --i)
    200                 ti->buffer[i + ilen] = ti->buffer[i];
    201 
    202         off = 0; i = 0;
     185       
     186        ipcarg_t new_width = ti->col0 + ti->nc + ilen;
     187        ipcarg_t new_height = (new_width / ti->con_cols) + 1;
     188        if (new_height >= ti->con_rows) {
     189                /* Disallow text longer than 1 page for now. */
     190                return;
     191        }
     192       
     193        if (ti->nc > 0) {
     194                size_t i;
     195                for (i = ti->nc; i > ti->pos; i--)
     196                        ti->buffer[i + ilen - 1] = ti->buffer[i - 1];
     197        }
     198       
     199        size_t off = 0;
     200        size_t i = 0;
    203201        while (i < ilen) {
    204                 c = str_decode(str, &off, STR_NO_LIMIT);
     202                wchar_t c = str_decode(str, &off, STR_NO_LIMIT);
    205203                if (c == '\0')
    206204                        break;
    207 
     205               
    208206                /* Filter out non-printable chars. */
    209207                if (c < 32)
    210208                        c = 32;
    211 
     209               
    212210                ti->buffer[ti->pos + i] = c;
    213                 ++i;
    214         }
    215 
     211                i++;
     212        }
     213       
    216214        ti->pos += ilen;
    217215        ti->nc += ilen;
    218216        ti->buffer[ti->nc] = '\0';
    219217        ti->sel_start = ti->pos;
    220 
     218       
    221219        tinput_display_tail(ti, ti->pos - ilen, 0);
    222220        tinput_update_origin(ti);
     
    226224static void tinput_backspace(tinput_t *ti)
    227225{
    228         int i;
    229 
    230226        if (tinput_sel_active(ti)) {
    231227                tinput_sel_delete(ti);
    232228                return;
    233229        }
    234 
     230       
    235231        if (ti->pos == 0)
    236232                return;
    237 
    238         for (i = ti->pos; i < ti->nc; ++i)
     233       
     234        size_t i;
     235        for (i = ti->pos; i < ti->nc; i++)
    239236                ti->buffer[i - 1] = ti->buffer[i];
     237       
    240238        ti->pos -= 1;
    241239        ti->nc -= 1;
    242240        ti->buffer[ti->nc] = '\0';
    243241        ti->sel_start = ti->pos;
    244 
     242       
    245243        tinput_display_tail(ti, ti->pos, 1);
    246244        tinput_position_caret(ti);
     
    253251                return;
    254252        }
    255 
     253       
    256254        if (ti->pos == ti->nc)
    257255                return;
    258 
     256       
    259257        ti->pos += 1;
    260258        ti->sel_start = ti->pos;
    261 
     259       
    262260        tinput_backspace(ti);
    263261}
     
    266264{
    267265        tinput_pre_seek(ti, shift_held);
    268 
     266       
    269267        if (dir == seek_forward) {
    270268                if (ti->pos < ti->nc)
     
    274272                        ti->pos -= 1;
    275273        }
    276 
     274       
    277275        tinput_post_seek(ti, shift_held);
    278276}
     
    281279{
    282280        tinput_pre_seek(ti, shift_held);
    283 
     281       
    284282        if (dir == seek_forward) {
    285283                if (ti->pos == ti->nc)
    286284                        return;
    287 
    288                 while (1) {
     285               
     286                while (true) {
    289287                        ti->pos += 1;
    290 
     288                       
    291289                        if (ti->pos == ti->nc)
    292290                                break;
    293 
    294                         if (ti->buffer[ti->pos - 1] == ' ' &&
    295                             ti->buffer[ti->pos] != ' ')
     291                       
     292                        if ((ti->buffer[ti->pos - 1] == ' ') &&
     293                            (ti->buffer[ti->pos] != ' '))
    296294                                break;
    297295                }
     
    299297                if (ti->pos == 0)
    300298                        return;
    301 
    302                 while (1) {
     299               
     300                while (true) {
    303301                        ti->pos -= 1;
    304 
     302                       
    305303                        if (ti->pos == 0)
    306304                                break;
    307 
     305                       
    308306                        if (ti->buffer[ti->pos - 1] == ' ' &&
    309307                            ti->buffer[ti->pos] != ' ')
    310308                                break;
    311309                }
    312 
    313         }
    314 
     310       
     311        }
     312       
    315313        tinput_post_seek(ti, shift_held);
    316314}
     
    319317{
    320318        tinput_pre_seek(ti, shift_held);
    321 
     319       
    322320        if (dir == seek_forward) {
    323321                if (ti->pos + ti->con_cols <= ti->nc)
    324322                        ti->pos = ti->pos + ti->con_cols;
    325323        } else {
    326                 if (ti->pos - ti->con_cols >= 0)
     324                if (ti->pos >= ti->con_cols)
    327325                        ti->pos = ti->pos - ti->con_cols;
    328326        }
    329 
     327       
    330328        tinput_post_seek(ti, shift_held);
    331329}
     
    334332{
    335333        tinput_pre_seek(ti, shift_held);
    336 
     334       
    337335        if (dir == seek_backward)
    338336                ti->pos = 0;
    339337        else
    340338                ti->pos = ti->nc;
    341 
     339       
    342340        tinput_post_seek(ti, shift_held);
    343341}
     
    345343static void tinput_pre_seek(tinput_t *ti, bool shift_held)
    346344{
    347         if (tinput_sel_active(ti) && !shift_held) {
     345        if ((tinput_sel_active(ti)) && (!shift_held)) {
    348346                /* Unselect and redraw. */
    349347                ti->sel_start = ti->pos;
     
    362360                ti->sel_start = ti->pos;
    363361        }
     362       
    364363        tinput_position_caret(ti);
    365364}
     
    367366static void tinput_history_insert(tinput_t *ti, char *str)
    368367{
    369         int i;
    370 
    371368        if (ti->hnum < HISTORY_LEN) {
    372369                ti->hnum += 1;
     
    375372                        free(ti->history[HISTORY_LEN]);
    376373        }
    377 
    378         for (i = ti->hnum; i > 1; --i)
     374       
     375        size_t i;
     376        for (i = ti->hnum; i > 1; i--)
    379377                ti->history[i] = ti->history[i - 1];
    380 
     378       
    381379        ti->history[1] = str_dup(str);
    382 
     380       
    383381        if (ti->history[0] != NULL) {
    384382                free(ti->history[0]);
     
    395393}
    396394
    397 static void tinput_sel_get_bounds(tinput_t *ti, int *sa, int *sb)
     395static void tinput_sel_get_bounds(tinput_t *ti, size_t *sa, size_t *sb)
    398396{
    399397        if (ti->sel_start < ti->pos) {
     
    408406static bool tinput_sel_active(tinput_t *ti)
    409407{
    410         return ti->sel_start != ti->pos;
     408        return (ti->sel_start != ti->pos);
    411409}
    412410
     
    421419static void tinput_sel_delete(tinput_t *ti)
    422420{
    423         int sa, sb;
    424 
     421        size_t sa;
     422        size_t sb;
     423       
    425424        tinput_sel_get_bounds(ti, &sa, &sb);
    426425        if (sa == sb)
    427426                return;
    428 
     427       
    429428        memmove(ti->buffer + sa, ti->buffer + sb,
    430429            (ti->nc - sb) * sizeof(wchar_t));
     430       
    431431        ti->pos = ti->sel_start = sa;
    432432        ti->nc -= (sb - sa);
    433433        ti->buffer[ti->nc] = '\0';
    434 
     434       
    435435        tinput_display_tail(ti, sa, sb - sa);
    436436        tinput_position_caret(ti);
     
    439439static void tinput_sel_copy_to_cb(tinput_t *ti)
    440440{
    441         int sa, sb;
     441        size_t sa;
     442        size_t sb;
     443       
     444        tinput_sel_get_bounds(ti, &sa, &sb);
     445       
    442446        char *str;
    443 
    444         tinput_sel_get_bounds(ti, &sa, &sb);
    445 
     447       
    446448        if (sb < ti->nc) {
    447449                wchar_t tmp_c = ti->buffer[sb];
     
    454456        if (str == NULL)
    455457                goto error;
    456 
     458       
    457459        if (clipboard_put_str(str) != EOK)
    458460                goto error;
    459 
     461       
    460462        free(str);
    461463        return;
     464       
    462465error:
     466        /* TODO: Give the user some kind of warning. */
    463467        return;
    464         /* TODO: Give the user some warning. */
    465468}
    466469
     
    468471{
    469472        char *str;
    470         int rc;
    471 
    472         rc = clipboard_get_str(&str);
    473         if (rc != EOK || str == NULL)
    474                 return; /* TODO: Give the user some warning. */
    475 
     473        int rc = clipboard_get_str(&str);
     474       
     475        if ((rc != EOK) || (str == NULL)) {
     476                /* TODO: Give the user some kind of warning. */
     477                return;
     478        }
     479       
    476480        tinput_insert_string(ti, str);
    477481        free(str);
     
    480484static void tinput_history_seek(tinput_t *ti, int offs)
    481485{
    482         int pad;
    483 
    484         if (ti->hpos + offs < 0 || ti->hpos + offs > ti->hnum)
    485                 return;
    486 
     486        if (offs >= 0) {
     487                if (ti->hpos + offs > ti->hnum)
     488                        return;
     489        } else {
     490                if (ti->hpos < (size_t) -offs)
     491                        return;
     492        }
     493       
    487494        if (ti->history[ti->hpos] != NULL) {
    488495                free(ti->history[ti->hpos]);
    489496                ti->history[ti->hpos] = NULL;
    490497        }
    491 
     498       
    492499        ti->history[ti->hpos] = tinput_get_str(ti);
    493500        ti->hpos += offs;
    494 
    495         pad = ti->nc - str_length(ti->history[ti->hpos]);
    496         if (pad < 0) pad = 0;
    497 
     501       
     502        int pad = (int) ti->nc - str_length(ti->history[ti->hpos]);
     503        if (pad < 0)
     504                pad = 0;
     505       
    498506        tinput_set_str(ti, ti->history[ti->hpos]);
    499507        tinput_display_tail(ti, 0, pad);
     
    515523/** Read in one line of input.
    516524 *
    517  * @param ti    Text input.
    518  * @param dstr  Place to save pointer to new string.
    519  * @return      EOK on success, ENOENT if user requested abort, EIO
    520  *              if communication with console failed.
     525 * @param ti   Text input.
     526 * @param dstr Place to save pointer to new string.
     527 *
     528 * @return EOK on success
     529 * @return ENOENT if user requested abort
     530 * @return EIO if communication with console failed
     531 *
    521532 */
    522533int tinput_read(tinput_t *ti, char **dstr)
    523534{
    524         console_event_t ev;
    525         char *str;
    526 
    527535        fflush(stdout);
    528 
    529536        if (console_get_size(fphone(stdin), &ti->con_cols, &ti->con_rows) != EOK)
    530537                return EIO;
     538       
    531539        if (console_get_pos(fphone(stdin), &ti->col0, &ti->row0) != EOK)
    532540                return EIO;
    533 
    534         ti->pos = ti->sel_start = 0;
     541       
     542        ti->pos = 0;
     543        ti->sel_start = 0;
    535544        ti->nc = 0;
    536545        ti->buffer[0] = '\0';
    537546        ti->done = false;
    538547        ti->exit_clui = false;
    539 
     548       
    540549        while (!ti->done) {
    541550                fflush(stdout);
     551               
     552                console_event_t ev;
    542553                if (!console_get_event(fphone(stdin), &ev))
    543554                        return EIO;
    544 
     555               
    545556                if (ev.type != KEY_PRESS)
    546557                        continue;
    547 
    548                 if ((ev.mods & KM_CTRL) != 0 &&
    549                     (ev.mods & (KM_ALT | KM_SHIFT)) == 0) {
     558               
     559                if (((ev.mods & KM_CTRL) != 0) &&
     560                    ((ev.mods & (KM_ALT | KM_SHIFT)) == 0))
    550561                        tinput_key_ctrl(ti, &ev);
    551                 }
    552 
    553                 if ((ev.mods & KM_SHIFT) != 0 &&
    554                     (ev.mods & (KM_CTRL | KM_ALT)) == 0) {
     562               
     563                if (((ev.mods & KM_SHIFT) != 0) &&
     564                    ((ev.mods & (KM_CTRL | KM_ALT)) == 0))
    555565                        tinput_key_shift(ti, &ev);
    556                 }
    557 
    558                 if ((ev.mods & KM_CTRL) != 0 &&
    559                     (ev.mods & KM_SHIFT) != 0 &&
    560                     (ev.mods & KM_ALT) == 0) {
     566               
     567                if (((ev.mods & KM_CTRL) != 0) &&
     568                    ((ev.mods & KM_SHIFT) != 0) &&
     569                    ((ev.mods & KM_ALT) == 0))
    561570                        tinput_key_ctrl_shift(ti, &ev);
    562                 }
    563 
    564                 if ((ev.mods & (KM_CTRL | KM_ALT | KM_SHIFT)) == 0) {
     571               
     572                if ((ev.mods & (KM_CTRL | KM_ALT | KM_SHIFT)) == 0)
    565573                        tinput_key_unmod(ti, &ev);
    566                 }
    567 
     574               
    568575                if (ev.c >= ' ') {
    569576                        tinput_sel_delete(ti);
     
    571578                }
    572579        }
    573 
     580       
    574581        if (ti->exit_clui)
    575582                return ENOENT;
    576 
     583       
    577584        ti->pos = ti->nc;
    578585        tinput_position_caret(ti);
    579586        putchar('\n');
    580 
    581         str = tinput_get_str(ti);
     587       
     588        char *str = tinput_get_str(ti);
    582589        if (str_cmp(str, "") != 0)
    583590                tinput_history_insert(ti, str);
    584 
     591       
    585592        ti->hpos = 0;
    586 
     593       
    587594        *dstr = str;
    588595        return EOK;
     
    700707                break;
    701708        case KC_UP:
    702                 tinput_history_seek(ti, +1);
     709                tinput_history_seek(ti, 1);
    703710                break;
    704711        case KC_DOWN:
  • uspace/lib/clui/tinput.h

    rcaad59a r9f1362d4  
    2929/** @addtogroup libclui
    3030 * @{
    31  */ 
     31 */
    3232/**
    3333 * @file
     
    3737#define LIBCLUI_TINPUT_H_
    3838
    39 #define HISTORY_LEN 10
    40 #define INPUT_MAX_SIZE 1024
     39#include <ipc/ipc.h>
     40
     41#define HISTORY_LEN     10
     42#define INPUT_MAX_SIZE  1024
    4143
    4244/** Text input field (command line).
     
    4749        /** Buffer holding text currently being edited */
    4850        wchar_t buffer[INPUT_MAX_SIZE + 1];
     51       
    4952        /** Screen coordinates of the top-left corner of the text field */
    50         int col0, row0;
     53        ipcarg_t col0;
     54        ipcarg_t row0;
     55       
    5156        /** Screen dimensions */
    52         int con_cols, con_rows;
     57        ipcarg_t con_cols;
     58        ipcarg_t con_rows;
     59       
    5360        /** Number of characters in @c buffer */
    54         int nc;
     61        size_t nc;
     62       
    5563        /** Caret position within buffer */
    56         int pos;
     64        size_t pos;
     65       
    5766        /** Selection mark position within buffer */
    58         int sel_start;
    59 
     67        size_t sel_start;
     68       
    6069        /** History (dynamically allocated strings) */
    61         char *history[1 + HISTORY_LEN];
     70        char *history[HISTORY_LEN + 1];
     71       
    6272        /** Number of entries in @c history, not counting [0] */
    63         int hnum;
     73        size_t hnum;
     74       
    6475        /** Current position in history */
    65         int hpos;
     76        size_t hpos;
     77       
    6678        /** @c true if finished with this line (return to caller) */
    6779        bool done;
     80       
    6881        /** @c true if user requested to abort interactive loop */
    6982        bool exit_clui;
     
    7184
    7285extern tinput_t *tinput_new(void);
    73 extern void tinput_destroy(tinput_t *ti);
    74 extern int tinput_read(tinput_t *ti, char **str);
     86extern void tinput_destroy(tinput_t *);
     87extern int tinput_read(tinput_t *, char **);
    7588
    7689#endif
     
    7891/** @}
    7992 */
    80 
  • uspace/srv/hid/console/console.c

    rcaad59a r9f1362d4  
    7171/** Information about framebuffer */
    7272struct {
    73         int phone;      /**< Framebuffer phone */
    74         ipcarg_t cols;  /**< Framebuffer columns */
    75         ipcarg_t rows;  /**< Framebuffer rows */
    76         int color_cap;  /**< Color capabilities (FB_CCAP_xxx) */
     73        int phone;           /**< Framebuffer phone */
     74        ipcarg_t cols;       /**< Framebuffer columns */
     75        ipcarg_t rows;       /**< Framebuffer rows */
     76        ipcarg_t color_cap;  /**< Color capabilities (FB_CCAP_xxx) */
    7777} fb_info;
    7878
     
    9999/** Information on row-span yet unsent to FB driver. */
    100100struct {
    101         size_t col;  /**< Leftmost column of the span. */
    102         size_t row;  /**< Row where the span lies. */
    103         size_t cnt;  /**< Width of the span. */
     101        ipcarg_t col;  /**< Leftmost column of the span. */
     102        ipcarg_t row;  /**< Row where the span lies. */
     103        ipcarg_t cnt;  /**< Width of the span. */
    104104} fb_pending;
    105105
     
    117117}
    118118
    119 static void curs_goto(size_t x, size_t y)
     119static void curs_goto(ipcarg_t x, ipcarg_t y)
    120120{
    121121        async_msg_2(fb_info.phone, FB_CURSOR_GOTO, x, y);
     
    147147}
    148148
    149 static void set_style(int style)
     149static void set_style(uint8_t style)
    150150{
    151151        async_msg_1(fb_info.phone, FB_SET_STYLE, style);
    152152}
    153153
    154 static void set_color(int fgcolor, int bgcolor, int flags)
     154static void set_color(uint8_t fgcolor, uint8_t bgcolor, uint8_t flags)
    155155{
    156156        async_msg_3(fb_info.phone, FB_SET_COLOR, fgcolor, bgcolor, flags);
    157157}
    158158
    159 static void set_rgb_color(int fgcolor, int bgcolor)
     159static void set_rgb_color(uint32_t fgcolor, uint32_t bgcolor)
    160160{
    161161        async_msg_2(fb_info.phone, FB_SET_RGB_COLOR, fgcolor, bgcolor);
     
    178178}
    179179
    180 static int ccap_fb_to_con(int ccap_fb, int *ccap_con)
     180static int ccap_fb_to_con(ipcarg_t ccap_fb, ipcarg_t *ccap_con)
    181181{
    182182        switch (ccap_fb) {
    183         case FB_CCAP_NONE: *ccap_con = CONSOLE_CCAP_NONE; break;
    184         case FB_CCAP_STYLE: *ccap_con = CONSOLE_CCAP_STYLE; break;
    185         case FB_CCAP_INDEXED: *ccap_con = CONSOLE_CCAP_INDEXED; break;
    186         case FB_CCAP_RGB: *ccap_con = CONSOLE_CCAP_RGB; break;
    187         default: return EINVAL;
    188         }
    189 
     183        case FB_CCAP_NONE:
     184                *ccap_con = CONSOLE_CCAP_NONE;
     185                break;
     186        case FB_CCAP_STYLE:
     187                *ccap_con = CONSOLE_CCAP_STYLE;
     188                break;
     189        case FB_CCAP_INDEXED:
     190                *ccap_con = CONSOLE_CCAP_INDEXED;
     191                break;
     192        case FB_CCAP_RGB:
     193                *ccap_con = CONSOLE_CCAP_RGB;
     194                break;
     195        default:
     196                return EINVAL;
     197        }
     198       
    190199        return EOK;
    191200}
     
    226235 *
    227236 */
    228 static void cell_mark_changed(size_t col, size_t row)
     237static void cell_mark_changed(ipcarg_t col, ipcarg_t row)
    229238{
    230239        if (fb_pending.cnt != 0) {
     
    253262{
    254263        bool flush_cursor = false;
    255 
     264       
    256265        switch (ch) {
    257266        case '\n':
     
    297306                        async_msg_1(fb_info.phone, FB_SCROLL, 1);
    298307        }
    299 
     308       
    300309        if (cons == active_console && flush_cursor)
    301310                curs_goto(cons->scr.position_x, cons->scr.position_y);
     
    327336       
    328337        if (cons != kernel_console) {
    329                 size_t x;
    330                 size_t y;
    331                 int rc = 0;
    332                
    333338                async_serialize_start();
    334339               
     
    344349                set_attrs(&cons->scr.attrs);
    345350                curs_visibility(false);
     351               
     352                ipcarg_t x;
     353                ipcarg_t y;
     354                int rc = 0;
     355               
    346356                if (interbuffer) {
    347357                        for (y = 0; y < cons->scr.size_y; y++) {
     
    390400        /* Ignore parameters, the connection is already opened */
    391401        while (true) {
    392                
    393402                ipc_call_t call;
    394403                ipc_callid_t callid = async_get_call(&call);
     
    433442static void mouse_events(ipc_callid_t iid, ipc_call_t *icall)
    434443{
    435         int button, press;
    436         int dx, dy;
    437         int newcon;
    438 
    439444        /* Ignore parameters, the connection is already opened */
    440445        while (true) {
    441 
    442446                ipc_call_t call;
    443447                ipc_callid_t callid = async_get_call(&call);
    444 
     448               
    445449                int retval;
    446 
     450               
    447451                switch (IPC_GET_METHOD(call)) {
    448452                case IPC_M_PHONE_HUNGUP:
     
    450454                        return;
    451455                case MEVENT_BUTTON:
    452                         button = IPC_GET_ARG1(call);
    453                         press = IPC_GET_ARG2(call);
    454                         if (button == 1) {
    455                                 newcon = gcons_mouse_btn(press);
     456                        if (IPC_GET_ARG1(call) == 1) {
     457                                int newcon = gcons_mouse_btn((bool) IPC_GET_ARG2(call));
    456458                                if (newcon != -1)
    457459                                        change_console(&consoles[newcon]);
     
    460462                        break;
    461463                case MEVENT_MOVE:
    462                         dx = IPC_GET_ARG1(call);
    463                         dy = IPC_GET_ARG2(call);
    464                         gcons_mouse_move(dx, dy);
     464                        gcons_mouse_move((int) IPC_GET_ARG1(call),
     465                            (int) IPC_GET_ARG2(call));
    465466                        retval = 0;
    466467                        break;
     
    520521        console_event_t ev;
    521522        fibril_mutex_lock(&input_mutex);
     523       
    522524recheck:
    523525        while ((keybuffer_pop(&cons->keybuffer, &ev)) && (pos < size)) {
     
    536538                goto recheck;
    537539        }
     540       
    538541        fibril_mutex_unlock(&input_mutex);
    539542}
     
    542545{
    543546        console_event_t ev;
    544 
     547       
    545548        fibril_mutex_lock(&input_mutex);
     549       
    546550recheck:
    547551        if (keybuffer_pop(&cons->keybuffer, &ev)) {
     
    551555                goto recheck;
    552556        }
     557       
    553558        fibril_mutex_unlock(&input_mutex);
    554559}
     
    580585        ipcarg_t arg2;
    581586        ipcarg_t arg3;
    582 
    583         int cons_ccap;
     587       
    584588        int rc;
    585589       
     
    622626                        if (cons == active_console) {
    623627                                async_req_0_0(fb_info.phone, FB_FLUSH);
    624                                
    625628                                curs_goto(cons->scr.position_x, cons->scr.position_y);
    626629                        }
     
    650653                        break;
    651654                case CONSOLE_GET_COLOR_CAP:
    652                         rc = ccap_fb_to_con(fb_info.color_cap, &cons_ccap);
     655                        rc = ccap_fb_to_con(fb_info.color_cap, &arg1);
    653656                        if (rc != EOK) {
    654657                                ipc_answer_0(callid, rc);
    655658                                continue;
    656659                        }
    657                         arg1 = cons_ccap;
    658660                        break;
    659661                case CONSOLE_SET_STYLE:
     
    714716                return false;
    715717        }
    716 
     718       
    717719        kbd_phone = fd_phone(input_fd);
    718720        if (kbd_phone < 0) {
     
    720722                return false;
    721723        }
    722 
     724       
    723725        /* NB: The callback connection is slotted for removal */
    724726        ipcarg_t phonehash;
     
    727729                return false;
    728730        }
    729 
     731       
    730732        async_new_connection(phonehash, 0, NULL, keyboard_events);
    731 
     733       
    732734        /* Connect to mouse device */
    733735        mouse_phone = -1;
    734736        int mouse_fd = open("/dev/hid_in/mouse", O_RDONLY);
    735 
     737       
    736738        if (mouse_fd < 0) {
    737739                printf(NAME ": Notice - failed opening %s\n", "/dev/hid_in/mouse");
    738740                goto skip_mouse;
    739741        }
    740 
     742       
    741743        mouse_phone = fd_phone(mouse_fd);
    742744        if (mouse_phone < 0) {
     
    744746                goto skip_mouse;
    745747        }
    746 
     748       
    747749        if (ipc_connect_to_me(mouse_phone, SERVICE_CONSOLE, 0, 0, &phonehash) != 0) {
    748750                printf(NAME ": Failed to create callback from mouse device\n");
     
    750752                goto skip_mouse;
    751753        }
    752 
     754       
    753755        async_new_connection(phonehash, 0, NULL, mouse_events);
    754756skip_mouse:
    755 
     757       
    756758        /* Connect to framebuffer driver */
    757759        fb_info.phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_VIDEO, 0, 0);
     
    760762                return -1;
    761763        }
    762 
     764       
    763765        /* Register driver */
    764766        int rc = devmap_driver_register(NAME, client_connection);
     
    772774       
    773775        /* Synchronize, the gcons could put something in queue */
    774         ipcarg_t color_cap;
    775776        async_req_0_0(fb_info.phone, FB_FLUSH);
    776777        async_req_0_2(fb_info.phone, FB_GET_CSIZE, &fb_info.cols, &fb_info.rows);
    777         async_req_0_1(fb_info.phone, FB_GET_COLOR_CAP, &color_cap);
    778         fb_info.color_cap = color_cap;
     778        async_req_0_1(fb_info.phone, FB_GET_COLOR_CAP, &fb_info.color_cap);
    779779       
    780780        /* Set up shared memory buffer. */
  • uspace/srv/hid/console/gcons.c

    rcaad59a r9f1362d4  
    5454#define STATUS_HEIGHT  48
    5555
    56 #define MAIN_COLOR  0xffffff
     56#define COLOR_MAIN        0xffffff
     57#define COLOR_FOREGROUND  0x202020
     58#define COLOR_BACKGROUND  0xffffff
     59
     60extern char _binary_gfx_helenos_ppm_start[0];
     61extern int _binary_gfx_helenos_ppm_size;
     62extern char _binary_gfx_nameic_ppm_start[0];
     63extern int _binary_gfx_nameic_ppm_size;
     64
     65extern char _binary_gfx_anim_1_ppm_start[0];
     66extern int _binary_gfx_anim_1_ppm_size;
     67extern char _binary_gfx_anim_2_ppm_start[0];
     68extern int _binary_gfx_anim_2_ppm_size;
     69extern char _binary_gfx_anim_3_ppm_start[0];
     70extern int _binary_gfx_anim_3_ppm_size;
     71extern char _binary_gfx_anim_4_ppm_start[0];
     72extern int _binary_gfx_anim_4_ppm_size;
     73
     74extern char _binary_gfx_cons_selected_ppm_start[0];
     75extern int _binary_gfx_cons_selected_ppm_size;
     76extern char _binary_gfx_cons_idle_ppm_start[0];
     77extern int _binary_gfx_cons_idle_ppm_size;
     78extern char _binary_gfx_cons_has_data_ppm_start[0];
     79extern int _binary_gfx_cons_has_data_ppm_size;
     80extern char _binary_gfx_cons_kernel_ppm_start[0];
     81extern int _binary_gfx_cons_kernel_ppm_size;
    5782
    5883static bool use_gcons = false;
     
    82107static size_t active_console = 0;
    83108
    84 size_t mouse_x;
    85 size_t mouse_y;
    86 
    87 bool btn_pressed;
    88 size_t btn_x;
    89 size_t btn_y;
     109static ipcarg_t mouse_x = 0;
     110static ipcarg_t mouse_y= 0;
     111
     112static bool btn_pressed = false;
     113static ipcarg_t btn_x = 0;
     114static ipcarg_t btn_y = 0;
    90115
    91116static void vp_switch(int vp)
     
    95120
    96121/** Create view port */
    97 static int vp_create(size_t x, size_t y, size_t width, size_t height)
     122static int vp_create(ipcarg_t x, ipcarg_t y, ipcarg_t width, ipcarg_t height)
    98123{
    99124        return async_req_2_0(fbphone, FB_VIEWPORT_CREATE, (x << 16) | y,
     
    112137
    113138/** Transparent putchar */
    114 static void tran_putch(wchar_t ch, size_t col, size_t row)
     139static void tran_putch(wchar_t ch, ipcarg_t col, ipcarg_t row)
    115140{
    116141        async_msg_3(fbphone, FB_PUTCHAR, ch, col, row);
     
    259284void gcons_mouse_move(ssize_t dx, ssize_t dy)
    260285{
    261         mouse_x = limit(mouse_x + dx, 0, xres);
    262         mouse_y = limit(mouse_y + dy, 0, yres);
    263 
     286        ssize_t nx = (ssize_t) mouse_x + dx;
     287        ssize_t ny = (ssize_t) mouse_y + dy;
     288       
     289        mouse_x = (size_t) limit(nx, 0, xres);
     290        mouse_y = (size_t) limit(ny, 0, yres);
     291       
    264292        if (active_console != KERNEL_CONSOLE)
    265293                async_msg_2(fbphone, FB_POINTER_MOVE, mouse_x, mouse_y);
    266294}
    267295
    268 static int gcons_find_conbut(int x, int y)
    269 {
    270         int status_start = STATUS_START + (xres - 800) / 2;
     296static int gcons_find_conbut(ipcarg_t x, ipcarg_t y)
     297{
     298        ipcarg_t status_start = STATUS_START + (xres - 800) / 2;
    271299       
    272300        if ((y < STATUS_TOP) || (y >= STATUS_TOP + STATUS_HEIGHT))
     
    278306        if (x >= status_start + (STATUS_WIDTH + STATUS_SPACE) * CONSOLE_COUNT)
    279307                return -1;
     308       
    280309        if (((x - status_start) % (STATUS_WIDTH + STATUS_SPACE)) < STATUS_SPACE)
    281310                return -1;
    282311       
    283         return (x - status_start) / (STATUS_WIDTH + STATUS_SPACE);
     312        ipcarg_t btn = (x - status_start) / (STATUS_WIDTH + STATUS_SPACE);
     313       
     314        if (btn < CONSOLE_COUNT)
     315                return btn;
     316       
     317        return -1;
    284318}
    285319
     
    287321 *
    288322 * @param state New state (true - pressed, false - depressed)
     323 *
    289324 */
    290325int gcons_mouse_btn(bool state)
    291326{
    292         int conbut;
     327        /* Ignore mouse clicks if no buttons
     328           are drawn at all */
     329        if (xres < 800)
     330                return -1;
    293331       
    294332        if (state) {
    295                 conbut = gcons_find_conbut(mouse_x, mouse_y);
     333                int conbut = gcons_find_conbut(mouse_x, mouse_y);
    296334                if (conbut != -1) {
    297335                        btn_pressed = true;
     
    307345        btn_pressed = false;
    308346       
    309         conbut = gcons_find_conbut(mouse_x, mouse_y);
     347        int conbut = gcons_find_conbut(mouse_x, mouse_y);
    310348        if (conbut == gcons_find_conbut(btn_x, btn_y))
    311349                return conbut;
     
    313351        return -1;
    314352}
    315 
    316353
    317354/** Draw a PPM pixmap to framebuffer
     
    321358 * @param x Coordinate of upper left corner
    322359 * @param y Coordinate of upper left corner
    323  */
    324 static void draw_pixmap(char *logo, size_t size, int x, int y)
    325 {
    326         char *shm;
    327         int rc;
    328        
     360 *
     361 */
     362static void draw_pixmap(char *logo, size_t size, ipcarg_t x, ipcarg_t y)
     363{
    329364        /* Create area */
    330         shm = mmap(NULL, size, PROTO_READ | PROTO_WRITE, MAP_SHARED |
     365        char *shm = mmap(NULL, size, PROTO_READ | PROTO_WRITE, MAP_SHARED |
    331366            MAP_ANONYMOUS, 0, 0);
    332367        if (shm == MAP_FAILED)
     
    336371       
    337372        /* Send area */
    338         rc = async_req_1_0(fbphone, FB_PREPARE_SHM, (ipcarg_t) shm);
     373        int rc = async_req_1_0(fbphone, FB_PREPARE_SHM, (ipcarg_t) shm);
    339374        if (rc)
    340375                goto exit;
     
    356391}
    357392
    358 extern char _binary_gfx_helenos_ppm_start[0];
    359 extern int _binary_gfx_helenos_ppm_size;
    360 extern char _binary_gfx_nameic_ppm_start[0];
    361 extern int _binary_gfx_nameic_ppm_size;
    362 
    363393/** Redraws console graphics */
    364394void gcons_redraw_console(void)
    365395{
    366         int i;
    367        
    368396        if (!use_gcons)
    369397                return;
    370398       
    371399        vp_switch(0);
    372         set_rgb_color(MAIN_COLOR, MAIN_COLOR);
     400        set_rgb_color(COLOR_MAIN, COLOR_MAIN);
    373401        clear();
    374402        draw_pixmap(_binary_gfx_helenos_ppm_start,
     
    377405            (size_t) &_binary_gfx_nameic_ppm_size, 5, 17);
    378406       
     407        unsigned int i;
    379408        for (i = 0; i < CONSOLE_COUNT; i++)
    380409                redraw_state(i);
     
    393422static int make_pixmap(char *data, size_t size)
    394423{
    395         char *shm;
    396         int rc;
    397         int pxid = -1;
    398        
    399424        /* Create area */
    400         shm = mmap(NULL, size, PROTO_READ | PROTO_WRITE, MAP_SHARED |
     425        char *shm = mmap(NULL, size, PROTO_READ | PROTO_WRITE, MAP_SHARED |
    401426            MAP_ANONYMOUS, 0, 0);
    402427        if (shm == MAP_FAILED)
     
    405430        memcpy(shm, data, size);
    406431       
     432        int pxid = -1;
     433       
    407434        /* Send area */
    408         rc = async_req_1_0(fbphone, FB_PREPARE_SHM, (ipcarg_t) shm);
     435        int rc = async_req_1_0(fbphone, FB_PREPARE_SHM, (ipcarg_t) shm);
    409436        if (rc)
    410437                goto exit;
     
    432459}
    433460
    434 extern char _binary_gfx_anim_1_ppm_start[0];
    435 extern int _binary_gfx_anim_1_ppm_size;
    436 extern char _binary_gfx_anim_2_ppm_start[0];
    437 extern int _binary_gfx_anim_2_ppm_size;
    438 extern char _binary_gfx_anim_3_ppm_start[0];
    439 extern int _binary_gfx_anim_3_ppm_size;
    440 extern char _binary_gfx_anim_4_ppm_start[0];
    441 extern int _binary_gfx_anim_4_ppm_size;
    442 
    443461static void make_anim(void)
    444462{
    445         int an = async_req_1_0(fbphone, FB_ANIM_CREATE, cstatus_vp[KERNEL_CONSOLE]);
     463        int an = async_req_1_0(fbphone, FB_ANIM_CREATE,
     464            cstatus_vp[KERNEL_CONSOLE]);
    446465        if (an < 0)
    447466                return;
     
    467486        animation = an;
    468487}
    469 
    470 extern char _binary_gfx_cons_selected_ppm_start[0];
    471 extern int _binary_gfx_cons_selected_ppm_size;
    472 extern char _binary_gfx_cons_idle_ppm_start[0];
    473 extern int _binary_gfx_cons_idle_ppm_size;
    474 extern char _binary_gfx_cons_has_data_ppm_start[0];
    475 extern int _binary_gfx_cons_has_data_ppm_size;
    476 extern char _binary_gfx_cons_kernel_ppm_start[0];
    477 extern int _binary_gfx_cons_kernel_ppm_size;
    478488
    479489/** Initialize nice graphical console environment */
     
    500510       
    501511        /* Create status buttons */
    502         size_t status_start = STATUS_START + (xres - 800) / 2;
     512        ipcarg_t status_start = STATUS_START + (xres - 800) / 2;
    503513        size_t i;
    504514        for (i = 0; i < CONSOLE_COUNT; i++) {
     
    511521               
    512522                vp_switch(cstatus_vp[i]);
    513                 set_rgb_color(0x202020, 0xffffff);
     523                set_rgb_color(COLOR_FOREGROUND, COLOR_BACKGROUND);
    514524        }
    515525       
  • uspace/srv/hid/console/gcons.h

    rcaad59a r9f1362d4  
    3838#include <sys/types.h>
    3939
    40 void gcons_init(int phone);
     40void gcons_init(int);
    4141
    4242void gcons_redraw_console(void);
    43 void gcons_change_console(size_t index);
    44 void gcons_notify_char(size_t index);
     43void gcons_change_console(size_t);
     44void gcons_notify_char(size_t);
    4545void gcons_in_kernel(void);
    4646
    47 void gcons_notify_connect(size_t index);
    48 void gcons_notify_disconnect(size_t index);
     47void gcons_notify_connect(size_t);
     48void gcons_notify_disconnect(size_t);
    4949
    50 void gcons_mouse_move(ssize_t dx, ssize_t dy);
     50void gcons_mouse_move(ssize_t, ssize_t);
    5151int gcons_mouse_btn(bool state);
    5252
  • uspace/srv/hid/console/keybuffer.h

    rcaad59a r9f1362d4  
    4747typedef struct {
    4848        console_event_t fifo[KEYBUFFER_SIZE];
    49         unsigned long head;
    50         unsigned long tail;
    51         unsigned long items;
     49        size_t head;
     50        size_t tail;
     51        size_t items;
    5252} keybuffer_t;
    5353
  • uspace/srv/hid/console/screenbuffer.c

    rcaad59a r9f1362d4  
    6767 *
    6868 */
    69 screenbuffer_t *screenbuffer_init(screenbuffer_t *scr, size_t size_x, size_t size_y)
     69screenbuffer_t *screenbuffer_init(screenbuffer_t *scr, ipcarg_t size_x,
     70    ipcarg_t size_y)
    7071{
    7172        scr->buffer = (keyfield_t *) malloc(sizeof(keyfield_t) * size_x * size_y);
     
    109110 *
    110111 */
    111 void screenbuffer_clear_line(screenbuffer_t *scr, size_t line)
     112void screenbuffer_clear_line(screenbuffer_t *scr, ipcarg_t line)
    112113{
    113         size_t x;
     114        ipcarg_t x;
    114115       
    115116        for (x = 0; x < scr->size_x; x++) {
     
    140141 *
    141142 */
    142 void screenbuffer_goto(screenbuffer_t *scr, size_t x, size_t y)
     143void screenbuffer_goto(screenbuffer_t *scr, ipcarg_t x, ipcarg_t y)
    143144{
    144145        scr->position_x = x % scr->size_x;
     
    166167 *
    167168 */
    168 void screenbuffer_set_color(screenbuffer_t *scr, uint8_t fg_color, uint8_t bg_color, uint8_t flags)
     169void screenbuffer_set_color(screenbuffer_t *scr, uint8_t fg_color,
     170    uint8_t bg_color, uint8_t flags)
    169171{
    170172        scr->attrs.t = at_idx;
     
    181183 *
    182184 */
    183 void screenbuffer_set_rgb_color(screenbuffer_t *scr, uint32_t fg_color, uint32_t bg_color)
     185void screenbuffer_set_rgb_color(screenbuffer_t *scr, uint32_t fg_color,
     186    uint32_t bg_color)
    184187{
    185188        scr->attrs.t = at_rgb;
  • uspace/srv/hid/console/screenbuffer.h

    rcaad59a r9f1362d4  
    3838#include <stdint.h>
    3939#include <sys/types.h>
     40#include <ipc/ipc.h>
    4041#include <bool.h>
    4142
    42 #define DEFAULT_FOREGROUND  0x0       /**< default console foreground color */
     43#define DEFAULT_FOREGROUND  0x000000  /**< default console foreground color */
    4344#define DEFAULT_BACKGROUND  0xf0f0f0  /**< default console background color */
    4445
     
    8283        keyfield_t *buffer;      /**< Screen content - characters and
    8384                                      their attributes (used as a circular buffer) */
    84         size_t size_x;           /**< Number of columns  */
    85         size_t size_y;           /**< Number of rows */
     85        ipcarg_t size_x;         /**< Number of columns  */
     86        ipcarg_t size_y;         /**< Number of rows */
    8687       
    8788        /** Coordinates of last printed character for determining cursor position */
    88         size_t position_x;
    89         size_t position_y;
     89        ipcarg_t position_x;
     90        ipcarg_t position_y;
    9091       
    9192        attrs_t attrs;           /**< Current attributes. */
     
    107108 *
    108109 */
    109 static inline keyfield_t *get_field_at(screenbuffer_t *scr, size_t x, size_t y)
     110static inline keyfield_t *get_field_at(screenbuffer_t *scr, ipcarg_t x, ipcarg_t y)
    110111{
    111112        return scr->buffer + x + ((y + scr->top_line) % scr->size_y) * scr->size_x;
     
    140141}
    141142
     143extern void screenbuffer_putchar(screenbuffer_t *, wchar_t);
     144extern screenbuffer_t *screenbuffer_init(screenbuffer_t *, ipcarg_t, ipcarg_t);
    142145
    143 void screenbuffer_putchar(screenbuffer_t *scr, wchar_t c);
    144 screenbuffer_t *screenbuffer_init(screenbuffer_t *scr, size_t size_x, size_t size_y);
    145 
    146 void screenbuffer_clear(screenbuffer_t *scr);
    147 void screenbuffer_clear_line(screenbuffer_t *scr, size_t line);
    148 void screenbuffer_copy_buffer(screenbuffer_t *scr, keyfield_t *dest);
    149 void screenbuffer_goto(screenbuffer_t *scr, size_t x, size_t y);
    150 void screenbuffer_set_style(screenbuffer_t *scr, uint8_t style);
    151 void screenbuffer_set_color(screenbuffer_t *scr, uint8_t fg_color,
    152     uint8_t bg_color, uint8_t attr);
    153 void screenbuffer_set_rgb_color(screenbuffer_t *scr, uint32_t fg_color,
    154     uint32_t bg_color);
     146extern void screenbuffer_clear(screenbuffer_t *);
     147extern void screenbuffer_clear_line(screenbuffer_t *, ipcarg_t);
     148extern void screenbuffer_copy_buffer(screenbuffer_t *, keyfield_t *);
     149extern void screenbuffer_goto(screenbuffer_t *, ipcarg_t, ipcarg_t);
     150extern void screenbuffer_set_style(screenbuffer_t *, uint8_t);
     151extern void screenbuffer_set_color(screenbuffer_t *, uint8_t, uint8_t, uint8_t);
     152extern void screenbuffer_set_rgb_color(screenbuffer_t *, uint32_t, uint32_t);
    155153
    156154#endif
  • uspace/srv/hid/fb/ega.c

    rcaad59a r9f1362d4  
    2828
    2929/** @defgroup egafb EGA framebuffer
    30  * @brief       HelenOS EGA framebuffer.
     30 * @brief HelenOS EGA framebuffer.
    3131 * @ingroup fbs
    3232 * @{
    33  */ 
     33 */
    3434/** @file
    3535 */
     
    5858#include "main.h"
    5959
    60 #define MAX_SAVED_SCREENS 256
     60#define MAX_SAVED_SCREENS  256
     61
    6162typedef struct saved_screen {
    6263        short *data;
     
    6566saved_screen saved_screens[MAX_SAVED_SCREENS];
    6667
    67 #define EGA_IO_BASE ((ioport8_t *) 0x3d4)
    68 #define EGA_IO_SIZE 2
    69 
    70 int ega_normal_color = 0x0f;
    71 int ega_inverted_color = 0xf0;
    72 
    73 #define NORMAL_COLOR            ega_normal_color
    74 #define INVERTED_COLOR          ega_inverted_color
     68#define EGA_IO_BASE  ((ioport8_t *) 0x3d4)
     69#define EGA_IO_SIZE  2
    7570
    7671/* Allow only 1 connection */
    7772static int client_connected = 0;
    7873
    79 static unsigned int scr_width;
    80 static unsigned int scr_height;
     74static sysarg_t scr_width;
     75static sysarg_t scr_height;
    8176static uint8_t *scr_addr;
    8277
    83 static unsigned int style;
    84 
    85 static unsigned attr_to_ega_style(const attrs_t *a);
    86 static uint8_t ega_glyph(wchar_t ch);
     78static uint8_t style_normal = 0xf0;
     79static uint8_t style_inverted = 0x0f;
     80static uint8_t style;
     81
     82static uint8_t style_to_ega_style(uint8_t style)
     83{
     84        switch (style) {
     85        case STYLE_EMPHASIS:
     86                return (style_normal | 0x04);
     87        case STYLE_SELECTED:
     88                return (style_inverted | 0x40);
     89        case STYLE_INVERTED:
     90                return style_inverted;
     91        }
     92       
     93        return style_normal;
     94}
     95
     96static uint8_t color_to_ega_style(uint8_t fg_color, uint8_t bg_color,
     97    uint8_t attr)
     98{
     99        uint8_t style = (fg_color & 7) | ((bg_color & 7) << 4);
     100       
     101        if (attr & CATTR_BRIGHT)
     102                style |= 0x08;
     103       
     104        return style;
     105}
     106
     107static uint8_t rgb_to_ega_style(uint32_t fg, uint32_t bg)
     108{
     109        return (fg > bg) ? style_inverted : style_normal;
     110}
     111
     112static uint8_t attr_to_ega_style(const attrs_t *attr)
     113{
     114        switch (attr->t) {
     115        case at_style:
     116                return style_to_ega_style(attr->a.s.style);
     117        case at_idx:
     118                return color_to_ega_style(attr->a.i.fg_color,
     119                    attr->a.i.bg_color, attr->a.i.flags);
     120        case at_rgb:
     121                return rgb_to_ega_style(attr->a.r.fg_color, attr->a.r.bg_color);
     122        default:
     123                return style_normal;
     124        }
     125}
     126
     127static uint8_t ega_glyph(wchar_t ch)
     128{
     129        if (ch >= 0 && ch < 128)
     130                return ch;
     131       
     132        return '?';
     133}
    87134
    88135static void clrscr(void)
     
    96143}
    97144
    98 static void cursor_goto(unsigned int col, unsigned int row)
    99 {
    100         int ega_cursor;
    101 
    102         ega_cursor = col + scr_width * row;
     145static void cursor_goto(sysarg_t col, sysarg_t row)
     146{
     147        sysarg_t cursor = col + scr_width * row;
    103148       
    104149        pio_write_8(EGA_IO_BASE, 0xe);
    105         pio_write_8(EGA_IO_BASE + 1, (ega_cursor >> 8) & 0xff);
     150        pio_write_8(EGA_IO_BASE + 1, (cursor >> 8) & 0xff);
    106151        pio_write_8(EGA_IO_BASE, 0xf);
    107         pio_write_8(EGA_IO_BASE + 1, ega_cursor & 0xff);
     152        pio_write_8(EGA_IO_BASE + 1, cursor & 0xff);
    108153}
    109154
    110155static void cursor_disable(void)
    111156{
    112         uint8_t stat;
    113 
    114157        pio_write_8(EGA_IO_BASE, 0xa);
    115         stat = pio_read_8(EGA_IO_BASE + 1);
     158       
     159        uint8_t stat = pio_read_8(EGA_IO_BASE + 1);
     160       
    116161        pio_write_8(EGA_IO_BASE, 0xa);
    117162        pio_write_8(EGA_IO_BASE + 1, stat | (1 << 5));
     
    120165static void cursor_enable(void)
    121166{
    122         uint8_t stat;
    123 
    124167        pio_write_8(EGA_IO_BASE, 0xa);
    125         stat = pio_read_8(EGA_IO_BASE + 1);
     168       
     169        uint8_t stat = pio_read_8(EGA_IO_BASE + 1);
     170       
    126171        pio_write_8(EGA_IO_BASE, 0xa);
    127172        pio_write_8(EGA_IO_BASE + 1, stat & (~(1 << 5)));
    128173}
    129174
    130 static void scroll(int rows)
    131 {
    132         unsigned i;
    133 
     175static void scroll(ssize_t rows)
     176{
     177        size_t i;
     178       
    134179        if (rows > 0) {
    135180                memmove(scr_addr, ((char *) scr_addr) + rows * scr_width * 2,
     
    142187                    scr_width * scr_height * 2 + rows * scr_width * 2);
    143188                for (i = 0; i < -rows * scr_width; i++)
    144                         ((short *)scr_addr)[i] = ((style << 8 ) + ' ');
    145         }
    146 }
    147 
    148 static void printchar(wchar_t c, unsigned int col, unsigned int row)
     189                        ((short *) scr_addr)[i] = ((style << 8 ) + ' ');
     190        }
     191}
     192
     193static void printchar(wchar_t c, sysarg_t col, sysarg_t row)
    149194{
    150195        scr_addr[(row * scr_width + col) * 2] = ega_glyph(c);
     
    158203 * @param vport Viewport id
    159204 * @param data  Text data.
    160  * @param x     Leftmost column of the area.
    161  * @param y     Topmost row of the area.
    162  * @param w     Number of rows.
    163  * @param h     Number of columns.
     205 * @param x     Leftmost column of the area.
     206 * @param y     Topmost row of the area.
     207 * @param w     Number of rows.
     208 * @param h     Number of columns.
     209 *
    164210 */
    165 static void draw_text_data(keyfield_t *data, unsigned int x,
    166     unsigned int y, unsigned int w, unsigned int h)
    167 {
    168         unsigned int i, j;
     211static void draw_text_data(keyfield_t *data, sysarg_t x, sysarg_t y,
     212    sysarg_t w, sysarg_t h)
     213{
     214        sysarg_t i;
     215        sysarg_t j;
    169216        keyfield_t *field;
    170217        uint8_t *dp;
    171 
     218       
    172219        for (j = 0; j < h; j++) {
    173220                for (i = 0; i < w; i++) {
    174221                        field = &data[j * w + i];
    175222                        dp = &scr_addr[2 * ((y + j) * scr_width + (x + i))];
    176 
     223                       
    177224                        dp[0] = ega_glyph(field->character);
    178225                        dp[1] = attr_to_ega_style(&field->attrs);
     
    183230static int save_screen(void)
    184231{
    185         int i;
    186 
    187         for (i = 0; (i < MAX_SAVED_SCREENS) && (saved_screens[i].data); i++)
    188                 ;
    189         if (i == MAX_SAVED_SCREENS)
     232        ipcarg_t i;
     233       
     234        /* Find empty screen */
     235        for (i = 0; (i < MAX_SAVED_SCREENS) && (saved_screens[i].data); i++);
     236       
     237        if (i == MAX_SAVED_SCREENS)
    190238                return EINVAL;
    191         if (!(saved_screens[i].data = malloc(2 * scr_width * scr_height)))
     239       
     240        if (!(saved_screens[i].data = malloc(2 * scr_width * scr_height)))
    192241                return ENOMEM;
     242       
    193243        memcpy(saved_screens[i].data, scr_addr, 2 * scr_width * scr_height);
    194 
    195         return i;
    196 }
    197 
    198 static int print_screen(int i)
    199 {
    200         if (saved_screens[i].data)
     244        return (int) i;
     245}
     246
     247static int print_screen(ipcarg_t i)
     248{
     249        if ((i >= MAX_SAVED_SCREENS) || (saved_screens[i].data))
    201250                memcpy(scr_addr, saved_screens[i].data, 2 * scr_width *
    202251                    scr_height);
    203252        else
    204253                return EINVAL;
    205         return i;
    206 }
    207 
    208 static int style_to_ega_style(int style)
    209 {
    210         unsigned int ega_style;
    211 
    212         switch (style) {
    213         case STYLE_NORMAL:
    214                 ega_style = INVERTED_COLOR;
    215                 break;
    216         case STYLE_EMPHASIS:
    217                 ega_style = INVERTED_COLOR | 4;
    218                 break;
    219         default:
    220                 return INVERTED_COLOR;
    221         }
    222 
    223         return ega_style;
    224 }
    225 
    226 static unsigned int color_to_ega_style(int fg_color, int bg_color, int attr)
    227 {
    228         unsigned int style;
    229 
    230         style = (fg_color & 7) | ((bg_color & 7) << 4);
    231         if (attr & CATTR_BRIGHT)
    232                 style = style | 0x08;
    233 
    234         return style;
    235 }
    236 
    237 static unsigned int rgb_to_ega_style(uint32_t fg, uint32_t bg)
    238 {
    239         return (fg > bg) ? NORMAL_COLOR : INVERTED_COLOR;
    240 }
    241 
    242 static unsigned attr_to_ega_style(const attrs_t *a)
    243 {
    244         switch (a->t) {
    245         case at_style:
    246                 return style_to_ega_style(a->a.s.style);
    247         case at_rgb:
    248                 return rgb_to_ega_style(a->a.r.fg_color, a->a.r.bg_color);
    249         case at_idx:
    250                 return color_to_ega_style(a->a.i.fg_color,
    251                     a->a.i.bg_color, a->a.i.flags);
    252         default:
    253                 return INVERTED_COLOR;
    254         }
    255 }
    256 
    257 static uint8_t ega_glyph(wchar_t ch)
    258 {
    259         if (ch >= 0 && ch < 128)
    260                 return ch;
    261 
    262         return '?';
     254       
     255        return (int) i;
    263256}
    264257
    265258static void ega_client_connection(ipc_callid_t iid, ipc_call_t *icall)
    266259{
    267         int retval;
    268         ipc_callid_t callid;
    269         ipc_call_t call;
    270         wchar_t c;
    271         unsigned int row, col, w, h;
    272         int bg_color, fg_color, attr;
    273         uint32_t bg_rgb, fg_rgb;
     260        size_t intersize = 0;
    274261        keyfield_t *interbuf = NULL;
    275         size_t intersize = 0;
    276         int i;
    277262
    278263        if (client_connected) {
     
    280265                return;
    281266        }
     267       
     268        /* Accept connection */
    282269        client_connected = 1;
    283         ipc_answer_0(iid, EOK); /* Accept connection */
    284 
    285         while (1) {
    286                 callid = async_get_call(&call);
    287                 switch (IPC_GET_METHOD(call)) {
     270        ipc_answer_0(iid, EOK);
     271       
     272        while (true) {
     273                ipc_call_t call;
     274                ipc_callid_t callid = async_get_call(&call);
     275               
     276                wchar_t c;
     277               
     278                ipcarg_t col;
     279                ipcarg_t row;
     280                ipcarg_t w;
     281                ipcarg_t h;
     282               
     283                ssize_t rows;
     284               
     285                uint8_t bg_color;
     286                uint8_t fg_color;
     287                uint8_t attr;
     288               
     289                uint32_t fg_rgb;
     290                uint32_t bg_rgb;
     291               
     292                ipcarg_t scr;
     293                int retval;
     294               
     295                switch (IPC_GET_METHOD(call)) {
    288296                case IPC_M_PHONE_HUNGUP:
    289297                        client_connected = 0;
    290298                        ipc_answer_0(callid, EOK);
    291                         return; /* Exit thread */
     299                       
     300                        /* Exit thread */
     301                        return;
    292302                case IPC_M_SHARE_OUT:
    293303                        /* We accept one area for data interchange */
     
    299309                                continue;
    300310                        }
     311                       
    301312                        retval = EINVAL;
    302313                        break;
    303314                case FB_DRAW_TEXT_DATA:
     315                        if (!interbuf) {
     316                                retval = EINVAL;
     317                                break;
     318                        }
     319                       
    304320                        col = IPC_GET_ARG1(call);
    305321                        row = IPC_GET_ARG2(call);
    306322                        w = IPC_GET_ARG3(call);
    307323                        h = IPC_GET_ARG4(call);
    308                         if (!interbuf) {
     324                       
     325                        if ((col + w > scr_width) || (row + h > scr_height)) {
    309326                                retval = EINVAL;
    310327                                break;
    311328                        }
    312                         if (col + w > scr_width || row + h > scr_height) {
    313                                 retval = EINVAL;
    314                                 break;
    315                         }
     329                       
    316330                        draw_text_data(interbuf, col, row, w, h);
    317331                        retval = 0;
     
    331345                        col = IPC_GET_ARG2(call);
    332346                        row = IPC_GET_ARG3(call);
    333                         if (col >= scr_width || row >= scr_height) {
     347                       
     348                        if ((col >= scr_width) || (row >= scr_height)) {
    334349                                retval = EINVAL;
    335350                                break;
    336351                        }
     352                       
    337353                        printchar(c, col, row);
    338354                        retval = 0;
    339355                        break;
    340                 case FB_CURSOR_GOTO:
    341                         col = IPC_GET_ARG1(call);
     356                case FB_CURSOR_GOTO:
     357                        col = IPC_GET_ARG1(call);
    342358                        row = IPC_GET_ARG2(call);
    343                         if (row >= scr_height || col >= scr_width) {
     359                       
     360                        if ((row >= scr_height) || (col >= scr_width)) {
    344361                                retval = EINVAL;
    345362                                break;
    346363                        }
     364                       
    347365                        cursor_goto(col, row);
    348                         retval = 0;
    349                         break;
     366                        retval = 0;
     367                        break;
    350368                case FB_SCROLL:
    351                         i = IPC_GET_ARG1(call);
    352                         if (i > (int) scr_height || i < -((int) scr_height)) {
    353                                 retval = EINVAL;
    354                                 break;
    355                         }
    356                         scroll(i);
     369                        rows = IPC_GET_ARG1(call);
     370                       
     371                        if (rows >= 0) {
     372                                if ((ipcarg_t) rows > scr_height) {
     373                                        retval = EINVAL;
     374                                        break;
     375                                }
     376                        } else {
     377                                if ((ipcarg_t) (-rows) > scr_height) {
     378                                        retval = EINVAL;
     379                                        break;
     380                                }
     381                        }
     382                       
     383                        scroll(rows);
    357384                        retval = 0;
    358385                        break;
     
    362389                        else
    363390                                cursor_disable();
     391                       
    364392                        retval = 0;
    365393                        break;
     
    372400                        bg_color = IPC_GET_ARG2(call);
    373401                        attr = IPC_GET_ARG3(call);
     402                       
    374403                        style = color_to_ega_style(fg_color, bg_color, attr);
    375404                        retval = 0;
     
    378407                        fg_rgb = IPC_GET_ARG1(call);
    379408                        bg_rgb = IPC_GET_ARG2(call);
     409                       
    380410                        style = rgb_to_ega_style(fg_rgb, bg_rgb);
    381411                        retval = 0;
    382412                        break;
    383413                case FB_VP_DRAW_PIXMAP:
    384                         i = IPC_GET_ARG2(call);
    385                         retval = print_screen(i);
     414                        scr = IPC_GET_ARG2(call);
     415                        retval = print_screen(scr);
    386416                        break;
    387417                case FB_VP2PIXMAP:
     
    389419                        break;
    390420                case FB_DROP_PIXMAP:
    391                         i = IPC_GET_ARG1(call);
    392                         if (i >= MAX_SAVED_SCREENS) {
     421                        scr = IPC_GET_ARG1(call);
     422                       
     423                        if (scr >= MAX_SAVED_SCREENS) {
    393424                                retval = EINVAL;
    394425                                break;
    395426                        }
    396                         if (saved_screens[i].data) {
    397                                 free(saved_screens[i].data);
    398                                 saved_screens[i].data = NULL;
    399                         }
     427                       
     428                        if (saved_screens[scr].data) {
     429                                free(saved_screens[scr].data);
     430                                saved_screens[scr].data = NULL;
     431                        }
     432                       
    400433                        retval = 0;
    401434                        break;
     
    413446int ega_init(void)
    414447{
    415         void *ega_ph_addr;
    416         size_t sz;
    417        
    418448        sysarg_t paddr;
    419449        if (sysinfo_get_value("fb.address.physical", &paddr) != EOK)
    420450                return -1;
    421451       
    422         sysarg_t width;
    423         if (sysinfo_get_value("fb.width", &width) != EOK)
     452        if (sysinfo_get_value("fb.width", &scr_width) != EOK)
    424453                return -1;
    425454       
    426         sysarg_t height;
    427         if (sysinfo_get_value("fb.width", &height) != EOK)
     455        if (sysinfo_get_value("fb.height", &scr_height) != EOK)
    428456                return -1;
    429457       
     
    432460                blinking = false;
    433461       
    434         ega_ph_addr = (void *) paddr;
    435         scr_width = width;
    436         scr_height = height;
     462        void *ega_ph_addr = (void *) paddr;
    437463        if (blinking) {
    438                 ega_normal_color &= 0x77;
    439                 ega_inverted_color &= 0x77;
    440         }
    441        
    442         style = NORMAL_COLOR;
     464                style_normal &= 0x77;
     465                style_inverted &= 0x77;
     466        }
     467       
     468        style = style_normal;
    443469       
    444470        iospace_enable(task_get_id(), (void *) EGA_IO_BASE, 2);
    445471       
    446         sz = scr_width * scr_height * 2;
     472        size_t sz = scr_width * scr_height * 2;
    447473        scr_addr = as_get_mappable_page(sz);
    448474       
     
    450476            PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE) != 0)
    451477                return -1;
    452 
     478       
    453479        async_set_client_connection(ega_client_connection);
    454 
     480       
    455481        return 0;
    456482}
    457 
    458483
    459484/**
  • uspace/srv/hid/fb/fb.c

    rcaad59a r9f1362d4  
    7272#define DEFAULT_FGCOLOR  0x000000
    7373
    74 #define GLYPH_UNAVAIL    '?'
    75 
    76 #define MAX_ANIM_LEN     8
    77 #define MAX_ANIMATIONS   4
    78 #define MAX_PIXMAPS      256  /**< Maximum number of saved pixmaps */
    79 #define MAX_VIEWPORTS    128  /**< Viewport is a rectangular area on the screen */
     74#define GLYPH_UNAVAIL  '?'
     75
     76#define MAX_ANIM_LEN    8
     77#define MAX_ANIMATIONS  4
     78#define MAX_PIXMAPS     256  /**< Maximum number of saved pixmaps */
     79#define MAX_VIEWPORTS   128  /**< Viewport is a rectangular area on the screen */
    8080
    8181/** Function to render a pixel from a RGB value. */
     
    956956        bb_cell_t *bbp;
    957957        attrs_t *a;
    958         attr_rgb_t rgb;
    959958       
    960959        for (j = 0; j < h; j++) {
     
    966965                       
    967966                        a = &data[j * w + i].attrs;
     967                       
     968                        attr_rgb_t rgb;
     969                        rgb.fg_color = 0;
     970                        rgb.bg_color = 0;
    968971                        rgb_from_attr(&rgb, a);
    969972                       
     
    15111514                rgb->bg_color = color_table[COLOR_WHITE];
    15121515                break;
     1516        case STYLE_INVERTED:
     1517                rgb->fg_color = color_table[COLOR_WHITE];
     1518                rgb->bg_color = color_table[COLOR_BLACK];
     1519                break;
     1520        case STYLE_SELECTED:
     1521                rgb->fg_color = color_table[COLOR_WHITE];
     1522                rgb->bg_color = color_table[COLOR_RED];
     1523                break;
    15131524        default:
    15141525                return EINVAL;
    15151526        }
    1516 
     1527       
    15171528        return EOK;
    15181529}
Note: See TracChangeset for help on using the changeset viewer.