console_board.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright 2007-2008, Marta Carbone, Luigi Rizzo
 *
 * See http://www.asterisk.org for more information about
 * the Asterisk project. Please do not directly contact
 * any of the maintainers of this project for assistance;
 * the project provides a web site, mailing lists and IRC
 * channels for your use.
 *
 * This program is free software, distributed under the terms of
 * the GNU General Public License Version 2. See the LICENSE file
 * at the top of the source tree.
 *
 * $Revision$
 */
 
/*
 * Message board implementation.
 *
 * A message board is a region of the SDL screen where
 * messages can be printed, like on a terminal window.
 *
 * At the moment we support fix-size font.
 *
 * The text is stored in a buffer
 * of fixed size (rows and cols). A portion of the buffer is
 * visible on the screen, and the visible window can be moved up and
 * down by dragging (not yet!)
 *
 * TODO: font dynamic allocation
 *
 * The region where the text is displayed on the screen is defined
 * as keypad element, (the name is defined in the `region' variable
 * so the board geometry can be read from the skin or from the
 * configuration file).
 */
 
/*** MODULEINFO
    <support_level>extended</support_level>
 ***/
 
#include "asterisk.h"   /* ast_strdupa */
#include "asterisk/utils.h" /* ast_strdupa */
#include "console_video.h"  /* ast_strdupa */
 
#ifdef HAVE_SDL /* we only use this code if SDL is available */
#include <SDL/SDL.h>
 
/* Fonts characterization. XXX should be read from the file */
#define FONT_H 20           /* char height, pixels */
#define FONT_W 9            /* char width, pixels */
 
struct board {
    int     kb_output;  /* identity of the board */
    /* pointer to the destination surface (on the keypad window) */
    SDL_Surface *screen;    /* the main screen */
    SDL_Rect    *p_rect;    /* where to write on the main screen */
    SDL_Surface *blank;     /* original content of the window */
 
    int v_h;    /* virtual text height, in lines */
    int v_w;    /* virtual text width, in lines (probably same as p_w) */
    int p_h;    /* physical (displayed) text height, in lines
             * XXX p_h * FONT_H = pixel_height */
    int p_w;    /* physical (displayed) text width, in characters
             * XXX p_w * FONT_W = pixel_width */
 
    int cur_col; /* print position (free character) on the last line */
    int cur_line;   /* first (or last ?) virtual line displayed,
                     * 0 is the line at the bottom, 1 is the one above,...
                     */
 
    SDL_Surface     *font;      /* points to a surface in the gui structure */
    SDL_Rect    *font_rects;    /* pointer to the font rects */
    char        *text;
                /* text buffer, v_h * v_w char.
                 * We make sure the buffer is always full,
                 * print on some position on the last line,
                 * and scroll up when appending new text
                 */
};
 
/*! \brief Initialize the board.
 * return 0 on success, 1 on error
 * TODO, if this is done at reload time,
 * free resources before allocate new ones
 * TODO: resource deallocation in case of error.
 * TODO: move the font load at gui_initialization
 * TODO: deallocation of the message history
 */
struct board *board_setup(SDL_Surface *screen, SDL_Rect *dest,
    SDL_Surface *font, SDL_Rect *font_rects);
struct board *board_setup(SDL_Surface *screen, SDL_Rect *dest,
    SDL_Surface *font, SDL_Rect *font_rects)
{
    struct board *b = ast_calloc(1, sizeof (*b));
    SDL_Rect br;
 
    if (b == NULL)
        return NULL;
    /* font, points to the gui structure */
    b->font = font;
    b->font_rects = font_rects;
 
    /* Destination rectangle on the screen - reference is the whole screen */
    b->p_rect = dest;
    b->screen = screen;
 
    /* compute physical sizes */
    b->p_h = b->p_rect->h/FONT_H;
    b->p_w = b->p_rect->w/FONT_W;
 
    /* virtual sizes */
    b->v_h = b->p_h * 10; /* XXX 10 times larger */
    b->v_w = b->p_w;    /* same width */
 
    /* the rectangle we actually use */
    br.h = b->p_h * FONT_H; /* pixel sizes of the background */
    br.w = b->p_w * FONT_W;
    br.x = br.y = 0;
 
    /* allocate a buffer for the text */
    b->text = ast_calloc(b->v_w*b->v_h + 1, 1);
    if (b->text == NULL) {
        ast_log(LOG_WARNING, "Unable to allocate board history memory.\n");
        ast_free(b);
        return NULL;
    }
    memset(b->text, ' ', b->v_w * b->v_h);  /* fill with spaces */
 
    /* make a copy of the original rectangle, for cleaning up */
    b->blank = SDL_CreateRGBSurface(screen->flags, br.w, br.h,
        screen->format->BitsPerPixel,
        screen->format->Rmask, screen->format->Gmask,
        screen->format->Bmask, screen->format->Amask);
 
    if (b->blank == NULL) {
        ast_log(LOG_WARNING, "Unable to allocate board virtual screen: %s\n",
                SDL_GetError());
        ast_free(b->text);
        ast_free(b);
        return NULL;
    }
    SDL_BlitSurface(screen, b->p_rect, b->blank, &br);
 
    /* Set color key, if not alpha channel present */
    //colorkey = SDL_MapRGB(b->board_surface->format, 0, 0, 0);
    //SDL_SetColorKey(b->board_surface, SDL_SRCCOLORKEY, colorkey);
 
    b->cur_col = 0;     /* current print column */
    b->cur_line = 0;    /* last line displayed */
 
    if (0) ast_log(LOG_WARNING, "Message board %dx%d@%d,%d successfully initialized\n",
        b->p_rect->w, b->p_rect->h,
        b->p_rect->x, b->p_rect->y);
    return b;
}
 
