libmenu/menu.c

   1 /*
   2  * This file is part of MPlayer.
   3  *
   4  * MPlayer is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * MPlayer is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with MPlayer; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  17  */
  18
  19 #include "config.h"
  20 #include "mp_msg.h"
  21
  22 #include <stdlib.h>
  23 #include <stdio.h>
  24 #include <string.h>
  25 #include <fcntl.h>
  26 #include <unistd.h>
  27
  28 #include "libvo/osd.h"
  29 #include "libvo/font_load.h"
  30 #include "libvo/sub.h"
  31 #include "osdep/keycodes.h"
  32 #include "asxparser.h"
  33 #include "stream/stream.h"
  34 #include "input/input.h"
  35
  36 #include "libmpcodecs/img_format.h"
  37 #include "libmpcodecs/mp_image.h"
  38 #include "m_option.h"
  39 #include "m_struct.h"
  40 #include "menu.h"
  41
  42 extern menu_info_t menu_info_cmdlist;
  43 extern menu_info_t menu_info_chapsel;
  44 extern menu_info_t menu_info_pt;
  45 extern menu_info_t menu_info_filesel;
  46 extern menu_info_t menu_info_txt;
  47 extern menu_info_t menu_info_console;
  48 extern menu_info_t menu_info_pref;
  49 extern menu_info_t menu_info_dvbsel;
  50
  51
  52 menu_info_t* menu_info_list[] = {
  53   &menu_info_pt,
  54   &menu_info_cmdlist,
  55   &menu_info_chapsel,
  56   &menu_info_filesel,
  57   &menu_info_txt,
  58   &menu_info_console,
  59 #ifdef CONFIG_DVBIN
  60   &menu_info_dvbsel,
  61 #endif
  62   &menu_info_pref,
  63   NULL
  64 };
  65
  66 typedef struct key_cmd_s {
  67   int key;
  68   char *cmd;
  69 } key_cmd_t;
  70
  71 typedef struct menu_cmd_bindings_s {
  72   char *name;
  73   key_cmd_t *bindings;
  74   int binding_num;
  75   struct menu_cmd_bindings_s *parent;
  76 } menu_cmd_bindings_t;
  77
  78 struct menu_def_st {
  79   char* name;
  80   menu_info_t* type;
  81   void* cfg;
  82   char* args;
  83 };
  84
  85 double menu_mouse_x = -1.0;
  86 double menu_mouse_y = -1.0;
  87 int menu_mouse_pos_updated = 0;
  88
  89 static struct MPContext *menu_ctx = NULL;
  90 static struct m_config *menu_mconfig = NULL;
  91 static struct input_ctx *menu_input = NULL;
  92 static menu_def_t* menu_list = NULL;
  93 static int menu_count = 0;
  94 static menu_cmd_bindings_t *cmd_bindings = NULL;
  95 static int cmd_bindings_num = 0;
  96
  97
  98 static menu_cmd_bindings_t *get_cmd_bindings(const char *name)
  99 {
 100   int i;
 101   for (i = 0; i < cmd_bindings_num; ++i)
 102     if (!strcasecmp(cmd_bindings[i].name, name))
 103       return &cmd_bindings[i];
 104   return NULL;
 105 }
 106
 107 static int menu_parse_config(char* buffer, struct m_config *mconfig)
 108 {
 109   char *element,*body, **attribs, *name;
 110   menu_info_t* minfo = NULL;
 111   int r,i;
 112   ASX_Parser_t* parser = asx_parser_new(mconfig);
 113
 114   while(1) {
 115     r = asx_get_element(parser,&buffer,&element,&body,&attribs);
 116     if(r < 0) {
 117       mp_tmsg(MSGT_GLOBAL,MSGL_WARN,"[MENU] syntax error at line: %d\n",parser->line);
 118       asx_parser_free(parser);
 119       return 0;
 120     } else if(r == 0) {
 121       asx_parser_free(parser);
 122       return 1;
 123     }
 124     // Has it a name ?
 125     name = asx_get_attrib("name",attribs);
 126     if(!name) {
 127       mp_tmsg(MSGT_GLOBAL,MSGL_WARN,"[MENU] Menu definitions need a name attribute (line %d).\n",parser->line);
 128       free(element);
 129       if(body) free(body);
 130       asx_free_attribs(attribs);
 131       continue;
 132     }
 133
 134     if (!strcasecmp(element, "keybindings")) {
 135       menu_cmd_bindings_t *bindings = cmd_bindings;
 136       char *parent_bindings;
 137       cmd_bindings = realloc(cmd_bindings,
 138                              (cmd_bindings_num+1)*sizeof(menu_cmd_bindings_t));
 139       for (i = 0; i < cmd_bindings_num; ++i)
 140         if (cmd_bindings[i].parent)
 141           cmd_bindings[i].parent = cmd_bindings[i].parent-bindings+cmd_bindings;
 142       bindings = &cmd_bindings[cmd_bindings_num];
 143       memset(bindings, 0, sizeof(menu_cmd_bindings_t));
 144       bindings->name = name;
 145       parent_bindings = asx_get_attrib("parent",attribs);
 146       if (parent_bindings) {
 147         bindings->parent = get_cmd_bindings(parent_bindings);
 148         free(parent_bindings);
 149       }
 150       free(element);
 151       asx_free_attribs(attribs);
 152       if (body) {
 153         char *bd = body;
 154         char *b, *key, *cmd;
 155         int keycode;
 156         for(;;) {
 157           r = asx_get_element(parser,&bd,&element,&b,&attribs);
 158           if(r < 0) {
 159             mp_tmsg(MSGT_GLOBAL,MSGL_WARN,"[MENU] syntax error at line: %d\n",
 160                    parser->line);
 161             free(body);
 162             asx_parser_free(parser);
 163             return 0;
 164           }
 165           if(r == 0)
 166             break;
 167           if (!strcasecmp(element, "binding")) {
 168             key = asx_get_attrib("key",attribs);
 169             cmd = asx_get_attrib("cmd",attribs);
 170             if (key && (keycode = mp_input_get_key_from_name(key)) >= 0) {
 171               keycode &= ~MP_NO_REPEAT_KEY;
 172               mp_msg(MSGT_GLOBAL,MSGL_V,
 173                      "[libmenu] got keybinding element %d %s=>[%s].\n",
 174                      keycode, key, cmd ? cmd : "");
 175               bindings->bindings = realloc(bindings->bindings,
 176                                    (bindings->binding_num+1)*sizeof(key_cmd_t));
 177               bindings->bindings[bindings->binding_num].key = keycode;
 178               bindings->bindings[bindings->binding_num].cmd = cmd;
 179               ++bindings->binding_num;
 180             }
 181             else
 182               free(cmd);
 183             free(key);
 184           }
 185           free(element);
 186           asx_free_attribs(attribs);
 187           free(b);
 188         }
 189         free(body);
 190       }
 191       ++cmd_bindings_num;
 192       continue;
 193     }
 194     // Try to find this menu type in our list
 195     for(i = 0, minfo = NULL ; menu_info_list[i] ; i++) {
 196       if(strcasecmp(element,menu_info_list[i]->name) == 0) {
 197         minfo = menu_info_list[i];
 198         break;
 199       }
 200     }
 201     // Got it : add this to our list
 202     if(minfo) {
 203       menu_list = realloc(menu_list,(menu_count+2)*sizeof(menu_def_t));
 204       menu_list[menu_count].name = name;
 205       menu_list[menu_count].type = minfo;
 206       menu_list[menu_count].cfg = m_struct_alloc(&minfo->priv_st);
 207       menu_list[menu_count].args = body;
 208       // Setup the attribs
 209       for(i = 0 ; attribs[2*i] ; i++) {
 210         if(strcasecmp(attribs[2*i],"name") == 0) continue;
 211         if(!m_struct_set(&minfo->priv_st,menu_list[menu_count].cfg,attribs[2*i], attribs[2*i+1]))
 212           mp_tmsg(MSGT_GLOBAL,MSGL_WARN,"[MENU] bad attribute %s=%s in menu '%s' at line %d\n",attribs[2*i],attribs[2*i+1],
 213                  name,parser->line);
 214       }
 215       menu_count++;
 216       memset(&menu_list[menu_count],0,sizeof(menu_def_t));
 217     } else {
 218       mp_tmsg(MSGT_GLOBAL,MSGL_WARN,"[MENU] unknown menu type '%s' at line %d\n",element,parser->line);
 219       free(name);
 220       if(body) free(body);
 221     }
 222
 223     free(element);
 224     asx_free_attribs(attribs);
 225   }
 226
 227 }
 228
 229
 230 /// This will build the menu_defs list from the cfg file
 231 #define BUF_STEP 1024
 232 #define BUF_MIN 128
 233 #define BUF_MAX BUF_STEP*1024
 234 int menu_init(struct MPContext *mpctx, struct m_config *mconfig,
 235               struct input_ctx *input_ctx, char* cfg_file)
 236 {
 237   char* buffer = NULL;
 238   int bl = BUF_STEP, br = 0;
 239   int f, fd;
 240 #ifndef CONFIG_FREETYPE
 241   if(vo_font == NULL)
 242     return 0;
 243 #endif
 244   fd = open(cfg_file, O_RDONLY);
 245   if(fd < 0) {
 246     mp_tmsg(MSGT_GLOBAL,MSGL_WARN,"[MENU] Can't open menu config file: %s\n",cfg_file);
 247     return 0;
 248   }
 249   buffer = malloc(bl);
 250   while(1) {
 251     int r;
 252     if(bl - br < BUF_MIN) {
 253       if(bl >= BUF_MAX) {
 254         mp_tmsg(MSGT_GLOBAL,MSGL_WARN,"[MENU] Config file is too big (> %d KB)\n",BUF_MAX/1024);
 255         close(fd);
 256         free(buffer);
 257         return 0;
 258       }
 259       bl += BUF_STEP;
 260       buffer = realloc(buffer,bl);
 261     }
 262     r = read(fd,buffer+br,bl-br);
 263     if(r == 0) break;
 264     br += r;
 265   }
 266   if(!br) {
 267     mp_tmsg(MSGT_GLOBAL,MSGL_WARN,"[MENU] Config file is empty.\n");
 268     return 0;
 269   }
 270   buffer[br-1] = '\0';
 271
 272   close(fd);
 273
 274   menu_ctx = mpctx;
 275   menu_mconfig = mconfig;
 276   menu_input = input_ctx;
 277   f = menu_parse_config(buffer, mconfig);
 278   free(buffer);
 279   return f;
 280 }
 281
 282 // Destroy all this stuff
 283 void menu_uninit(void) {
 284   int i;
 285   for(i = 0 ; menu_list && menu_list[i].name ; i++) {
 286     free(menu_list[i].name);
 287     m_struct_free(&menu_list[i].type->priv_st,menu_list[i].cfg);
 288     if(menu_list[i].args) free(menu_list[i].args);
 289   }
 290   free(menu_list);
 291   menu_count = 0;
 292   for (i = 0; i < cmd_bindings_num; ++i) {
 293     free(cmd_bindings[i].name);
 294     while(cmd_bindings[i].binding_num > 0)
 295       free(cmd_bindings[i].bindings[--cmd_bindings[i].binding_num].cmd);
 296     free(cmd_bindings[i].bindings);
 297   }
 298   free(cmd_bindings);
 299 }
 300
 301 /// Default read_key function
 302 int menu_dflt_read_key(menu_t* menu,int cmd) {
 303   int i;
 304   menu_cmd_bindings_t *bindings = get_cmd_bindings(menu->type->name);
 305   if (!bindings)
 306     bindings = get_cmd_bindings(menu->type->type->name);
 307   if (!bindings)
 308     bindings = get_cmd_bindings("default");
 309   while (bindings) {
 310     for (i = 0; i < bindings->binding_num; ++i) {
 311       if (bindings->bindings[i].key == cmd) {
 312         if (bindings->bindings[i].cmd)
 313           mp_input_parse_and_queue_cmds(menu->input_ctx,
 314                                         bindings->bindings[i].cmd);
 315         return 1;
 316       }
 317     }
 318     bindings = bindings->parent;
 319   }
 320   return 0;
 321 }
 322
 323 menu_t* menu_open(char *name) {
 324   menu_t* m;
 325   int i;
 326
 327   for(i = 0 ; menu_list[i].name != NULL ; i++) {
 328     if(strcmp(name,menu_list[i].name) == 0)
 329       break;
 330   }
 331   if(menu_list[i].name == NULL) {
 332     mp_tmsg(MSGT_GLOBAL,MSGL_WARN,"[MENU] Menu %s not found.\n",name);
 333     return NULL;
 334   }
 335   m = calloc(1,sizeof(menu_t));
 336   m->priv_st = &(menu_list[i].type->priv_st);
 337   m->priv = m_struct_copy(m->priv_st,menu_list[i].cfg);
 338   m->ctx = menu_ctx;
 339   m->mconfig = menu_mconfig;
 340   m->input_ctx = menu_input;
 341   m->type = &menu_list[i];
 342   if(menu_list[i].type->open(m,menu_list[i].args))
 343     return m;
 344   if(m->priv)
 345     m_struct_free(m->priv_st,m->priv);
 346   free(m);
 347   mp_tmsg(MSGT_GLOBAL,MSGL_WARN,"[MENU] Menu '%s': Init failed.\n",name);
 348   return NULL;
 349 }
 350
 351 void menu_draw(menu_t* menu,mp_image_t* mpi) {
 352   if(menu->show && menu->draw)
 353     menu->draw(menu,mpi);
 354 }
 355
 356 void menu_update_mouse_pos(double x, double y) {
 357   menu_mouse_x = x;
 358   menu_mouse_y = y;
 359   menu_mouse_pos_updated = 1;
 360 }
 361
 362 void menu_read_cmd(menu_t* menu,int cmd) {
 363   if(menu->read_cmd)
 364     menu->read_cmd(menu,cmd);
 365 }
 366
 367 void menu_close(menu_t* menu) {
 368   if(menu->close)
 369     menu->close(menu);
 370   if(menu->priv)
 371     m_struct_free(menu->priv_st,menu->priv);
 372   free(menu);
 373 }
 374
 375 int menu_read_key(menu_t* menu,int cmd) {
 376   if(menu->read_key)
 377     return menu->read_key(menu,cmd);
 378   else
 379     return menu_dflt_read_key(menu,cmd);
 380 }
 381
 382 ///////////////////////////// Helpers ////////////////////////////////////
 383
 384 typedef void (*draw_alpha_f)(int w,int h, unsigned char* src, unsigned char *srca, int srcstride, unsigned char* dstbase,int dststride);
 385
 386 inline static draw_alpha_f get_draw_alpha(uint32_t fmt) {
 387   switch(fmt) {
 388   case IMGFMT_BGR12:
 389   case IMGFMT_RGB12:
 390     return vo_draw_alpha_rgb12;
 391   case IMGFMT_BGR15:
 392   case IMGFMT_RGB15:
 393     return vo_draw_alpha_rgb15;
 394   case IMGFMT_BGR16:
 395   case IMGFMT_RGB16:
 396     return vo_draw_alpha_rgb16;
 397   case IMGFMT_BGR24:
 398   case IMGFMT_RGB24:
 399     return vo_draw_alpha_rgb24;
 400   case IMGFMT_BGR32:
 401   case IMGFMT_RGB32:
 402     return vo_draw_alpha_rgb32;
 403   case IMGFMT_YV12:
 404   case IMGFMT_I420:
 405   case IMGFMT_IYUV:
 406   case IMGFMT_YVU9:
 407   case IMGFMT_IF09:
 408   case IMGFMT_Y800:
 409   case IMGFMT_Y8:
 410     return vo_draw_alpha_yv12;
 411   case IMGFMT_YUY2:
 412     return vo_draw_alpha_yuy2;
 413   case IMGFMT_UYVY:
 414     return vo_draw_alpha_uyvy;
 415   }
 416
 417   return NULL;
 418 }
 419
 420 // return the real height of a char:
 421 static inline int get_height(int c,int h){
 422     int font;
 423     if ((font=vo_font->font[c])>=0)
 424         if(h<vo_font->pic_a[font]->h) h=vo_font->pic_a[font]->h;
 425     return h;
 426 }
 427
 428 static void render_txt(char *txt)
 429 {
 430   while (*txt) {
 431     int c = utf8_get_char((const char**)&txt);
 432     render_one_glyph(vo_font, c);
 433   }
 434 }
 435
 436 #ifdef CONFIG_FRIBIDI
 437 #include <fribidi/fribidi.h>
 438 #include "libavutil/common.h"
 439 char *menu_fribidi_charset = NULL;
 440 int menu_flip_hebrew = 0;
 441 int menu_fribidi_flip_commas = 0;
 442
 443 static char *menu_fribidi(char *txt)
 444 {
 445   static int char_set_num = -1;
 446   static FriBidiChar *logical, *visual;
 447   static size_t buffer_size = 1024;
 448   static char *outputstr;
 449
 450   FriBidiCharType base;
 451   fribidi_boolean log2vis;
 452   size_t len;
 453
 454   if (menu_flip_hebrew) {
 455     len = strlen(txt);
 456     if (char_set_num == -1) {
 457       fribidi_set_mirroring (1);
 458       fribidi_set_reorder_nsm (0);
 459       char_set_num = fribidi_parse_charset("UTF-8");
 460       buffer_size = FFMAX(1024,len+1);
 461       logical = malloc(buffer_size);
 462       visual = malloc(buffer_size);
 463       outputstr = malloc(buffer_size);
 464     } else if (len+1 > buffer_size) {
 465       buffer_size = len+1;
 466       logical = realloc(logical, buffer_size);
 467       visual = realloc(visual, buffer_size);
 468       outputstr = realloc(outputstr, buffer_size);
 469     }
 470     len = fribidi_charset_to_unicode (char_set_num, txt, len, logical);
 471     base = menu_fribidi_flip_commas?FRIBIDI_TYPE_ON:FRIBIDI_TYPE_L;
 472     log2vis = fribidi_log2vis (logical, len, &base, visual, NULL, NULL, NULL);
 473     if (log2vis) {
 474       len = fribidi_remove_bidi_marks (visual, len, NULL, NULL, NULL);
 475       fribidi_unicode_to_charset (char_set_num, visual, len, outputstr);
 476       return outputstr;
 477     }
 478   }
 479   return txt;
 480 }
 481 #endif
 482
 483 void menu_draw_text(mp_image_t* mpi,char* txt, int x, int y) {
 484   draw_alpha_f draw_alpha = get_draw_alpha(mpi->imgfmt);
 485   int font;
 486
 487   if(!draw_alpha) {
 488     mp_tmsg(MSGT_GLOBAL,MSGL_WARN,"[MENU] Unsupported output format!!!!\n");
 489     return;
 490   }
 491
 492 #ifdef CONFIG_FRIBIDI
 493   txt = menu_fribidi(txt);
 494 #endif
 495   render_txt(txt);
 496
 497   while (*txt) {
 498     int c=utf8_get_char((const char**)&txt);
 499     if ((font=vo_font->font[c])>=0 && (x + vo_font->width[c] <= mpi->w) && (y + vo_font->pic_a[font]->h <= mpi->h))
 500       draw_alpha(vo_font->width[c], vo_font->pic_a[font]->h,
 501                  vo_font->pic_b[font]->bmp+vo_font->start[c],
 502                  vo_font->pic_a[font]->bmp+vo_font->start[c],
 503                  vo_font->pic_a[font]->w,
 504                  mpi->planes[0] + y * mpi->stride[0] + x * (mpi->bpp>>3),
 505                  mpi->stride[0]);
 506     x+=vo_font->width[c]+vo_font->charspace;
 507   }
 508
 509 }
 510
 511 void menu_draw_text_full(mp_image_t* mpi,char* txt,
 512                          int x, int y,int w, int h,
 513                          int vspace, int warp, int align, int anchor) {
 514   int need_w,need_h;
 515   int sy, ymin, ymax;
 516   int sx, xmin, xmax, xmid, xrmin;
 517   int ll = 0;
 518   int font;
 519   draw_alpha_f draw_alpha = get_draw_alpha(mpi->imgfmt);
 520
 521   if(!draw_alpha) {
 522     mp_tmsg(MSGT_GLOBAL,MSGL_WARN,"[MENU] Unsupported output format!!!!\n");
 523     return;
 524   }
 525
 526 #ifdef CONFIG_FRIBIDI
 527   txt = menu_fribidi(txt);
 528 #endif
 529   render_txt(txt);
 530
 531   if(x > mpi->w || y > mpi->h)
 532     return;
 533
 534   if(anchor & MENU_TEXT_VCENTER) {
 535     if(h <= 0) h = mpi->h;
 536     ymin = y - h/2;
 537     ymax = y + h/2;
 538   }  else if(anchor & MENU_TEXT_BOT) {
 539     if(h <= 0) h = mpi->h - y;
 540     ymin = y - h;
 541     ymax = y;
 542   } else {
 543     if(h <= 0) h = mpi->h - y;
 544     ymin = y;
 545     ymax = y + h;
 546   }
 547
 548   if(anchor & MENU_TEXT_HCENTER) {
 549     if(w <= 0) w = mpi->w;
 550     xmin = x - w/2;
 551     xmax = x + w/2;
 552   }  else if(anchor & MENU_TEXT_RIGHT) {
 553     if(w <= 0) w = mpi->w -x;
 554     xmin = x - w;
 555     xmax = x;
 556   } else {
 557     if(w <= 0) w = mpi->w -x;
 558     xmin = x;
 559     xmax = x + w;
 560   }
 561
 562   // How many space do we need to draw this ?
 563   menu_text_size(txt,w,vspace,warp,&need_w,&need_h);
 564
 565   // Find the first line
 566   if(align & MENU_TEXT_VCENTER)
 567     sy = ymin + ((h - need_h)/2);
 568   else if(align & MENU_TEXT_BOT)
 569     sy = ymax - need_h - 1;
 570   else
 571     sy = y;
 572
 573 #if 0
 574   // Find the first col
 575   if(align & MENU_TEXT_HCENTER)
 576     sx = xmin + ((w - need_w)/2);
 577   else if(align & MENU_TEXT_RIGHT)
 578     sx = xmax - need_w;
 579 #endif
 580
 581   xmid = xmin + (xmax - xmin) / 2;
 582   xrmin = xmin;
 583   // Clamp the bb to the mpi size
 584   if(ymin < 0) ymin = 0;
 585   if(xmin < 0) xmin = 0;
 586   if(ymax > mpi->h) ymax = mpi->h;
 587   if(xmax > mpi->w) xmax = mpi->w;
 588
 589   // Jump some the beginnig text if needed
 590   while(sy < ymin && *txt) {
 591     int c=utf8_get_char((const char**)&txt);
 592     if(c == '\n' || (warp && ll + vo_font->width[c] > w)) {
 593       ll = 0;
 594       sy += vo_font->height + vspace;
 595       if(c == '\n') continue;
 596     }
 597     ll += vo_font->width[c]+vo_font->charspace;
 598   }
 599   if(*txt == '\0') // Nothing left to draw
 600       return;
 601
 602   while(sy < ymax && *txt) {
 603     char* line_end = NULL;
 604     int n;
 605
 606     if(txt[0] == '\n') { // New line
 607       sy += vo_font->height + vspace;
 608       txt++;
 609       continue;
 610     }
 611
 612     // Get the length and end of this line
 613     for(n = 0, ll = 0 ; txt[n] != '\0' && txt[n] != '\n'  ; n++) {
 614       unsigned char c = txt[n];
 615       if(warp && ll + vo_font->width[c]  > w)  break;
 616       ll += vo_font->width[c]+vo_font->charspace;
 617     }
 618     line_end = &txt[n];
 619     ll -= vo_font->charspace;
 620
 621
 622     if(align & (MENU_TEXT_HCENTER|MENU_TEXT_RIGHT)) {
 623       // Too long line
 624       if(ll > xmax-xmin) {
 625         if(align & MENU_TEXT_HCENTER) {
 626           int mid = ll/2;
 627           // Find the middle point
 628           for(n--, ll = 0 ; n <= 0 ; n--) {
 629             ll += vo_font->width[(int)txt[n]]+vo_font->charspace;
 630             if(ll - vo_font->charspace > mid) break;
 631           }
 632           ll -= vo_font->charspace;
 633           sx = xmid + mid - ll;
 634         } else// MENU_TEXT_RIGHT)
 635           sx = xmax + vo_font->charspace;
 636
 637         // We are after the start point -> go back
 638         if(sx > xmin) {
 639           for(n-- ; n <= 0 ; n--) {
 640             unsigned char c = txt[n];
 641             if(sx - vo_font->width[c] - vo_font->charspace < xmin) break;
 642             sx -= vo_font->width[c]+vo_font->charspace;
 643           }
 644         } else { // We are before the start point -> go forward
 645           for( ; sx < xmin && (&txt[n]) != line_end ; n++) {
 646             unsigned char c = txt[n];
 647             sx += vo_font->width[c]+vo_font->charspace;
 648           }
 649         }
 650         txt = &txt[n]; // Jump to the new start char
 651       } else {
 652         if(align & MENU_TEXT_HCENTER)
 653           sx = xmid - ll/2;
 654         else
 655           sx = xmax - 1 - ll;
 656       }
 657     } else {
 658       for(sx = xrmin ;  sx < xmin && txt != line_end ; txt++) {
 659         unsigned char c = txt[n];
 660         sx += vo_font->width[c]+vo_font->charspace;
 661       }
 662     }
 663
 664     while(sx < xmax && txt != line_end) {
 665       int c=utf8_get_char((const char**)&txt);
 666       font = vo_font->font[c];
 667       if(font >= 0) {
 668         int cs = (vo_font->pic_a[font]->h - vo_font->height) / 2;
 669         if ((sx + vo_font->width[c] <= xmax) && (sy + vo_font->height <= ymax) )
 670           draw_alpha(vo_font->width[c], vo_font->height,
 671                      vo_font->pic_b[font]->bmp+vo_font->start[c] +
 672                      cs * vo_font->pic_a[font]->w,
 673                      vo_font->pic_a[font]->bmp+vo_font->start[c] +
 674                      cs * vo_font->pic_a[font]->w,
 675                      vo_font->pic_a[font]->w,
 676                      mpi->planes[0] + sy * mpi->stride[0] + sx * (mpi->bpp>>3),
 677                      mpi->stride[0]);
 678         //      else
 679         //printf("Can't draw '%c'\n",c);
 680       }
 681       sx+=vo_font->width[c]+vo_font->charspace;
 682     }
 683     txt = line_end;
 684     if(txt[0] == '\0') break;
 685     sy += vo_font->height + vspace;
 686   }
 687 }
 688
 689 int menu_text_length(char* txt) {
 690   int l = 0;
 691   render_txt(txt);
 692   while (*txt) {
 693     int c=utf8_get_char((const char**)&txt);
 694     l += vo_font->width[c]+vo_font->charspace;
 695   }
 696   return l - vo_font->charspace;
 697 }
 698
 699 void menu_text_size(char* txt,int max_width, int vspace, int warp, int* _w, int* _h) {
 700   int l = 1, i = 0;
 701   int w = 0;
 702
 703   render_txt(txt);
 704   while (*txt) {
 705     int c=utf8_get_char((const char**)&txt);
 706     if(c == '\n' || (warp && i + vo_font->width[c] >= max_width)) {
 707       i -= vo_font->charspace;
 708       if (i > w) w = i;
 709       if(*txt)
 710         l++;
 711       i = 0;
 712       if(c == '\n') continue;
 713     }
 714     i += vo_font->width[c]+vo_font->charspace;
 715   }
 716   if (i > 0) {
 717     i -= vo_font->charspace;
 718     if (i > w) w = i;
 719   }
 720
 721   *_w = w;
 722   *_h = (l-1) * (vo_font->height + vspace) + vo_font->height;
 723 }
 724
 725
 726 int menu_text_num_lines(char* txt, int max_width) {
 727   int l = 1, i = 0;
 728   render_txt(txt);
 729   while (*txt) {
 730     int c=utf8_get_char((const char**)&txt);
 731     if(c == '\n' || i + vo_font->width[c] > max_width) {
 732       l++;
 733       i = 0;
 734       if(c == '\n') continue;
 735     }
 736     i += vo_font->width[c]+vo_font->charspace;
 737   }
 738   return l;
 739 }
 740
 741
 742 void menu_draw_box(mp_image_t* mpi,unsigned char grey,unsigned char alpha, int x, int y, int w, int h) {
 743   draw_alpha_f draw_alpha = get_draw_alpha(mpi->imgfmt);
 744   int g;
 745
 746   if(!draw_alpha) {
 747     mp_tmsg(MSGT_GLOBAL,MSGL_WARN,"[MENU] Unsupported output format!!!!\n");
 748     return;
 749   }
 750
 751   if(x > mpi->w || y > mpi->h) return;
 752
 753   if(x < 0) w += x, x = 0;
 754   if(x+w > mpi->w) w = mpi->w-x;
 755   if(y < 0) h += y, y = 0;
 756   if(y+h > mpi->h) h = mpi->h-y;
 757
 758   g = ((256-alpha)*grey)>>8;
 759   if(g < 1) g = 1;
 760
 761   {
 762     int stride = (w+7)&(~7); // round to 8
 763     char pic[stride*h],pic_alpha[stride*h];
 764     memset(pic,g,stride*h);
 765     memset(pic_alpha,alpha,stride*h);
 766     draw_alpha(w,h,pic,pic_alpha,stride,
 767                mpi->planes[0] + y * mpi->stride[0] + x * (mpi->bpp>>3),
 768                mpi->stride[0]);
 769   }
 770
 771 }