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