fix wrong argument in checking boundaries for a rectangle
[asterisk/asterisk.git] / channels / console_board.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright 2007-2008, Marta Carbone, Luigi Rizzo
5  *
6  * See http://www.asterisk.org for more information about
7  * the Asterisk project. Please do not directly contact
8  * any of the maintainers of this project for assistance;
9  * the project provides a web site, mailing lists and IRC
10  * channels for your use.
11  *
12  * This program is free software, distributed under the terms of
13  * the GNU General Public License Version 2. See the LICENSE file
14  * at the top of the source tree.
15  *
16  * $Revision$
17  */
18
19 /* 
20  * Message board implementation.
21  *
22  * A message board is a region of the SDL screen where
23  * messages can be printed, like on a terminal window.
24  *
25  * At the moment we support fix-size font.
26  *
27  * The text is stored in a buffer
28  * of fixed size (rows and cols). A portion of the buffer is
29  * visible on the screen, and the visible window can be moved up and
30  * down by dragging (not yet!)
31  * 
32  * TODO: font dynamic allocation
33  *
34  * The region where the text is displayed on the screen is defined
35  * as keypad element, (the name is defined in the `region' variable
36  * so the board geometry can be read from the skin or from the
37  * configuration file).
38  */
39
40 #include "asterisk.h"   /* ast_strdupa */
41 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
42 #include "asterisk/utils.h"     /* ast_strdupa */
43 #include "console_video.h"      /* ast_strdupa */
44
45 #ifdef HAVE_SDL /* we only use this code if SDL is available */
46 #include <SDL/SDL.h>
47
48 /* Fonts characterization. XXX should be read from the file */
49 #define FONT_H 20                       /* char height, pixels */
50 #define FONT_W 9                        /* char width, pixels */
51
52 struct board {
53         int             kb_output;      /* identity of the board */
54         /* pointer to the destination surface (on the keypad window) */
55         SDL_Surface     *screen;        /* the main screen */
56         SDL_Rect        *p_rect;        /* where to write on the main screen */
57         SDL_Surface     *blank;         /* original content of the window */
58
59         int     v_h;    /* virtual text height, in lines */
60         int     v_w;    /* virtual text width, in lines (probably same as p_w) */
61         int     p_h;    /* physical (displayed) text height, in lines
62                          * XXX p_h * FONT_H = pixel_height */
63         int     p_w;    /* physical (displayed) text width, in characters
64                          * XXX p_w * FONT_W = pixel_width */
65
66         int     cur_col; /* print position (free character) on the last line */
67         int     cur_line;       /* first (or last ?) virtual line displayed,
68                                          * 0 is the line at the bottom, 1 is the one above,...
69                                          */
70
71         SDL_Surface     *font;          /* points to a surface in the gui structure */
72         SDL_Rect        *font_rects;    /* pointer to the font rects */
73         char            *text;
74                                 /* text buffer, v_h * v_w char.
75                                  * We make sure the buffer is always full,
76                                  * print on some position on the last line,
77                                  * and scroll up when appending new text
78                                  */
79 };
80
81 /*! \brief Initialize the board.
82  * return 0 on success, 1 on error
83  * TODO, if this is done at reload time,
84  * free resources before allocate new ones
85  * TODO: resource deallocation in case of error.
86  * TODO: move the font load at gui_initialization
87  * TODO: deallocation of the message history
88  */
89 struct board *board_setup(SDL_Surface *screen, SDL_Rect *dest,
90         SDL_Surface *font, SDL_Rect *font_rects);
91 struct board *board_setup(SDL_Surface *screen, SDL_Rect *dest,
92         SDL_Surface *font, SDL_Rect *font_rects)
93 {
94         struct board *b = ast_calloc(1, sizeof (*b));
95         SDL_Rect br;
96
97         if (b == NULL)
98                 return NULL;
99         /* font, points to the gui structure */
100         b->font = font;
101         b->font_rects = font_rects;
102
103         /* Destination rectangle on the screen - reference is the whole screen */
104         b->p_rect = dest;
105         b->screen = screen;
106
107         /* compute physical sizes */
108         b->p_h = b->p_rect->h/FONT_H;
109         b->p_w = b->p_rect->w/FONT_W;
110
111         /* virtual sizes */
112         b->v_h = b->p_h * 10; /* XXX 10 times larger */
113         b->v_w = b->p_w;        /* same width */
114
115         /* the rectangle we actually use */
116         br.h = b->p_h * FONT_H; /* pixel sizes of the background */
117         br.w = b->p_w * FONT_W;
118         br.x = br.y = 0;
119
120         /* allocate a buffer for the text */
121         b->text = ast_calloc(b->v_w*b->v_h + 1, 1);
122         if (b->text == NULL) {
123                 ast_log(LOG_WARNING, "Unable to allocate board history memory.\n");
124                 ast_free(b);
125                 return NULL;
126         }
127         memset(b->text, ' ', b->v_w * b->v_h);  /* fill with spaces */
128
129         /* make a copy of the original rectangle, for cleaning up */
130         b->blank = SDL_CreateRGBSurface(screen->flags, br.w, br.h,
131                 screen->format->BitsPerPixel,
132                 screen->format->Rmask, screen->format->Gmask,
133                 screen->format->Bmask, screen->format->Amask);
134
135         if (b->blank == NULL) { 
136                 ast_log(LOG_WARNING, "Unable to allocate board virtual screen: %s\n",
137                                 SDL_GetError());
138                 ast_free(b->text);
139                 ast_free(b);
140                 return NULL;
141         }
142         SDL_BlitSurface(screen, b->p_rect, b->blank, &br);
143
144         /* Set color key, if not alpha channel present */
145         //colorkey = SDL_MapRGB(b->board_surface->format, 0, 0, 0);
146         //SDL_SetColorKey(b->board_surface, SDL_SRCCOLORKEY, colorkey);
147
148         b->cur_col = 0;         /* current print column */
149         b->cur_line = 0;        /* last line displayed */
150
151         if (0) ast_log(LOG_WARNING, "Message board %dx%d@%d,%d successfully initialized\n",
152                 b->p_rect->w, b->p_rect->h,
153                 b->p_rect->x, b->p_rect->y);
154         return b;
155 }
156
157 /* Render the text on the board surface.
158  * The first line to render is the one at v_h - p_h - cur_line,
159  * the size is p_h * p_w.
160  * XXX we assume here that p_w = v_w.
161  */
162 static void render_board(struct board *b)
163 {
164         int first_row = b->v_h - b->p_h - b->cur_line;
165         int first_char = b->v_w * first_row;
166         int last_char = first_char + b->p_h * b->v_w;
167         int i, col;
168         SDL_Rect dst;
169
170         /* top left char on the physical surface */
171         dst.w = FONT_W;
172         dst.h = FONT_H;
173         dst.x = b->p_rect->x;
174         dst.y = b->p_rect->y;
175
176
177         /* clean the surface board */
178         SDL_BlitSurface(b->blank, NULL, b->screen, b->p_rect);
179
180         /* blit all characters */
181         for (i = first_char, col = 0; i <  last_char; i++) {
182                 int c = b->text[i] - 32;        /* XXX first 32 chars are not printable */
183                 if (c < 0) /* buffer terminator or anything else is a blank */
184                         c = 0;
185                 SDL_BlitSurface(b->font, &b->font_rects[c], b->screen, &dst);
186                 /* point dst to next char position */
187                 dst.x += dst.w;
188                 col++;
189                 if (col >= b->v_w) { /* next row */
190                         dst.x = b->p_rect->x;
191                         dst.y += dst.h;
192                         col = 0;
193                 }
194         }
195         SDL_UpdateRects(b->screen, 1, b->p_rect);       /* Update the screen */
196 }
197
198 void move_message_board(struct board *b, int dy)
199 {
200         int cur = b->cur_line + dy;
201         if (cur < 0)
202                 cur = 0;
203         else if (cur >= b->v_h - b->p_h)
204                 cur = b->v_h - b->p_h - 1;
205         b->cur_line = cur;
206         render_board(b);
207 }
208
209 /* return the content of a board */
210 const char *read_message(const struct board *b)
211 {
212         return b->text;
213 }
214
215 int reset_board(struct board *b)
216 {
217         memset(b->text, ' ', b->v_w * b->v_h);  /* fill with spaces */
218         b->cur_col = 0;
219         b->cur_line = 0;
220         render_board(b);
221         return 0;
222 }
223 /* Store the message on the history board
224  * and blit on screen if required.
225  * XXX now easy. only regular chars
226  */
227 int print_message(struct board *b, const char *s)
228 {
229         int i, l, row, col;
230         char *dst;
231
232         if (ast_strlen_zero(s))
233                 return 0;
234
235         l = strlen(s);
236         row = 0;
237         col = b->cur_col;
238         /* First, only check how much space we need.
239          * Starting from the current print position, we move
240          * it forward and down (if necessary) according to input
241          * characters (including newlines, tabs, backspaces...).
242          * At the end, row tells us how many rows to scroll, and
243          * col (ignored) is the final print position.
244          */
245         for (i = 0; i < l; i++) {
246                 switch (s[i]) {
247                 case '\r':
248                         col = 0;
249                         break;
250                 case '\n':
251                         col = 0;
252                         row++;
253                         break;
254                 case '\b':
255                         if (col > 0)
256                                 col--;
257                         break;
258                 default:
259                         if (s[i] < 32) /* signed, so take up to 127 */
260                                 break;
261                         col++;
262                         if (col >= b->v_w) {
263                                 col -= b->v_w;
264                                 row++;
265                         }
266                         break;
267                 }
268         }
269         /* scroll the text window */
270         if (row > 0) { /* need to scroll by 'row' rows */
271                 memcpy(b->text, b->text + row * b->v_w, b->v_w * (b->v_h - row));
272                 /* clean the destination area */
273                 dst = b->text + b->v_w * (b->v_h - row - 1) + b->cur_col;
274                 memset(dst, ' ', b->v_w - b->cur_col + b->v_w * row);
275         }
276         /* now do the actual printing. The print position is 'row' lines up
277          * from the bottom of the buffer, start at the same 'cur_col' as before.
278          * dst points to the beginning of the current line.
279          */
280         dst = b->text + b->v_w * (b->v_h - row - 1); /* start of current line */
281         col = b->cur_col;
282         for (i = 0; i < l; i++) {
283                 switch (s[i]) {
284                 case '\r':
285                         col = 0;
286                         break;
287                 case '\n':      /* move to beginning of next line */
288                         dst[col] = '\0'; /* mark the rest of the line as empty */
289                         col = 0;
290                         dst += b->v_w;
291                         break;
292                 case '\b':      /* one char back */
293                         if (col > 0)
294                                 col--;
295                         dst[col] = ' '; /* delete current char */
296                         break;
297                 default:
298                         if (s[i] < 32) /* signed, so take up to 127 */
299                                 break;  /* non printable */
300                         dst[col] = s[i];        /* store character */
301                         col++;
302                         if (col >= b->v_w) {
303                                 col -= b->v_w;
304                                 dst += b->v_w;
305                         }
306                         break;
307                 }
308         }
309         dst[col] = '\0'; /* the current position is empty */
310         b->cur_col = col;
311         /* everything is printed now, must do the rendering */
312         render_board(b);
313         return 1;
314 }
315
316 #if 0
317 /*! \brief refresh the screen, and also grab a bunch of events.
318  */
319 static int scroll_message(...)
320 {
321 if moving up, scroll text up;
322     if (gui->message_board.screen_cur > 0)
323         gui->message_board.screen_cur--;
324 otherwise scroll text down.
325     if ((b->screen_cur + b->p_line) < b->board_next) {
326         gui->message_board.screen_cur++;
327 #endif /* notyet */
328
329 #endif /* HAVE_SDL */