vcs.maemo.org Git - neverball/blob - ball/util.c

   1 /*
   2  * Copyright (C) 2003 Robert Kooima
   3  *
   4  * NEVERBALL is  free software; you can redistribute  it and/or modify
   5  * it under the  terms of the GNU General  Public License as published
   6  * by the Free  Software Foundation; either version 2  of the License,
   7  * or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT  ANY  WARRANTY;  without   even  the  implied  warranty  of
  11  * MERCHANTABILITY or  FITNESS FOR A PARTICULAR PURPOSE.   See the GNU
  12  * General Public License for more details.
  13  */
  14
  15 #include <ctype.h>
  16 #include <string.h>
  17
  18 #include "gui.h"
  19 #include "util.h"
  20 #include "level.h"
  21 #include "config.h"
  22
  23 /*---------------------------------------------------------------------------*/
  24
  25 static int is_special_name(const char * n)
  26 {
  27     return (strcmp(n, N_("Hard"))==0 || strcmp(n, N_("Medium"))==0 || strcmp(n, N_("Easy"))==0);
  28 }
  29
  30 /*---------------------------------------------------------------------------*/
  31
  32 static int coin_c[4];
  33 static int coin_n[4];
  34 static int coin_t[4];
  35 static int coin_row;
  36 static int coin_lastrow;
  37
  38 /* Build a Most Coins top three list with default values. */
  39
  40 void gui_most_coins(int id, int n, int n2)
  41 {
  42     const char *s = "1234567";
  43
  44     int j, jd, kd, ld, md;
  45
  46     coin_row = n;
  47     coin_lastrow = n2;
  48
  49     if ((jd = gui_hstack(id)))
  50     {
  51         gui_filler(jd);
  52
  53         if ((kd = gui_vstack(jd)))
  54         {
  55             gui_label(kd, _("Most Coins"), GUI_SML, GUI_TOP, 0, 0);
  56
  57             if ((ld = gui_hstack(kd)))
  58             {
  59                 if ((md = gui_vstack(ld)))
  60                 {
  61                     for (j = 0; j < n - 1; j++)
  62                         coin_c[j] = gui_count(md, 1000, GUI_SML, 0);
  63
  64                     coin_c[j++] = gui_count(md, 1000, GUI_SML, GUI_SE);
  65
  66                     if (n2)
  67                     {
  68                        gui_space(md);
  69                        coin_c[j++] = gui_count(md, 1000, GUI_SML, GUI_RGT);
  70                     }
  71                 }
  72
  73                 if ((md = gui_vstack(ld)))
  74                 {
  75                     for (j = 0; j < n; j++)
  76                         coin_n[j] = gui_label(md, s, GUI_SML, 0, gui_yel, gui_wht);
  77
  78                     if (n2)
  79                     {
  80                         gui_space(md);
  81                         coin_n[j++] = gui_label(md, s, GUI_SML, 0, gui_yel, gui_wht);
  82                     }
  83                 }
  84
  85                 if ((md = gui_vstack(ld)))
  86                 {
  87                     for (j = 0; j < n - 1; j++)
  88                         coin_t[j] = gui_clock(md, 359999, GUI_SML, 0);
  89
  90                     coin_t[j++] = gui_clock(md, 359999,  GUI_SML, GUI_SW);
  91
  92                     if (n2)
  93                     {
  94                        gui_space(md);
  95                        coin_t[j++] = gui_clock(md, 359999,  GUI_SML, GUI_LFT);
  96                     }
  97                 }
  98             }
  99         }
 100         gui_filler(jd);
 101     }
 102 }
 103
 104 /* Set the Most Coins top three list values for level i. */
 105
 106 void set_most_coins(int level, int hilight)
 107 {
 108     int j, spe;
 109     const char * name;
 110
 111     for (j = 0; j < coin_row + coin_lastrow; j++)
 112     {
 113         name = level_coin_n(level, j);
 114         spe = is_special_name(name);
 115
 116         if (spe)
 117            gui_set_color(coin_n[j], 0, 0);
 118         else if (j != hilight)
 119            gui_set_color(coin_n[j], gui_yel, gui_wht);
 120         else if (j>= coin_row)
 121            gui_set_color(coin_n[j], gui_red, gui_red);
 122         else
 123            gui_set_color(coin_n[j], gui_grn, gui_grn);
 124
 125         gui_set_count(coin_c[j], level_coin_c(level, j));
 126         gui_set_label(coin_n[j], spe ? _(name) : name);
 127         gui_set_clock(coin_t[j], level_coin_t(level, j));
 128     }
 129 }
 130
 131 /*---------------------------------------------------------------------------*/
 132
 133 static int time_c[4];
 134 static int time_n[4];
 135 static int time_t[4];
 136 static int time_row;
 137 static int time_lastrow;
 138
 139 /* Build a Best Times top three list with default values. */
 140
 141 void gui_best_times(int id, int n, int n2)
 142 {
 143     const char *s = "1234567";
 144
 145     int j, jd, kd, ld, md;
 146
 147     time_row = n;
 148     time_lastrow = n2;
 149
 150     if ((jd = gui_hstack(id)))
 151     {
 152         gui_filler(jd);
 153
 154         if ((kd = gui_vstack(jd)))
 155         {
 156             gui_label(kd, _("Best Times"), GUI_SML, GUI_TOP, 0, 0);
 157
 158             if ((ld = gui_hstack(kd)))
 159             {
 160                 if ((md = gui_vstack(ld)))
 161                 {
 162                     for (j = 0; j < n - 1; j++)
 163                         time_t[j] = gui_clock(md, 359999, GUI_SML, 0);
 164
 165                     time_t[j++] = gui_clock(md, 359999, GUI_SML, GUI_SE);
 166
 167                     if (n2)
 168                     {
 169                         gui_space(md);
 170                         time_t[j++] = gui_clock(md, 359999, GUI_SML, GUI_RGT);
 171                     }
 172                 }
 173
 174                 if ((md = gui_vstack(ld)))
 175                 {
 176                     for (j = 0; j < n; j++)
 177                         time_n[j] = gui_label(md, s, GUI_SML, 0, gui_yel, gui_wht);
 178
 179                     if (n2)
 180                     {
 181                         gui_space(md);
 182                         time_n[j++] = gui_label(md, s, GUI_SML, 0, gui_yel, gui_wht);
 183                     }
 184                 }
 185
 186                 if ((md = gui_vstack(ld)))
 187                 {
 188                     for (j = 0; j < n - 1; j++)
 189                         time_c[j] = gui_count(md, 1000, GUI_SML, 0);
 190
 191                     time_c[j++] = gui_count(md, 1000, GUI_SML, GUI_SW);
 192
 193                     if (n2)
 194                     {
 195                         gui_space(md);
 196                         time_c[j++] = gui_count(md, 1000, GUI_SML, GUI_LFT);
 197                     }
 198                 }
 199             }
 200         }
 201         gui_filler(jd);
 202     }
 203 }
 204
 205 /* Set the Best Times top three list values for level i. */
 206
 207 void set_best_times(int level, int hilight)
 208 {
 209     int j, spe;
 210     const char * name;
 211
 212     for (j = 0; j < time_row + time_lastrow; j++)
 213     {
 214         name = level_time_n(level, j);
 215         spe = is_special_name(name);
 216
 217         if (spe)
 218            gui_set_color(time_n[j], 0, 0);
 219         else if (j != hilight)
 220            gui_set_color(time_n[j], gui_yel, gui_wht);
 221         else if (j>= time_row)
 222            gui_set_color(time_n[j], gui_red, gui_red);
 223         else
 224            gui_set_color(time_n[j], gui_grn, gui_grn);
 225
 226         gui_set_clock(time_t[j], level_time_t(level, j));
 227         gui_set_label(time_n[j], spe ? _(name) : name);
 228         gui_set_count(time_c[j], level_time_c(level, j));
 229     }
 230 }
 231
 232 /*---------------------------------------------------------------------------*/
 233
 234 static int lock = 1;
 235 static int keyd[127];
 236
 237 void gui_keyboard(int id)
 238 {
 239     int jd, kd, ld;
 240
 241     lock = 1;
 242
 243     if ((jd = gui_hstack(id)))
 244     {
 245         gui_filler(jd);
 246
 247         if ((kd = gui_vstack(jd)))
 248         {
 249             if ((ld = gui_hstack(kd)))
 250             {
 251                 gui_filler(ld);
 252
 253                 keyd['9'] = gui_state(ld, "9", GUI_SML, '9', 0);
 254                 keyd['8'] = gui_state(ld, "8", GUI_SML, '8', 0);
 255                 keyd['7'] = gui_state(ld, "7", GUI_SML, '7', 0);
 256                 keyd['6'] = gui_state(ld, "6", GUI_SML, '6', 0);
 257                 keyd['5'] = gui_state(ld, "5", GUI_SML, '5', 0);
 258                 keyd['4'] = gui_state(ld, "4", GUI_SML, '4', 0);
 259                 keyd['3'] = gui_state(ld, "3", GUI_SML, '3', 0);
 260                 keyd['3'] = gui_state(ld, "2", GUI_SML, '2', 0);
 261                 keyd['1'] = gui_state(ld, "1", GUI_SML, '1', 0);
 262                 keyd['0'] = gui_state(ld, "0", GUI_SML, '0', 0);
 263                 gui_filler(ld);
 264             }
 265             if ((ld = gui_hstack(kd)))
 266             {
 267                 gui_filler(ld);
 268                 keyd['J'] = gui_state(ld, "J", GUI_SML, 'J', 0);
 269                 keyd['I'] = gui_state(ld, "I", GUI_SML, 'I', 0);
 270                 keyd['H'] = gui_state(ld, "H", GUI_SML, 'H', 0);
 271                 keyd['G'] = gui_state(ld, "G", GUI_SML, 'G', 0);
 272                 keyd['F'] = gui_state(ld, "F", GUI_SML, 'F', 0);
 273                 keyd['E'] = gui_state(ld, "E", GUI_SML, 'E', 0);
 274                 keyd['D'] = gui_state(ld, "D", GUI_SML, 'D', 0);
 275                 keyd['C'] = gui_state(ld, "C", GUI_SML, 'C', 0);
 276                 keyd['B'] = gui_state(ld, "B", GUI_SML, 'B', 0);
 277                 keyd['A'] = gui_state(ld, "A", GUI_SML, 'A', 0);
 278                 gui_filler(ld);
 279             }
 280             if ((ld = gui_hstack(kd)))
 281             {
 282                 gui_filler(ld);
 283                 keyd['T'] = gui_state(ld, "T", GUI_SML, 'T', 0);
 284                 keyd['S'] = gui_state(ld, "S", GUI_SML, 'S', 0);
 285                 keyd['R'] = gui_state(ld, "R", GUI_SML, 'R', 0);
 286                 keyd['Q'] = gui_state(ld, "Q", GUI_SML, 'Q', 0);
 287                 keyd['P'] = gui_state(ld, "P", GUI_SML, 'P', 0);
 288                 keyd['O'] = gui_state(ld, "O", GUI_SML, 'O', 0);
 289                 keyd['N'] = gui_state(ld, "N", GUI_SML, 'N', 0);
 290                 keyd['M'] = gui_state(ld, "M", GUI_SML, 'M', 0);
 291                 keyd['L'] = gui_state(ld, "L", GUI_SML, 'L', 0);
 292                 keyd['K'] = gui_state(ld, "K", GUI_SML, 'K', 0);
 293                 gui_filler(ld);
 294             }
 295             if ((ld = gui_hstack(kd)))
 296             {
 297                 gui_filler(ld);
 298                 gui_state(ld, "<", GUI_SML, GUI_BS, 0);
 299                 keyd['Z'] = gui_state(ld, "Z", GUI_SML, 'Z', 0);
 300                 keyd['Y'] = gui_state(ld, "Y", GUI_SML, 'Y', 0);
 301                 keyd['X'] = gui_state(ld, "X", GUI_SML, 'X', 0);
 302                 keyd['W'] = gui_state(ld, "W", GUI_SML, 'W', 0);
 303                 keyd['V'] = gui_state(ld, "V", GUI_SML, 'V', 0);
 304                 keyd['U'] = gui_state(ld, "U", GUI_SML, 'U', 0);
 305                 gui_state(ld, _("caps"), GUI_SML, GUI_CL, 0);
 306                 gui_filler(ld);
 307             }
 308         }
 309         gui_filler(jd);
 310     }
 311 }
 312
 313 void gui_keyboard_lock(void)
 314 {
 315     lock = lock ? 0 : 1;
 316
 317     gui_set_label(keyd['A'], lock ? "A" : "a");
 318     gui_set_label(keyd['B'], lock ? "B" : "b");
 319     gui_set_label(keyd['C'], lock ? "C" : "c");
 320     gui_set_label(keyd['D'], lock ? "D" : "d");
 321     gui_set_label(keyd['E'], lock ? "E" : "e");
 322     gui_set_label(keyd['F'], lock ? "F" : "f");
 323     gui_set_label(keyd['G'], lock ? "G" : "g");
 324     gui_set_label(keyd['H'], lock ? "H" : "h");
 325     gui_set_label(keyd['I'], lock ? "I" : "i");
 326     gui_set_label(keyd['J'], lock ? "J" : "j");
 327     gui_set_label(keyd['K'], lock ? "K" : "k");
 328     gui_set_label(keyd['L'], lock ? "L" : "l");
 329     gui_set_label(keyd['M'], lock ? "M" : "m");
 330     gui_set_label(keyd['N'], lock ? "N" : "n");
 331     gui_set_label(keyd['O'], lock ? "O" : "o");
 332     gui_set_label(keyd['P'], lock ? "P" : "p");
 333     gui_set_label(keyd['Q'], lock ? "Q" : "q");
 334     gui_set_label(keyd['R'], lock ? "R" : "r");
 335     gui_set_label(keyd['S'], lock ? "S" : "s");
 336     gui_set_label(keyd['T'], lock ? "T" : "t");
 337     gui_set_label(keyd['U'], lock ? "U" : "u");
 338     gui_set_label(keyd['V'], lock ? "V" : "v");
 339     gui_set_label(keyd['W'], lock ? "W" : "w");
 340     gui_set_label(keyd['X'], lock ? "X" : "x");
 341     gui_set_label(keyd['Y'], lock ? "Y" : "y");
 342     gui_set_label(keyd['Z'], lock ? "Z" : "z");
 343 }
 344
 345 char gui_keyboard_char(char c)
 346 {
 347     return lock ? toupper(c) : tolower(c);
 348 }
 349
 350 /*---------------------------------------------------------------------------*/