/* Render the text on the board surface.
 * The first line to render is the one at v_h - p_h - cur_line,
 * the size is p_h * p_w.
 * XXX we assume here that p_w = v_w.
 */
static void render_board(struct board *b)
{
    int first_row = b->v_h - b->p_h - b->cur_line;
    int first_char = b->v_w * first_row;
    int last_char = first_char + b->p_h * b->v_w;
    int i, col;
    SDL_Rect dst;
 
    /* top left char on the physical surface */
    dst.w = FONT_W;
    dst.h = FONT_H;
    dst.x = b->p_rect->x;
    dst.y = b->p_rect->y;
 
 
    /* clean the surface board */
    SDL_BlitSurface(b->blank, NULL, b->screen, b->p_rect);
 
    /* blit all characters */
    for (i = first_char, col = 0; i <  last_char; i++) {
        int c = b->text[i] - 32;    /* XXX first 32 chars are not printable */
        if (c < 0) /* buffer terminator or anything else is a blank */
            c = 0;
        SDL_BlitSurface(b->font, &b->font_rects[c], b->screen, &dst);
        /* point dst to next char position */
        dst.x += dst.w;
        col++;
        if (col >= b->v_w) { /* next row */
            dst.x = b->p_rect->x;
            dst.y += dst.h;
            col = 0;
        }
    }
    SDL_UpdateRects(b->screen, 1, b->p_rect);   /* Update the screen */
}
 
void move_message_board(struct board *b, int dy)
{
    int cur = b->cur_line + dy;
    if (cur < 0)
        cur = 0;
    else if (cur >= b->v_h - b->p_h)
        cur = b->v_h - b->p_h - 1;
    b->cur_line = cur;
    render_board(b);
}
 
/* return the content of a board */
const char *read_message(const struct board *b)
{
    return b->text;
}
 
int reset_board(struct board *b)
{
    memset(b->text, ' ', b->v_w * b->v_h);  /* fill with spaces */
    b->cur_col = 0;
    b->cur_line = 0;
    render_board(b);
    return 0;
}
/* Store the message on the history board
 * and blit on screen if required.
 * XXX now easy. only regular chars
 */
int print_message(struct board *b, const char *s)
{
    int i, l, row, col;
    char *dst;
 
    if (ast_strlen_zero(s))
        return 0;
 
    l = strlen(s);
    row = 0;
    col = b->cur_col;
    /* First, only check how much space we need.
     * Starting from the current print position, we move
     * it forward and down (if necessary) according to input
     * characters (including newlines, tabs, backspaces...).
     * At the end, row tells us how many rows to scroll, and
     * col (ignored) is the final print position.
     */
    for (i = 0; i < l; i++) {
        switch (s[i]) {
        case '\r':
            col = 0;
            break;
        case '\n':
            col = 0;
            row++;
            break;
        case '\b':
            if (col > 0)
                col--;
            break;
        default:
            if (s[i] < 32) /* signed, so take up to 127 */
                break;
            col++;
            if (col >= b->v_w) {
                col -= b->v_w;
                row++;
            }
            break;
        }
    }
    /* scroll the text window */
    if (row > 0) { /* need to scroll by 'row' rows */
        memcpy(b->text, b->text + row * b->v_w, b->v_w * (b->v_h - row));
        /* clean the destination area */
        dst = b->text + b->v_w * (b->v_h - row - 1) + b->cur_col;
        memset(dst, ' ', b->v_w - b->cur_col + b->v_w * row);
    }
    /* now do the actual printing. The print position is 'row' lines up
     * from the bottom of the buffer, start at the same 'cur_col' as before.
     * dst points to the beginning of the current line.
     */
    dst = b->text + b->v_w * (b->v_h - row - 1); /* start of current line */
    col = b->cur_col;
    for (i = 0; i < l; i++) {
        switch (s[i]) {
        case '\r':
            col = 0;
            break;
        case '\n':  /* move to beginning of next line */
            dst[col] = '\0'; /* mark the rest of the line as empty */
            col = 0;
            dst += b->v_w;
            break;
        case '\b':  /* one char back */
            if (col > 0)
                col--;
            dst[col] = ' '; /* delete current char */
            break;
        default:
            if (s[i] < 32) /* signed, so take up to 127 */
                break;  /* non printable */
            dst[col] = s[i];    /* store character */
            col++;
            if (col >= b->v_w) {
                col -= b->v_w;
                dst += b->v_w;
            }
            break;
        }
    }
    dst[col] = '\0'; /* the current position is empty */
    b->cur_col = col;
    /* everything is printed now, must do the rendering */
    render_board(b);
    return 1;
}
 
/* deletes a board.
 * we make the free operation on any fields of the board structure allocated
 * in dynamic memory
 */
void delete_board(struct board *b)
{
    if (b) {
        /* deletes the text */
        if (b->text)
            ast_free (b->text);
        /* deallocates the blank surface */
        SDL_FreeSurface(b->blank);
        /* deallocates the board */
        ast_free(b);
    }
}
 
#if 0
/*! \brief refresh the screen, and also grab a bunch of events.
 */
static int scroll_message(...)
{
if moving up, scroll text up;
    if (gui->message_board.screen_cur > 0)
    gui->message_board.screen_cur--;
otherwise scroll text down.
    if ((b->screen_cur + b->p_line) < b->board_next) {
    gui->message_board.screen_cur++;
#endif /* notyet */
 
#endif /* HAVE_SDL */