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
  36 /* Build a Most Coins top three list with default values. */
  37
  38 void gui_most_coins(int id, int n, int i)
  39 {
  40     const char *s = "1234567";
  41
  42     const float *c0 = gui_yel;
  43     const float *c1 = gui_grn;
  44     const float *c2 = gui_wht;
  45     const float *c3 = gui_red;
  46
  47     int j, jd, kd, ld, md;
  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 - 2; 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                     gui_space(md);
  66                     coin_c[j++] = gui_count(md, 1000, GUI_SML, GUI_RGT);
  67                 }
  68
  69                 if ((md = gui_vstack(ld)))
  70                 {
  71                     for (j = 0; j < n; j++)
  72                         if      (i == j && i < n - 1)
  73                             coin_n[j] = gui_label(md, s, GUI_SML, 0, c1, c1);
  74                         else if (i == j)
  75                         {
  76                             if (j == n - 1) gui_space(md);
  77                             coin_n[j] = gui_label(md, s, GUI_SML, 0, c3, c3);
  78                         }
  79                         else
  80                         {
  81                             if (j == n - 1) gui_space(md);
  82                             coin_n[j] = gui_label(md, s, GUI_SML, 0, c0, c2);
  83                         }
  84                 }
  85
  86                 if ((md = gui_vstack(ld)))
  87                 {
  88                     for (j = 0; j < n - 2; j++)
  89                         coin_t[j] = gui_clock(md, 359999, GUI_SML, 0);
  90
  91                     coin_t[j++] = gui_clock(md, 359999,  GUI_SML, GUI_SW);
  92                     gui_space(md);
  93                     coin_t[j++] = gui_clock(md, 359999,  GUI_SML, GUI_LFT);
  94                 }
  95             }
  96         }
  97         gui_filler(jd);
  98     }
  99 }
 100
 101 /* Set the Most Coins top three list values for level i. */
 102
 103 void set_most_coins(int level, int n)
 104 {
 105     int j, spe;
 106     const char * name;
 107
 108     for (j = 0; j < n; j++)
 109     {
 110         name = level_coin_n(level, j);
 111         spe = is_special_name(name);
 112         gui_set_count(coin_c[j], level_coin_c(level, j));
 113         gui_set_label(coin_n[j], spe ? _(name) : name);
 114         gui_set_clock(coin_t[j], level_coin_t(level, j));
 115     }
 116 }
 117
 118 /*---------------------------------------------------------------------------*/
 119
 120 static int time_c[4];
 121 static int time_n[4];
 122 static int time_t[4];
 123
 124 /* Build a Best Times top three list with default values. */
 125
 126 void gui_best_times(int id, int n, int i)
 127 {
 128     const char *s = "1234567";
 129
 130     const float *c0 = gui_yel;
 131     const float *c1 = gui_grn;
 132     const float *c2 = gui_wht;
 133     const float *c3 = gui_red;
 134
 135     int j, jd, kd, ld, md;
 136
 137     if ((jd = gui_hstack(id)))
 138     {
 139         gui_filler(jd);
 140
 141         if ((kd = gui_vstack(jd)))
 142         {
 143             gui_label(kd, _("Best Times"), GUI_SML, GUI_TOP, 0, 0);
 144
 145             if ((ld = gui_hstack(kd)))
 146             {
 147                 if ((md = gui_vstack(ld)))
 148                 {
 149                     for (j = 0; j < n - 2; j++)
 150                         time_t[j] = gui_clock(md, 359999, GUI_SML, 0);
 151
 152                     time_t[j++] = gui_clock(md, 359999, GUI_SML, GUI_SE);
 153                     gui_space(md);
 154                     time_t[j++] = gui_clock(md, 359999, GUI_SML, GUI_RGT);
 155                 }
 156
 157                 if ((md = gui_vstack(ld)))
 158                 {
 159                     for (j = 0; j < n; j++)
 160                         if      (i == j && i < n - 1)
 161                             time_n[j] = gui_label(md, s, GUI_SML, 0, c1, c1);
 162                         else if (i == j)
 163                         {
 164                             if (j == n - 1) gui_space(md);
 165                             time_n[j] = gui_label(md, s, GUI_SML, 0, c3, c3);
 166                         }
 167                         else
 168                         {
 169                             if (j == n - 1) gui_space(md);
 170                             time_n[j] = gui_label(md, s, GUI_SML, 0, c0, c2);
 171                         }
 172                 }
 173
 174                 if ((md = gui_vstack(ld)))
 175                 {
 176                     for (j = 0; j < n - 2; j++)
 177                         time_c[j] = gui_count(md, 1000, GUI_SML, 0);
 178
 179                     time_c[j++] = gui_count(md, 1000, GUI_SML, GUI_SW);
 180                     gui_space(md);
 181                     time_c[j++] = gui_count(md, 1000, GUI_SML, GUI_LFT);
 182                 }
 183             }
 184         }
 185         gui_filler(jd);
 186     }
 187 }
 188
 189 /* Set the Best Times top three list values for level i. */
 190
 191 void set_best_times(int level, int n)
 192 {
 193     int j, spe;
 194     const char * name;
 195
 196     for (j = 0; j < n; j++)
 197     {
 198         name = level_time_n(level, j);
 199         spe = is_special_name(name);
 200         gui_set_clock(time_t[j], level_time_t(level, j));
 201         gui_set_label(time_n[j], spe ? _(name) : name);
 202         gui_set_count(time_c[j], level_time_c(level, j));
 203     }
 204 }
 205
 206 /*---------------------------------------------------------------------------*/
 207
 208 static int lock = 1;
 209 static int keyd[127];
 210
 211 void gui_keyboard(int id)
 212 {
 213     int jd, kd, ld;
 214
 215     lock = 1;
 216
 217     if ((jd = gui_hstack(id)))
 218     {
 219         gui_filler(jd);
 220
 221         if ((kd = gui_vstack(jd)))
 222         {
 223             if ((ld = gui_hstack(kd)))
 224             {
 225                 gui_filler(ld);
 226
 227                 keyd['9'] = gui_state(ld, "9", GUI_SML, '9', 0);
 228                 keyd['8'] = gui_state(ld, "8", GUI_SML, '8', 0);
 229                 keyd['7'] = gui_state(ld, "7", GUI_SML, '7', 0);
 230                 keyd['6'] = gui_state(ld, "6", GUI_SML, '6', 0);
 231                 keyd['5'] = gui_state(ld, "5", GUI_SML, '5', 0);
 232                 keyd['4'] = gui_state(ld, "4", GUI_SML, '4', 0);
 233                 keyd['3'] = gui_state(ld, "3", GUI_SML, '3', 0);
 234                 keyd['3'] = gui_state(ld, "2", GUI_SML, '2', 0);
 235                 keyd['1'] = gui_state(ld, "1", GUI_SML, '1', 0);
 236                 keyd['0'] = gui_state(ld, "0", GUI_SML, '0', 0);
 237                 gui_filler(ld);
 238             }
 239             if ((ld = gui_hstack(kd)))
 240             {
 241                 gui_filler(ld);
 242                 keyd['J'] = gui_state(ld, "J", GUI_SML, 'J', 0);
 243                 keyd['I'] = gui_state(ld, "I", GUI_SML, 'I', 0);
 244                 keyd['H'] = gui_state(ld, "H", GUI_SML, 'H', 0);
 245                 keyd['G'] = gui_state(ld, "G", GUI_SML, 'G', 0);
 246                 keyd['F'] = gui_state(ld, "F", GUI_SML, 'F', 0);
 247                 keyd['E'] = gui_state(ld, "E", GUI_SML, 'E', 0);
 248                 keyd['D'] = gui_state(ld, "D", GUI_SML, 'D', 0);
 249                 keyd['C'] = gui_state(ld, "C", GUI_SML, 'C', 0);
 250                 keyd['B'] = gui_state(ld, "B", GUI_SML, 'B', 0);
 251                 keyd['A'] = gui_state(ld, "A", GUI_SML, 'A', 0);
 252                 gui_filler(ld);
 253             }
 254             if ((ld = gui_hstack(kd)))
 255             {
 256                 gui_filler(ld);
 257                 keyd['T'] = gui_state(ld, "T", GUI_SML, 'T', 0);
 258                 keyd['S'] = gui_state(ld, "S", GUI_SML, 'S', 0);
 259                 keyd['R'] = gui_state(ld, "R", GUI_SML, 'R', 0);
 260                 keyd['Q'] = gui_state(ld, "Q", GUI_SML, 'Q', 0);
 261                 keyd['P'] = gui_state(ld, "P", GUI_SML, 'P', 0);
 262                 keyd['O'] = gui_state(ld, "O", GUI_SML, 'O', 0);
 263                 keyd['N'] = gui_state(ld, "N", GUI_SML, 'N', 0);
 264                 keyd['M'] = gui_state(ld, "M", GUI_SML, 'M', 0);
 265                 keyd['L'] = gui_state(ld, "L", GUI_SML, 'L', 0);
 266                 keyd['K'] = gui_state(ld, "K", GUI_SML, 'K', 0);
 267                 gui_filler(ld);
 268             }
 269             if ((ld = gui_hstack(kd)))
 270             {
 271                 gui_filler(ld);
 272                 gui_state(ld, "<", GUI_SML, GUI_BS, 0);
 273                 keyd['Z'] = gui_state(ld, "Z", GUI_SML, 'Z', 0);
 274                 keyd['Y'] = gui_state(ld, "Y", GUI_SML, 'Y', 0);
 275                 keyd['X'] = gui_state(ld, "X", GUI_SML, 'X', 0);
 276                 keyd['W'] = gui_state(ld, "W", GUI_SML, 'W', 0);
 277                 keyd['V'] = gui_state(ld, "V", GUI_SML, 'V', 0);
 278                 keyd['U'] = gui_state(ld, "U", GUI_SML, 'U', 0);
 279                 gui_state(ld, _("caps"), GUI_SML, GUI_CL, 0);
 280                 gui_filler(ld);
 281             }
 282         }
 283         gui_filler(jd);
 284     }
 285 }
 286
 287 void gui_keyboard_lock(void)
 288 {
 289     lock = lock ? 0 : 1;
 290
 291     gui_set_label(keyd['A'], lock ? "A" : "a");
 292     gui_set_label(keyd['B'], lock ? "B" : "b");
 293     gui_set_label(keyd['C'], lock ? "C" : "c");
 294     gui_set_label(keyd['D'], lock ? "D" : "d");
 295     gui_set_label(keyd['E'], lock ? "E" : "e");
 296     gui_set_label(keyd['F'], lock ? "F" : "f");
 297     gui_set_label(keyd['G'], lock ? "G" : "g");
 298     gui_set_label(keyd['H'], lock ? "H" : "h");
 299     gui_set_label(keyd['I'], lock ? "I" : "i");
 300     gui_set_label(keyd['J'], lock ? "J" : "j");
 301     gui_set_label(keyd['K'], lock ? "K" : "k");
 302     gui_set_label(keyd['L'], lock ? "L" : "l");
 303     gui_set_label(keyd['M'], lock ? "M" : "m");
 304     gui_set_label(keyd['N'], lock ? "N" : "n");
 305     gui_set_label(keyd['O'], lock ? "O" : "o");
 306     gui_set_label(keyd['P'], lock ? "P" : "p");
 307     gui_set_label(keyd['Q'], lock ? "Q" : "q");
 308     gui_set_label(keyd['R'], lock ? "R" : "r");
 309     gui_set_label(keyd['S'], lock ? "S" : "s");
 310     gui_set_label(keyd['T'], lock ? "T" : "t");
 311     gui_set_label(keyd['U'], lock ? "U" : "u");
 312     gui_set_label(keyd['V'], lock ? "V" : "v");
 313     gui_set_label(keyd['W'], lock ? "W" : "w");
 314     gui_set_label(keyd['X'], lock ? "X" : "x");
 315     gui_set_label(keyd['Y'], lock ? "Y" : "y");
 316     gui_set_label(keyd['Z'], lock ? "Z" : "z");
 317 }
 318
 319 char gui_keyboard_char(char c)
 320 {
 321     return lock ? toupper(c) : tolower(c);
 322 }
 323
 324 /*---------------------------------------------------------------------------*/