src/menu.cpp

   1 /*
   2   menu.c
   3
   4   Super Tux - Menu
   5
   6   by Tobias Glaesser
   7   tobi.web@gmx.de
   8   http://www.newbreedsoftware.com/supertux/
   9
  10   December 20, 2003 - March 15, 2004
  11 */
  12
  13 #ifndef WIN32
  14 #include <sys/types.h>
  15 #include <ctype.h>
  16 #endif
  17
  18 #include <stdlib.h>
  19 #include <stdio.h>
  20 #include <string.h>
  21
  22 #include "defines.h"
  23 #include "globals.h"
  24 #include "menu.h"
  25 #include "screen.h"
  26 #include "setup.h"
  27 #include "sound.h"
  28 #include "scene.h"
  29 #include "leveleditor.h"
  30 #include "timer.h"
  31 #include "high_scores.h"
  32
  33 /* (global) menu variables */
  34 MenuAction menuaction;
  35 int show_menu;
  36 int menu_change;
  37 texture_type checkbox, checkbox_checked, back, arrow_left, arrow_right;
  38
  39 menu_type main_menu, game_menu, options_menu, highscore_menu, load_game_menu, save_game_menu;
  40 menu_type* current_menu, * last_menu;
  41
  42 /* input implementation variables */
  43 int delete_character;
  44 char mn_input_char;
  45
  46 /* Set the current menu */
  47 void menu_set_current(menu_type* pmenu)
  48 {
  49   if(pmenu != current_menu)
  50     {
  51       menu_change = YES;
  52       last_menu = current_menu;
  53       current_menu = pmenu;
  54       timer_start(&pmenu->effect, 500);
  55     }
  56 }
  57
  58 /* Return a pointer to a new menu item */
  59 menu_item_type* menu_item_create(MenuItemKind kind, char *text, int init_toggle, void* target_menu)
  60 {
  61   menu_item_type *pnew_item = (menu_item_type*) malloc(sizeof(menu_item_type));
  62   pnew_item->kind = kind;
  63   pnew_item->text = (char*) malloc(sizeof(char) * (strlen(text) + 1));
  64   strcpy(pnew_item->text,text);
  65   if(kind == MN_TOGGLE)
  66     pnew_item->toggled = init_toggle;
  67   else
  68     pnew_item->toggled = NO;
  69   pnew_item->target_menu = target_menu;
  70   pnew_item->input = (char*) malloc(sizeof(char));
  71   pnew_item->input[0] = '\0';
  72   if(kind == MN_STRINGSELECT)
  73     {
  74       pnew_item->list = (string_list_type*) malloc(sizeof(string_list_type));
  75       string_list_init(pnew_item->list);
  76     }
  77   else
  78     pnew_item->list = NULL;
  79   return pnew_item;
  80 }
  81
  82 void menu_item_change_text(menu_item_type* pmenu_item,const  char *text)
  83 {
  84   if(text)
  85     {
  86       free(pmenu_item->text);
  87       pmenu_item->text = (char*) malloc(sizeof(char )*(strlen(text)+1));
  88       strcpy(pmenu_item->text,text);
  89     }
  90 }
  91 void menu_item_change_input(menu_item_type* pmenu_item,const  char *text)
  92 {
  93   if(text)
  94     {
  95       free(pmenu_item->input);
  96       pmenu_item->input = (char*) malloc(sizeof(char )*(strlen(text)+1));
  97       strcpy(pmenu_item->input,text);
  98     }
  99 }
 100
 101 /* Free a menu and all its items */
 102 void menu_free(menu_type* pmenu)
 103 {
 104   int i;
 105   if(pmenu->num_items != 0 && pmenu->item != NULL)
 106     {
 107       for(i = 0; i < pmenu->num_items; ++i)
 108         {
 109           free(pmenu->item[i].text);
 110           free(pmenu->item[i].input);
 111           string_list_free(pmenu->item[i].list);
 112         }
 113       free(pmenu->item);
 114     }
 115 }
 116
 117 /* Initialize a menu */
 118 void menu_init(menu_type* pmenu)
 119 {
 120   pmenu->x            = screen->w/2;
 121   pmenu->y            = screen->h/2;
 122   pmenu->arrange_left = 0;
 123   pmenu->num_items    = 0;
 124   pmenu->active_item  = 0;
 125   pmenu->item         = NULL;
 126   timer_init(&pmenu->effect,NO);
 127 }
 128
 129 /* Add an item to a menu */
 130 void menu_additem(menu_type* pmenu, menu_item_type* pmenu_item)
 131 {
 132   ++pmenu->num_items;
 133   pmenu->item = (menu_item_type*)realloc(pmenu->item, sizeof(menu_item_type) * pmenu->num_items);
 134   memcpy(&pmenu->item[pmenu->num_items-1],pmenu_item,sizeof(menu_item_type));
 135   free(pmenu_item);
 136 }
 137
 138 /* Process actions done on the menu */
 139 void menu_action(menu_type* pmenu)
 140 {
 141   menu_item_type& item = pmenu->item[pmenu->active_item];
 142
 143   if(pmenu->num_items != 0 && pmenu->item != NULL)
 144     {
 145       switch(menuaction)
 146         {
 147         case MENU_ACTION_UP:
 148           if(pmenu->active_item > 0)
 149             --pmenu->active_item;
 150           else
 151             pmenu->active_item = pmenu->num_items-1;
 152           break;
 153
 154         case MENU_ACTION_DOWN:
 155           if(pmenu->active_item < pmenu->num_items-1)
 156             ++pmenu->active_item;
 157           else
 158             pmenu->active_item = 0;
 159           break;
 160
 161         case MENU_ACTION_LEFT:
 162           if(item.kind == MN_STRINGSELECT
 163              && item.list->num_items != 0)
 164             {
 165               if(item.list->active_item > 0)
 166                 --item.list->active_item;
 167               else
 168                 item.list->active_item = item.list->num_items-1;
 169             }
 170           break;
 171         case MENU_ACTION_RIGHT:
 172           if(item.kind == MN_STRINGSELECT
 173              && item.list->num_items != 0)
 174             {
 175               if(item.list->active_item < item.list->num_items-1)
 176                 ++item.list->active_item;
 177               else
 178                 item.list->active_item = 0;
 179             }
 180           break;
 181
 182         case MENU_ACTION_HIT:
 183           if(item.kind == MN_GOTO
 184              && item.target_menu != NULL)
 185             menu_set_current((menu_type*)item.target_menu);
 186
 187           else if(item.kind == MN_TOGGLE)
 188             {
 189               item.toggled = !item.toggled;
 190               menu_change = YES;
 191             }
 192           else if(item.kind == MN_ACTION || item.kind == MN_TEXTFIELD || item.kind == MN_NUMFIELD)
 193             {
 194               item.toggled = YES;
 195             }
 196           else if(item.kind == MN_BACK)
 197             {
 198               if(last_menu != NULL)
 199                 menu_set_current(last_menu);
 200             }
 201           break;
 202
 203         case MENU_ACTION_REMOVE:
 204           if(item.kind == MN_TEXTFIELD
 205              || item.kind == MN_NUMFIELD)
 206             {
 207               if(item.input != NULL)
 208                 {
 209                   int i = strlen(item.input);
 210
 211                   while(delete_character > 0)   /* remove charactes */
 212                     {
 213                       item.input[i-1] = '\0';
 214                       delete_character--;
 215                     }
 216                 }
 217             }
 218           break;
 219
 220         case MENU_ACTION_INPUT:
 221           if(item.kind == MN_TEXTFIELD
 222              || (item.kind == MN_NUMFIELD && mn_input_char >= '0' && mn_input_char <= '9'))
 223             {
 224               if(item.input != NULL)
 225                 {
 226                   int i = strlen(item.input);
 227                   item.input = (char*) realloc(item.input,sizeof(char)*(i + 2));
 228                   item.input[i] = mn_input_char;
 229                   item.input[i+1] = '\0';
 230                 }
 231               else
 232                 {
 233                   item.input = (char*) malloc(2*sizeof(char));
 234                   item.input[0] = mn_input_char;
 235                   item.input[1] = '\0';
 236                 }
 237             }
 238           break;
 239
 240         case MENU_ACTION_NONE:
 241           break;
 242         }
 243     }
 244
 245   menu_item_type& new_item = pmenu->item[pmenu->active_item];
 246   if(new_item.kind == MN_DEACTIVE
 247      || new_item.kind == MN_LABEL
 248      || new_item.kind == MN_HL)
 249     {
 250       // Skip the horzontal line item
 251       if(menuaction != MENU_ACTION_UP && menuaction != MENU_ACTION_DOWN)
 252         menuaction = MENU_ACTION_DOWN;
 253
 254       if(pmenu->num_items > 1)
 255         menu_action(pmenu);
 256     }
 257 }
 258
 259 /* Check, if the value of the active menu item has changed. */
 260 int menu_check(menu_type* pmenu)
 261 {
 262   menu_item_type& item = pmenu->item[pmenu->active_item];
 263
 264   if(pmenu->num_items != 0 && pmenu->item != NULL)
 265     {
 266       if((item.kind == MN_ACTION || item.kind == MN_TEXTFIELD || item.kind == MN_NUMFIELD) && item.toggled == YES)
 267         {
 268           item.toggled = NO;
 269           show_menu = 0;
 270           return pmenu->active_item;
 271         }
 272       else if(item.kind == MN_TOGGLE || item.kind == MN_GOTO)
 273         {
 274           return pmenu->active_item;
 275         }
 276       else
 277         return -1;
 278     }
 279   else
 280     return -1;
 281 }
 282
 283 void menu_draw_item(menu_type* pmenu,
 284                     int index, // Position of the current item in the menu
 285                     int menu_width,
 286                     int menu_height)
 287 {
 288   int font_width  = 16;
 289
 290   const menu_item_type& pitem =  pmenu->item[index];
 291
 292   int effect_offset = 0;
 293   {
 294     int effect_time = 0;
 295     if(timer_check(&pmenu->effect))
 296       effect_time = timer_get_left(&pmenu->effect) / 4;
 297
 298     effect_offset = (index % 2) ? effect_time : -effect_time;
 299   }
 300
 301   int x_pos       = pmenu->x;
 302   int y_pos       = pmenu->y + 24*index - menu_height/2 + 12 + effect_offset;
 303   int shadow_size = 2;
 304   int text_width  = strlen(pitem.text) * font_width;
 305   int input_width = strlen(pitem.input) * font_width;
 306   int list_width  = strlen(string_list_active(pitem.list)) * font_width;
 307   text_type* text_font = &white_text;
 308
 309   if(pmenu->arrange_left == YES)
 310     x_pos += 24 - menu_width/2 + (text_width + input_width + list_width)/2;
 311
 312   if(index == pmenu->active_item)
 313     {
 314       shadow_size = 3;
 315       text_font = &blue_text;
 316     }
 317
 318   switch (pitem.kind)
 319     {
 320     case MN_DEACTIVE:
 321       {
 322         text_draw_align(&black_text, pitem.text,
 323                         x_pos, y_pos,
 324                         A_HMIDDLE, A_VMIDDLE, 2);
 325         break;
 326       }
 327
 328     case MN_HL:
 329       {
 330         int x = pmenu->x - menu_width/2;
 331         int y = y_pos - 12 - effect_offset;
 332         /* Draw a horizontal line with a little 3d effect */
 333         fillrect(x, y + 6,
 334                  menu_width, 4,
 335                  210,50,50,225);
 336         fillrect(x, y + 6,
 337                  menu_width, 2,
 338                  0,0,0,255);
 339         break;
 340       }
 341     case MN_LABEL:
 342       {
 343         text_draw_align(&white_big_text, pitem.text,
 344                         x_pos, y_pos,
 345                         A_HMIDDLE, A_VMIDDLE, 2);
 346         break;
 347       }
 348     case MN_TEXTFIELD:
 349     case MN_NUMFIELD:
 350       {
 351         int input_pos = input_width/2;
 352         int text_pos  = (text_width + font_width)/2;
 353
 354         fillrect(x_pos - input_pos + text_pos - 1, y_pos - 10,
 355                  input_width + font_width + 2, 20,
 356                  255,255,255,255);
 357         fillrect(x_pos - input_pos + text_pos, y_pos - 9,
 358                  input_width + font_width, 18,
 359                  0,0,0,128);
 360
 361         text_draw_align(&gold_text, pitem.input,
 362                         x_pos + text_pos, y_pos,
 363                         A_HMIDDLE, A_VMIDDLE, 2);
 364
 365         text_draw_align(text_font, pitem.text,
 366                         x_pos - (input_width + font_width)/2, y_pos,
 367                         A_HMIDDLE, A_VMIDDLE, shadow_size);
 368         break;
 369       }
 370     case MN_STRINGSELECT:
 371       {
 372         int list_pos_2 = list_width + font_width;
 373         int list_pos   = list_width/2;
 374         int text_pos   = (text_width + font_width)/2;
 375
 376         /* Draw arrows */
 377         texture_draw(&arrow_left,  x_pos - list_pos + text_pos - 17, y_pos - 8);
 378         texture_draw(&arrow_right, x_pos - list_pos + text_pos - 1 + list_pos_2, y_pos - 8);
 379
 380         /* Draw input background */
 381         fillrect(x_pos - list_pos + text_pos - 1, y_pos - 10,
 382                  list_pos_2 + 2, 20,
 383                  255,255,255,255);
 384         fillrect(x_pos - list_pos + text_pos, y_pos - 9,
 385                  list_pos_2, 18,
 386                  0,0,0,128);
 387
 388         text_draw_align(&gold_text, string_list_active(pitem.list),
 389                         x_pos + text_pos, y_pos,
 390                         A_HMIDDLE, A_VMIDDLE,2);
 391
 392         text_draw_align(text_font, pitem.text,
 393                         x_pos - list_pos_2/2, y_pos,
 394                         A_HMIDDLE, A_VMIDDLE, shadow_size);
 395         break;
 396       }
 397     case MN_BACK:
 398       {
 399         text_draw_align(text_font, pitem.text, x_pos, y_pos, A_HMIDDLE, A_VMIDDLE, shadow_size);
 400         texture_draw(&back, x_pos + text_width/2  + font_width, y_pos - 8);
 401         break;
 402       }
 403
 404     case MN_TOGGLE:
 405       {
 406         text_draw_align(text_font, pitem.text, x_pos, y_pos, A_HMIDDLE, A_VMIDDLE, shadow_size);
 407
 408         if(pitem.toggled == YES)
 409           texture_draw(&checkbox_checked,
 410                        x_pos + (text_width+font_width)/2,
 411                        y_pos - 8);
 412         else
 413           texture_draw(&checkbox,
 414                        x_pos + (text_width+font_width)/2,
 415                        y_pos - 8);
 416         break;
 417       }
 418     case MN_ACTION:
 419       text_draw_align(text_font, pitem.text, x_pos, y_pos, A_HMIDDLE, A_VMIDDLE, shadow_size);
 420       break;
 421
 422     case MN_GOTO:
 423       text_draw_align(text_font, pitem.text, x_pos, y_pos, A_HMIDDLE, A_VMIDDLE, shadow_size);
 424       break;
 425     }
 426 }
 427
 428 /* Draw the current menu. */
 429 void menu_draw(menu_type* pmenu)
 430 {
 431   int menu_height;
 432   int menu_width;
 433
 434   /* The width of the menu has to be more than the width of the text
 435      with the most characters */
 436   menu_width = 0;
 437   for(int i = 0; i < pmenu->num_items; ++i)
 438     {
 439       int w = strlen(pmenu->item[i].text) + (pmenu->item[i].input ? strlen(pmenu->item[i].input) + 1 : 0) + strlen(string_list_active(pmenu->item[i].list));
 440       if( w > menu_width )
 441         {
 442           menu_width = w;
 443           if( pmenu->item[i].kind == MN_TOGGLE)
 444             menu_width += 2;
 445         }
 446     }
 447
 448   menu_width  = menu_width * 16 + 48;
 449   menu_height = (pmenu->num_items) * 24;
 450
 451   /* Draw a transparent background */
 452   fillrect(pmenu->x - menu_width/2,
 453            pmenu->y - 24*pmenu->num_items/2,
 454            menu_width,menu_height,150,150,150,100);
 455
 456   for(int i = 0; i < pmenu->num_items; ++i)
 457     {
 458       menu_draw_item(pmenu, i, menu_width, menu_height);
 459     }
 460 }
 461
 462 /* Reset/Set global defaults */
 463 void menu_reset(void)
 464 {
 465   menu_change  = NO;
 466   show_menu    = NO;
 467   menuaction   = MENU_ACTION_NONE;
 468   current_menu = NULL;
 469   last_menu    = NULL;
 470
 471   delete_character = 0;
 472   mn_input_char    = '\0';
 473 }
 474
 475 /* --- MENU --- */
 476 /* Draw the current menu and execute the (menu)events */
 477 void menu_process_current(void)
 478 {
 479   menu_change = NO;
 480
 481   if(current_menu != NULL)
 482     {
 483       menu_action(current_menu);
 484       menu_draw(current_menu);
 485     }
 486
 487   menuaction = MENU_ACTION_NONE;
 488 }
 489
 490 /* Check for menu event */
 491 void menu_event(SDL_keysym* keysym)
 492 {
 493   SDLKey key = keysym->sym;
 494   SDLMod keymod;
 495   char ch[2];
 496   keymod = SDL_GetModState();
 497
 498   /* If the current unicode character is an ASCII character,
 499      assign it to ch. */
 500   if ( (keysym->unicode & 0xFF80) == 0 )
 501     {
 502       ch[0] = keysym->unicode & 0x7F;
 503       ch[1] = '\0';
 504     }
 505   else
 506     {
 507       /* An International Character. */
 508     }
 509
 510   switch(key)
 511     {
 512     case SDLK_UP:               /* Menu Up */
 513       menuaction = MENU_ACTION_UP;
 514       menu_change = YES;
 515       break;
 516     case SDLK_DOWN:             /* Menu Down */
 517       menuaction = MENU_ACTION_DOWN;
 518       menu_change = YES;
 519       break;
 520     case SDLK_LEFT:             /* Menu Up */
 521       menuaction = MENU_ACTION_LEFT;
 522       menu_change = YES;
 523       break;
 524     case SDLK_RIGHT:            /* Menu Down */
 525       menuaction = MENU_ACTION_RIGHT;
 526       menu_change = YES;
 527       break;
 528     case SDLK_SPACE:
 529       if(current_menu->item[current_menu->active_item].kind == MN_TEXTFIELD)
 530       {
 531       menuaction = MENU_ACTION_INPUT;
 532       menu_change = YES;
 533       mn_input_char = ' ';
 534       break;
 535       }
 536     case SDLK_RETURN: /* Menu Hit */
 537       menuaction = MENU_ACTION_HIT;
 538       menu_change = YES;
 539       break;
 540     case SDLK_DELETE:
 541     case SDLK_BACKSPACE:
 542       menuaction = MENU_ACTION_REMOVE;
 543       menu_change = YES;
 544       delete_character++;
 545       break;
 546     default:
 547       if( (key >= SDLK_0 && key <= SDLK_9) || (key >= SDLK_a && key <= SDLK_z) || (key >= SDLK_SPACE && key <= SDLK_SLASH))
 548         {
 549           menuaction = MENU_ACTION_INPUT;
 550           menu_change = YES;
 551           mn_input_char = *ch;
 552         }
 553       else
 554         {
 555           mn_input_char = '\0';
 556         }
 557       break;
 558     }
 559
 560
 561   /* FIXME: NO JOYSTICK SUPPORT */
 562   /*#ifdef JOY_YES
 563   else if (event.type == SDL_JOYBUTTONDOWN)
 564    {
 565       Joystick button: Continue:
 566
 567      done = 1;
 568    }
 569   #endif*/
 570 }
 571
 572 menu_item_type*
 573 menu_additem(menu_type* pmenu, MenuItemKind kind, char *text, int init_toggle, void* target_menu)
 574 {
 575   menu_item_type* item = menu_item_create(kind, text, init_toggle, target_menu);
 576   menu_additem(pmenu, item);
 577   return item;
 578 }
 579
 580 // EOF //