Make --with-pjproject-bundled the default for Asterisk 15
[asterisk/asterisk.git] / channels / console_board.c
index fbc92c5..e5ff1fc 100644 (file)
@@ -1,39 +1,54 @@
+/*
+ * 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 section of an sdl screen where
+ * 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.
+ * down by dragging (not yet!)
  * 
  * TODO: font dynamic allocation
  *
- * OLD: The physical section displayed on the screen is defined
+ * 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.
- *
- * OLD: To define a message board:
- *  - declare a board in the gui_info structure;
- *  - define a region name in the keypad skin and update
- *    the gui_key_map list;
- *  - add and manage focus events on its.
- *
+ * 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 */
 
-#ifndef HAVE_SDL
-/* nothing */
-#else
+#ifdef HAVE_SDL        /* we only use this code if SDL is available */
 #include <SDL/SDL.h>
 
-#define GUI_BUFFER_LEN 256                     /* buffer lenght used for input buffers */
-
-/* Fonts characterization, TODO, read from file */
+/* Fonts characterization. XXX should be read from the file */
 #define FONT_H 20                      /* char height, pixels */
 #define FONT_W 9                       /* char width, pixels */
 
@@ -100,10 +115,12 @@ struct board *board_setup(SDL_Surface *screen, SDL_Rect *dest,
        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");
@@ -112,7 +129,7 @@ struct board *board_setup(SDL_Surface *screen, SDL_Rect *dest,
        }
        memset(b->text, ' ', b->v_w * b->v_h);  /* fill with spaces */
 
-       /* XXX make a copy of the original, for cleaning up */
+       /* 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,
@@ -134,40 +151,12 @@ struct board *board_setup(SDL_Surface *screen, SDL_Rect *dest,
        b->cur_col = 0;         /* current print column */
        b->cur_line = 0;        /* last line displayed */
 
-       ast_log(LOG_WARNING, "Message board %dx%d@%d,%d successfully initialized\n",
+       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;
 }
 
-#if 0
-
-/*! \brief Remap and blit the virtual surface on the physical surface */
-static void blit_on_screen(struct gui_info *gui, struct board *b)
-{
-       /* Blit a section of the virtual board on the main surface */
-       SDL_Rect mapped_rect;   /* coordinates related to the main surface */
-
-       mapped_rect.x = 0;
-       mapped_rect.y = b->rendering_offset;
-       mapped_rect.w = b->p_rect.w;
-       mapped_rect.h = b->p_rect.h;
-
-       /* Clean the surface (print backgroud) */
-       // This sould be done in the main loop
-       // SDL_BlitSurface(gui->keypad, NULL, gui->screen, &b->p_rect);
-       SDL_BlitSurface(gui->keypad, NULL, gui->screen, &b->p_rect);
-
-       /* Blit the virtual surface on the main surface */
-       SDL_BlitSurface(b->v_board, &mapped_rect, gui->screen, &b->p_rect);
-
-       /* Update the keypad screen, should be done in the main loop */
-       SDL_UpdateRects(gui->screen, 1, &gui->message_board.p_rect);
-       //SDL_UpdateRects(gui->screen, 1, &gui->message_board.p_rect);
-}
-
-#endif /* notyet */
-
 /* 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.
@@ -193,7 +182,9 @@ static void render_board(struct board *b)
 
        /* blit all characters */
        for (i = first_char, col = 0; i <  last_char; i++) {
-               int c = b->text[i] - 32;
+               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;
@@ -204,15 +195,38 @@ static void render_board(struct board *b)
                        col = 0;
                }
        }
-       /* Update the written portion of the keypad on the screen */
-       SDL_UpdateRects(b->screen, 1, b->p_rect);
+       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 print_message(struct board *b, const char *s)
 {
        int i, l, row, col;
@@ -274,12 +288,14 @@ int print_message(struct board *b, const char *s)
                        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 */
@@ -293,13 +309,30 @@ int print_message(struct board *b, const char *s)
                        break;
                }
        }
+       dst[col] = '\0'; /* the current position is empty */
        b->cur_col = col;
        /* everything is printed now, must do the rendering */
-       //board_dump(b);
        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.
  */