engine/menu.cpp

   1 /*SENI, Search for Extra Nibiru Intelligence*/
   2
   3 /*
   4         This program 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 3 of the License, or
   7         (at your option) any later version.
   8
   9         This program 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
  15         along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16 */
  17
  18 /*
  19         Copyright SSW Team 2010
  20 */
  21
  22 #include <string.h>
  23 #include "menu.hpp"
  24 #include "engine.hpp"
  25
  26 Option::Option()
  27 {
  28         this->id = 0;
  29         this->image[0] = 0;
  30         this->Simage = 0;
  31         this->event = 0;
  32         this->engine = 0;
  33 }
  34
  35 Option::Option(Engine *e)
  36 {
  37         this->id = 0;
  38         this->image[0] = 0;
  39         this->Simage = 0;
  40         this->event = 0;
  41         this->engine = e;
  42 }
  43
  44 Option::Option(char *f, Engine *e)
  45 {
  46         this->id = 0;
  47         this->engine = e;
  48         this->setImage(f);
  49         this->event = 0;
  50 }
  51
  52 Option::Option(char *f, int i, Engine *e)
  53 {
  54         this->setId(i);
  55         this->engine = e;
  56         this->setImage(f);
  57         this->event = 0;
  58 }
  59
  60 int Option::getId(void)
  61 {
  62         return this->id;
  63 }
  64
  65 void Option::setId(int i)
  66 {
  67         this->id = i;
  68 }
  69
  70 int Option::setImage(char *f)
  71 {
  72         char err[255];
  73         if(!this->engine)
  74                 return MENU_NO_ENGINE;
  75         strcpy(this->image, f);
  76         this->Simage = SDL_LoadBMP(f);
  77         if(!this->Simage){
  78                 strcpy(err, "Error: SDL_LoadBMP(f): ");
  79                 strcat(err, SDL_GetError());
  80                 this->engine->setError(err);
  81                 return MENU_ERROR;
  82         }
  83         this->engine->setError((char *)"No hay errores", ERROR_NO_PRINT);
  84         return MENU_NO_ERROR;
  85 }
  86
  87 void Option::setEvent(option_event oe)
  88 {
  89         event = oe;
  90 }
  91
  92 int Option::execEvent(SDL_Event *se, Engine *e, Menu *m, Option *o)
  93 {
  94         if(!this->event)
  95                 return OPTION_STAY;
  96         return this->event(se, e, m, o);
  97 }
  98
  99 int Option::show(void)
 100 {
 101         char err[255];
 102         if(!this->engine)
 103                 return MENU_NO_ENGINE;
 104         if(!this->Simage){
 105                 engine->setError((char *)"Error: No se asigno imagen");
 106                 return MENU_ERROR;
 107         }
 108         if(this->engine->show(this->Simage, this->x, this->y, this->Simage->w, this->Simage->h) == ENGINE_ERROR){
 109                 strcpy(err, "Error: Option->show()->engine->show(): ");
 110                 strcat(err, SDL_GetError());
 111                 this->engine->setError(err);
 112                 return MENU_ERROR;
 113         }
 114 //      this->engine->update(this->x, this->y, this->Simage->w, this->Simage->h);
 115         engine->setError((char *)"No hay errores", ERROR_NO_PRINT);
 116         return MENU_NO_ERROR;
 117
 118 }
 119
 120 int Option::update(void)
 121 {
 122         if(!engine)
 123                 return MENU_NO_ENGINE;
 124         this->engine->update(this->x, this->y, this->Simage->w, this->Simage->h);
 125         return MENU_NO_ERROR;
 126 }
 127
 128 void Option::setXY(int x, int y)
 129 {
 130         this->x = x;
 131         this->y = y;
 132 }
 133
 134 int Option::getX(void)
 135 {
 136         return this->x;
 137 }
 138
 139 int Option::getY(void)
 140 {
 141         return this->y;
 142 }
 143
 144 int Option::getH(void)
 145 {
 146         return this->Simage ? this->Simage->h : 0;
 147 }
 148
 149 int Option::getW(void)
 150 {
 151         return this->Simage ? this->Simage->w : 0;
 152 }
 153
 154 void Option::setEngine(Engine *e)
 155 {
 156         this->engine = e;
 157 }
 158
 159 Menu::Menu(void)
 160 {
 161         int i;
 162         this->engine = 0;
 163         for(i = 0; i < MAX_OPTIONS; i++)
 164                 this->options[i] = WITHOUT_OPTION;
 165         this->wallpaper[0] = 0;
 166 }
 167
 168 Menu::Menu(Engine *e)
 169 {
 170         int i;
 171         this->engine = e;
 172         for(i = 0; i < MAX_OPTIONS; i++)
 173                 this->options[i] = WITHOUT_OPTION;
 174         this->wallpaper[0] = 0;
 175 }
 176
 177 Menu::Menu(char *w, Engine *e)
 178 {
 179         int i;
 180         this->engine = e;
 181         for(i = 0; i < MAX_OPTIONS; i++)
 182                 this->options[i] = WITHOUT_OPTION;
 183         this->setWallpaper(w);
 184 }
 185
 186 Menu::Menu(char *w, Option **o, int im, Engine *e)
 187 {
 188         int i;
 189         this->engine = e;
 190         for(i = 0; i < im && i < MAX_OPTIONS; i++){
 191                 this->options[i] = o[i];
 192         }
 193         for(;i < MAX_OPTIONS; i++)
 194                 this->options[i] = WITHOUT_OPTION;
 195         this->setWallpaper(w);
 196 }
 197
 198 int Menu::setWallpaper(char *w)
 199 {
 200         char err[255];
 201         strcpy(this->wallpaper, w);
 202         this->Swallpaper = SDL_LoadBMP(w);
 203         if(!this->Swallpaper){
 204                 strcpy(err, "Error: SDL_LoadBMP(w): ");
 205                 strcat(err, SDL_GetError());
 206                 this->engine->setError(err);
 207                 return MENU_ERROR;
 208         }
 209         this->engine->setError((char *)"No hay errores", ERROR_NO_PRINT);
 210         return MENU_NO_ERROR;
 211 }
 212
 213 int Menu::addOption(Option *o)
 214 {
 215         int i;
 216         for(i = 0; i < MAX_OPTIONS; i++){
 217                 if(this->options[i] == WITHOUT_OPTION){
 218                         this->options[i] = o;
 219                         return MENU_NO_ERROR;
 220                 }
 221         }
 222         return OPTIONS_FULL;
 223 }
 224
 225 Option *Menu::getOptionById(int oid)
 226 {
 227         int i;
 228         for(i = 0; i < MAX_OPTIONS; i++){
 229                 if(options[i] != WITHOUT_OPTION && options[i]->getId() == oid){
 230                         return options[i];
 231                 }
 232         }
 233         return 0;
 234 }
 235
 236 Option *Menu::getOption(int i)
 237 {
 238         if(i >= MAX_OPTIONS)
 239                 return WITHOUT_OPTION;
 240         return this->options[i];
 241 }
 242
 243 int Menu::removeOption(int oid)
 244 {
 245         int i;
 246         for(i = 0; i < MAX_OPTIONS; i++){
 247                 if(options[i] != WITHOUT_OPTION && options[i]->getId() == oid){
 248                         options[i] = WITHOUT_OPTION;
 249                         return MENU_NO_ERROR;
 250                 }
 251         }
 252         return NO_OPTION;
 253 }
 254
 255 int Menu::show()
 256 {
 257         int i;
 258         char err[255];
 259         if(!this->engine)
 260                 return MENU_NO_ENGINE;
 261         if(this->engine->show(this->Swallpaper, 0, 0, this->Swallpaper->w, this->Swallpaper->h) == ENGINE_ERROR){
 262                 strcpy(err, "Error: Menu->show()->engine->show(): ");
 263                 strcat(err, SDL_GetError());
 264                 this->engine->setError(err);
 265                 return MENU_ERROR;
 266         }
 267 //      this->engine->update(0, 0, 0, 0);
 268         for(i = 0; i < MAX_OPTIONS; ++i){
 269                 if(this->options[i] != WITHOUT_OPTION){
 270                         int r = this->options[i]->show();
 271                         if(r != MENU_NO_ERROR)
 272                                 return r;
 273                 }
 274         }
 275         return MENU_NO_ERROR;
 276 }
 277
 278 int Menu::update(void)
 279 {
 280         if(!engine)
 281                 return MENU_NO_ENGINE;
 282         this->engine->update(0, 0, 0, 0);
 283         return MENU_NO_ERROR;
 284 }
 285
 286 void Menu::setEngine(Engine *e)
 287 {
 288         this->engine = e;
 289 }