src/libgame/gadgets.c

   1 /***********************************************************
   2 * Artsoft Retro-Game Library                               *
   3 *----------------------------------------------------------*
   4 * (c) 1994-2002 Artsoft Entertainment                      *
   5 *               Holger Schemel                             *
   6 *               Detmolder Strasse 189                      *
   7 *               33604 Bielefeld                            *
   8 *               Germany                                    *
   9 *               e-mail: info@artsoft.org                   *
  10 *----------------------------------------------------------*
  11 * gadgets.c                                                *
  12 ***********************************************************/
  13
  14 #include <stdarg.h>
  15 #include <string.h>
  16
  17 #include "gadgets.h"
  18 #include "text.h"
  19 #include "misc.h"
  20
  21
  22 /* values for DrawGadget() */
  23 #define DG_UNPRESSED            0
  24 #define DG_PRESSED              1
  25 #define DG_BUFFERED             0
  26 #define DG_DIRECT               1
  27
  28 static struct GadgetInfo *gadget_list_first_entry = NULL;
  29 static struct GadgetInfo *gadget_list_last_entry = NULL;
  30 static int next_free_gadget_id = 1;
  31 static boolean gadget_id_wrapped = FALSE;
  32
  33 static struct GadgetInfo *getGadgetInfoFromGadgetID(int id)
  34 {
  35   struct GadgetInfo *gi = gadget_list_first_entry;
  36
  37   while (gi && gi->id != id)
  38     gi = gi->next;
  39
  40   return gi;
  41 }
  42
  43 static int getNewGadgetID()
  44 {
  45   int id = next_free_gadget_id++;
  46
  47   if (next_free_gadget_id <= 0)         /* counter overrun */
  48   {
  49     gadget_id_wrapped = TRUE;           /* now we must check each ID */
  50     next_free_gadget_id = 0;
  51   }
  52
  53   if (gadget_id_wrapped)
  54   {
  55     next_free_gadget_id++;
  56     while (getGadgetInfoFromGadgetID(next_free_gadget_id) != NULL)
  57       next_free_gadget_id++;
  58   }
  59
  60   if (next_free_gadget_id <= 0)         /* cannot get new gadget id */
  61     Error(ERR_EXIT, "too much gadgets -- this should not happen");
  62
  63   return id;
  64 }
  65
  66 #if 0
  67 void DUMP_GADGET_MAP_STATE()
  68 {
  69   struct GadgetInfo *gi = gadget_list_first_entry;
  70
  71   while (gi)
  72   {
  73     printf("-XXX-1-> '%s': %s\n",
  74            gi->info_text, (gi->mapped ? "mapped" : "not mapped"));
  75
  76     gi = gi->next;
  77   }
  78 }
  79 #endif
  80
  81 static struct GadgetInfo *getGadgetInfoFromMousePosition(int mx, int my)
  82 {
  83   struct GadgetInfo *gi = gadget_list_first_entry;
  84
  85   while (gi)
  86   {
  87     if (gi->mapped &&
  88         mx >= gi->x && mx < gi->x + gi->width &&
  89         my >= gi->y && my < gi->y + gi->height)
  90         break;
  91
  92     gi = gi->next;
  93   }
  94
  95   return gi;
  96 }
  97
  98 static void default_callback_info(void *ptr)
  99 {
 100   return;
 101 }
 102
 103 static void default_callback_action(void *ptr)
 104 {
 105   return;
 106 }
 107
 108 static void DrawGadget(struct GadgetInfo *gi, boolean pressed, boolean direct)
 109 {
 110   int state = (pressed ? 1 : 0);
 111   struct GadgetDesign *gd = (gi->checked ?
 112                              &gi->alt_design[state] :
 113                              &gi->design[state]);
 114
 115   switch (gi->type)
 116   {
 117     case GD_TYPE_NORMAL_BUTTON:
 118     case GD_TYPE_CHECK_BUTTON:
 119     case GD_TYPE_RADIO_BUTTON:
 120       BlitBitmap(gd->bitmap, drawto,
 121                  gd->x, gd->y, gi->width, gi->height, gi->x, gi->y);
 122       if (gi->deco.design.bitmap)
 123         BlitBitmap(gi->deco.design.bitmap, drawto,
 124                    gi->deco.design.x, gi->deco.design.y,
 125                    gi->deco.width, gi->deco.height,
 126                    gi->x + gi->deco.x + (pressed ? gi->deco.xshift : 0),
 127                    gi->y + gi->deco.y + (pressed ? gi->deco.yshift : 0));
 128       break;
 129
 130     case GD_TYPE_TEXTINPUT_ALPHANUMERIC:
 131     case GD_TYPE_TEXTINPUT_NUMERIC:
 132       {
 133         int i;
 134         char cursor_letter;
 135         char cursor_string[3];
 136         char text[MAX_GADGET_TEXTSIZE + 1];
 137         int font_type = gi->text.font_type;
 138         int font_width = getFontWidth(FS_SMALL, font_type);
 139         int border = gi->border.size;
 140         strcpy(text, gi->text.value);
 141         strcat(text, " ");
 142
 143         /* left part of gadget */
 144         BlitBitmap(gd->bitmap, drawto,
 145                    gd->x, gd->y, border, gi->height, gi->x, gi->y);
 146
 147         /* middle part of gadget */
 148         for (i=0; i<=gi->text.size; i++)
 149           BlitBitmap(gd->bitmap, drawto,
 150                      gd->x + border, gd->y, font_width, gi->height,
 151                      gi->x + border + i * font_width, gi->y);
 152
 153         /* right part of gadget */
 154         BlitBitmap(gd->bitmap, drawto,
 155                    gd->x + gi->border.width - border, gd->y,
 156                    border, gi->height, gi->x + gi->width - border, gi->y);
 157
 158         /* gadget text value */
 159         DrawText(gi->x + border, gi->y + border, text, FS_SMALL, font_type);
 160
 161         cursor_letter = gi->text.value[gi->text.cursor_position];
 162         cursor_string[0] = '~';
 163         cursor_string[1] = (cursor_letter != '\0' ? cursor_letter : ' ');
 164         cursor_string[2] = '\0';
 165
 166         /* draw cursor, if active */
 167         if (pressed)
 168           DrawText(gi->x + border + gi->text.cursor_position * font_width,
 169                    gi->y + border, cursor_string, FS_SMALL, font_type);
 170       }
 171       break;
 172
 173     case GD_TYPE_SCROLLBAR_VERTICAL:
 174       {
 175         int i;
 176         int xpos = gi->x;
 177         int ypos = gi->y + gi->scrollbar.position;
 178         int design_full = gi->width;
 179         int design_body = design_full - 2 * gi->border.size;
 180         int size_full = gi->scrollbar.size;
 181         int size_body = size_full - 2 * gi->border.size;
 182         int num_steps = size_body / design_body;
 183         int step_size_remain = size_body - num_steps * design_body;
 184
 185         /* clear scrollbar area */
 186         ClearRectangle(backbuffer, gi->x, gi->y, gi->width, gi->height);
 187
 188         /* upper part of gadget */
 189         BlitBitmap(gd->bitmap, drawto,
 190                    gd->x, gd->y,
 191                    gi->width, gi->border.size,
 192                    xpos, ypos);
 193
 194         /* middle part of gadget */
 195         for (i=0; i<num_steps; i++)
 196           BlitBitmap(gd->bitmap, drawto,
 197                      gd->x, gd->y + gi->border.size,
 198                      gi->width, design_body,
 199                      xpos, ypos + gi->border.size + i * design_body);
 200
 201         /* remaining middle part of gadget */
 202         if (step_size_remain > 0)
 203           BlitBitmap(gd->bitmap, drawto,
 204                      gd->x,  gd->y + gi->border.size,
 205                      gi->width, step_size_remain,
 206                      xpos, ypos + gi->border.size + num_steps * design_body);
 207
 208         /* lower part of gadget */
 209         BlitBitmap(gd->bitmap, drawto,
 210                    gd->x, gd->y + design_full - gi->border.size,
 211                    gi->width, gi->border.size,
 212                    xpos, ypos + size_full - gi->border.size);
 213       }
 214       break;
 215
 216     case GD_TYPE_SCROLLBAR_HORIZONTAL:
 217       {
 218         int i;
 219         int xpos = gi->x + gi->scrollbar.position;
 220         int ypos = gi->y;
 221         int design_full = gi->height;
 222         int design_body = design_full - 2 * gi->border.size;
 223         int size_full = gi->scrollbar.size;
 224         int size_body = size_full - 2 * gi->border.size;
 225         int num_steps = size_body / design_body;
 226         int step_size_remain = size_body - num_steps * design_body;
 227
 228         /* clear scrollbar area */
 229         ClearRectangle(backbuffer, gi->x, gi->y, gi->width, gi->height);
 230
 231         /* left part of gadget */
 232         BlitBitmap(gd->bitmap, drawto,
 233                    gd->x, gd->y,
 234                    gi->border.size, gi->height,
 235                    xpos, ypos);
 236
 237         /* middle part of gadget */
 238         for (i=0; i<num_steps; i++)
 239           BlitBitmap(gd->bitmap, drawto,
 240                      gd->x + gi->border.size, gd->y,
 241                      design_body, gi->height,
 242                      xpos + gi->border.size + i * design_body, ypos);
 243
 244         /* remaining middle part of gadget */
 245         if (step_size_remain > 0)
 246           BlitBitmap(gd->bitmap, drawto,
 247                      gd->x + gi->border.size, gd->y,
 248                      step_size_remain, gi->height,
 249                      xpos + gi->border.size + num_steps * design_body, ypos);
 250
 251         /* right part of gadget */
 252         BlitBitmap(gd->bitmap, drawto,
 253                    gd->x + design_full - gi->border.size, gd->y,
 254                    gi->border.size, gi->height,
 255                    xpos + size_full - gi->border.size, ypos);
 256       }
 257       break;
 258
 259     default:
 260       return;
 261   }
 262
 263   if (direct)
 264     BlitBitmap(drawto, window,
 265                gi->x, gi->y, gi->width, gi->height, gi->x, gi->y);
 266   else
 267     redraw_mask |= (gi->x < gfx.sx + gfx.sxsize ? REDRAW_FIELD :
 268                     gi->y < gfx.dy + gfx.dysize ? REDRAW_DOOR_1 :
 269                     gi->y > gfx.vy ? REDRAW_DOOR_2 : REDRAW_DOOR_3);
 270 }
 271
 272 static void HandleGadgetTags(struct GadgetInfo *gi, int first_tag, va_list ap)
 273 {
 274   int tag = first_tag;
 275
 276   while (tag != GDI_END)
 277   {
 278     switch(tag)
 279     {
 280       case GDI_CUSTOM_ID:
 281         gi->custom_id = va_arg(ap, int);
 282         break;
 283
 284       case GDI_CUSTOM_TYPE_ID:
 285         gi->custom_type_id = va_arg(ap, int);
 286         break;
 287
 288       case GDI_INFO_TEXT:
 289         {
 290           int max_textsize = MAX_INFO_TEXTSIZE - 1;
 291
 292           strncpy(gi->info_text, va_arg(ap, char *), max_textsize);
 293           gi->info_text[max_textsize] = '\0';
 294         }
 295         break;
 296
 297       case GDI_X:
 298         gi->x = va_arg(ap, int);
 299         break;
 300
 301       case GDI_Y:
 302         gi->y = va_arg(ap, int);
 303         break;
 304
 305       case GDI_WIDTH:
 306         gi->width = va_arg(ap, int);
 307         break;
 308
 309       case GDI_HEIGHT:
 310         gi->height = va_arg(ap, int);
 311         break;
 312
 313       case GDI_TYPE:
 314         gi->type = va_arg(ap, unsigned long);
 315         break;
 316
 317       case GDI_STATE:
 318         gi->state = va_arg(ap, unsigned long);
 319         break;
 320
 321       case GDI_CHECKED:
 322         /* take care here: "boolean" is typedef'ed as "unsigned char",
 323            which gets promoted to "int" */
 324         gi->checked = (boolean)va_arg(ap, int);
 325         break;
 326
 327       case GDI_RADIO_NR:
 328         gi->radio_nr = va_arg(ap, unsigned long);
 329         break;
 330
 331       case GDI_NUMBER_VALUE:
 332         gi->text.number_value = va_arg(ap, long);
 333         sprintf(gi->text.value, "%d", gi->text.number_value);
 334         gi->text.cursor_position = strlen(gi->text.value);
 335         break;
 336
 337       case GDI_NUMBER_MIN:
 338         gi->text.number_min = va_arg(ap, long);
 339         if (gi->text.number_value < gi->text.number_min)
 340         {
 341           gi->text.number_value = gi->text.number_min;
 342           sprintf(gi->text.value, "%d", gi->text.number_value);
 343         }
 344         break;
 345
 346       case GDI_NUMBER_MAX:
 347         gi->text.number_max = va_arg(ap, long);
 348         if (gi->text.number_value > gi->text.number_max)
 349         {
 350           gi->text.number_value = gi->text.number_max;
 351           sprintf(gi->text.value, "%d", gi->text.number_value);
 352         }
 353         break;
 354
 355       case GDI_TEXT_VALUE:
 356         {
 357           int max_textsize = MAX_GADGET_TEXTSIZE;
 358
 359           if (gi->text.size)
 360             max_textsize = MIN(gi->text.size, MAX_GADGET_TEXTSIZE - 1);
 361
 362           strncpy(gi->text.value, va_arg(ap, char *), max_textsize);
 363           gi->text.value[max_textsize] = '\0';
 364           gi->text.cursor_position = strlen(gi->text.value);
 365         }
 366         break;
 367
 368       case GDI_TEXT_SIZE:
 369         {
 370           int tag_value = va_arg(ap, int);
 371           int max_textsize = MIN(tag_value, MAX_GADGET_TEXTSIZE - 1);
 372
 373           gi->text.size = max_textsize;
 374           gi->text.value[max_textsize] = '\0';
 375         }
 376         break;
 377
 378       case GDI_TEXT_FONT:
 379         gi->text.font_type = va_arg(ap, int);
 380         break;
 381
 382       case GDI_DESIGN_UNPRESSED:
 383         gi->design[GD_BUTTON_UNPRESSED].bitmap = va_arg(ap, Bitmap *);
 384         gi->design[GD_BUTTON_UNPRESSED].x = va_arg(ap, int);
 385         gi->design[GD_BUTTON_UNPRESSED].y = va_arg(ap, int);
 386         break;
 387
 388       case GDI_DESIGN_PRESSED:
 389         gi->design[GD_BUTTON_PRESSED].bitmap = va_arg(ap, Bitmap *);
 390         gi->design[GD_BUTTON_PRESSED].x = va_arg(ap, int);
 391         gi->design[GD_BUTTON_PRESSED].y = va_arg(ap, int);
 392         break;
 393
 394       case GDI_ALT_DESIGN_UNPRESSED:
 395         gi->alt_design[GD_BUTTON_UNPRESSED].bitmap= va_arg(ap, Bitmap *);
 396         gi->alt_design[GD_BUTTON_UNPRESSED].x = va_arg(ap, int);
 397         gi->alt_design[GD_BUTTON_UNPRESSED].y = va_arg(ap, int);
 398         break;
 399
 400       case GDI_ALT_DESIGN_PRESSED:
 401         gi->alt_design[GD_BUTTON_PRESSED].bitmap = va_arg(ap, Bitmap *);
 402         gi->alt_design[GD_BUTTON_PRESSED].x = va_arg(ap, int);
 403         gi->alt_design[GD_BUTTON_PRESSED].y = va_arg(ap, int);
 404         break;
 405
 406       case GDI_BORDER_SIZE:
 407         gi->border.size = va_arg(ap, int);
 408         break;
 409
 410       case GDI_TEXTINPUT_DESIGN_WIDTH:
 411         gi->border.width = va_arg(ap, int);
 412         break;
 413
 414       case GDI_DECORATION_DESIGN:
 415         gi->deco.design.bitmap = va_arg(ap, Bitmap *);
 416         gi->deco.design.x = va_arg(ap, int);
 417         gi->deco.design.y = va_arg(ap, int);
 418         break;
 419
 420       case GDI_DECORATION_POSITION:
 421         gi->deco.x = va_arg(ap, int);
 422         gi->deco.y = va_arg(ap, int);
 423         break;
 424
 425       case GDI_DECORATION_SIZE:
 426         gi->deco.width = va_arg(ap, int);
 427         gi->deco.height = va_arg(ap, int);
 428         break;
 429
 430       case GDI_DECORATION_SHIFTING:
 431         gi->deco.xshift = va_arg(ap, int);
 432         gi->deco.yshift = va_arg(ap, int);
 433         break;
 434
 435       case GDI_EVENT_MASK:
 436         gi->event_mask = va_arg(ap, unsigned long);
 437         break;
 438
 439       case GDI_AREA_SIZE:
 440         gi->drawing.area_xsize = va_arg(ap, int);
 441         gi->drawing.area_ysize = va_arg(ap, int);
 442
 443         /* determine dependent values for drawing area gadget, if needed */
 444         if (gi->width == 0 && gi->height == 0 &&
 445             gi->drawing.item_xsize !=0 && gi->drawing.item_ysize !=0)
 446         {
 447           gi->width = gi->drawing.area_xsize * gi->drawing.item_xsize;
 448           gi->height = gi->drawing.area_ysize * gi->drawing.item_ysize;
 449         }
 450         else if (gi->drawing.item_xsize == 0 && gi->drawing.item_ysize == 0 &&
 451                  gi->width != 0 && gi->height != 0)
 452         {
 453           gi->drawing.item_xsize = gi->width / gi->drawing.area_xsize;
 454           gi->drawing.item_ysize = gi->height / gi->drawing.area_ysize;
 455         }
 456         break;
 457
 458       case GDI_ITEM_SIZE:
 459         gi->drawing.item_xsize = va_arg(ap, int);
 460         gi->drawing.item_ysize = va_arg(ap, int);
 461
 462         /* determine dependent values for drawing area gadget, if needed */
 463         if (gi->width == 0 && gi->height == 0 &&
 464             gi->drawing.area_xsize !=0 && gi->drawing.area_ysize !=0)
 465         {
 466           gi->width = gi->drawing.area_xsize * gi->drawing.item_xsize;
 467           gi->height = gi->drawing.area_ysize * gi->drawing.item_ysize;
 468         }
 469         else if (gi->drawing.area_xsize == 0 && gi->drawing.area_ysize == 0 &&
 470                  gi->width != 0 && gi->height != 0)
 471         {
 472           gi->drawing.area_xsize = gi->width / gi->drawing.item_xsize;
 473           gi->drawing.area_ysize = gi->height / gi->drawing.item_ysize;
 474         }
 475         break;
 476
 477       case GDI_SCROLLBAR_ITEMS_MAX:
 478         gi->scrollbar.items_max = va_arg(ap, int);
 479         break;
 480
 481       case GDI_SCROLLBAR_ITEMS_VISIBLE:
 482         gi->scrollbar.items_visible = va_arg(ap, int);
 483         break;
 484
 485       case GDI_SCROLLBAR_ITEM_POSITION:
 486         gi->scrollbar.item_position = va_arg(ap, int);
 487         break;
 488
 489       case GDI_CALLBACK_INFO:
 490         gi->callback_info = va_arg(ap, gadget_function);
 491         break;
 492
 493       case GDI_CALLBACK_ACTION:
 494         gi->callback_action = va_arg(ap, gadget_function);
 495         break;
 496
 497       default:
 498         Error(ERR_EXIT, "HandleGadgetTags(): unknown tag %d", tag);
 499     }
 500
 501     tag = va_arg(ap, int);      /* read next tag */
 502   }
 503
 504   /* check if gadget complete */
 505   if (gi->type != GD_TYPE_DRAWING_AREA &&
 506       (!gi->design[GD_BUTTON_UNPRESSED].bitmap ||
 507        !gi->design[GD_BUTTON_PRESSED].bitmap))
 508     Error(ERR_EXIT, "gadget incomplete (missing Bitmap)");
 509
 510   /* adjust gadget values in relation to other gadget values */
 511
 512   if (gi->type & GD_TYPE_TEXTINPUT)
 513   {
 514     int font_width = getFontWidth(FS_SMALL, gi->text.font_type);
 515     int font_height = getFontHeight(FS_SMALL, gi->text.font_type);
 516
 517     gi->width = 2 * gi->border.size + (gi->text.size + 1) * font_width;
 518     gi->height = 2 * gi->border.size + font_height;
 519   }
 520
 521   if (gi->type & GD_TYPE_TEXTINPUT_NUMERIC)
 522   {
 523     struct GadgetTextInput *text = &gi->text;
 524     int value = text->number_value;
 525
 526     text->number_value = (value < text->number_min ? text->number_min :
 527                           value > text->number_max ? text->number_max :
 528                           value);
 529
 530     sprintf(text->value, "%d", text->number_value);
 531   }
 532
 533   if (gi->type & GD_TYPE_SCROLLBAR)
 534   {
 535     struct GadgetScrollbar *gs = &gi->scrollbar;
 536
 537     if (gi->width == 0 || gi->height == 0 ||
 538         gs->items_max == 0 || gs->items_visible == 0)
 539       Error(ERR_EXIT, "scrollbar gadget incomplete (missing tags)");
 540
 541     /* calculate internal scrollbar values */
 542     gs->size_max = (gi->type == GD_TYPE_SCROLLBAR_VERTICAL ?
 543                     gi->height : gi->width);
 544     gs->size = gs->size_max * gs->items_visible / gs->items_max;
 545     gs->position = gs->size_max * gs->item_position / gs->items_max;
 546     gs->position_max = gs->size_max - gs->size;
 547     gs->correction = gs->size_max / gs->items_max / 2;
 548
 549     /* finetuning for maximal right/bottom position */
 550     if (gs->item_position == gs->items_max - gs->items_visible)
 551       gs->position = gs->position_max;
 552   }
 553 }
 554
 555 void ModifyGadget(struct GadgetInfo *gi, int first_tag, ...)
 556 {
 557   va_list ap;
 558
 559   va_start(ap, first_tag);
 560   HandleGadgetTags(gi, first_tag, ap);
 561   va_end(ap);
 562
 563   RedrawGadget(gi);
 564 }
 565
 566 void RedrawGadget(struct GadgetInfo *gi)
 567 {
 568   if (gi->mapped)
 569     DrawGadget(gi, gi->state, DG_DIRECT);
 570 }
 571
 572 struct GadgetInfo *CreateGadget(int first_tag, ...)
 573 {
 574   struct GadgetInfo *new_gadget = checked_malloc(sizeof(struct GadgetInfo));
 575   va_list ap;
 576
 577   /* always start with reliable default values */
 578   memset(new_gadget, 0, sizeof(struct GadgetInfo));     /* zero all fields */
 579   new_gadget->id = getNewGadgetID();
 580   new_gadget->callback_info = default_callback_info;
 581   new_gadget->callback_action = default_callback_action;
 582
 583   va_start(ap, first_tag);
 584   HandleGadgetTags(new_gadget, first_tag, ap);
 585   va_end(ap);
 586
 587   /* insert new gadget into global gadget list */
 588   if (gadget_list_last_entry)
 589   {
 590     gadget_list_last_entry->next = new_gadget;
 591     gadget_list_last_entry = gadget_list_last_entry->next;
 592   }
 593   else
 594     gadget_list_first_entry = gadget_list_last_entry = new_gadget;
 595
 596   return new_gadget;
 597 }
 598
 599 void FreeGadget(struct GadgetInfo *gi)
 600 {
 601   struct GadgetInfo *gi_previous = gadget_list_first_entry;
 602
 603   while (gi_previous && gi_previous->next != gi)
 604     gi_previous = gi_previous->next;
 605
 606   if (gi == gadget_list_first_entry)
 607     gadget_list_first_entry = gi->next;
 608
 609   if (gi == gadget_list_last_entry)
 610     gadget_list_last_entry = gi_previous;
 611
 612   gi_previous->next = gi->next;
 613   free(gi);
 614 }
 615
 616 static void CheckRangeOfNumericInputGadget(struct GadgetInfo *gi)
 617 {
 618   if (gi->type != GD_TYPE_TEXTINPUT_NUMERIC)
 619     return;
 620
 621   gi->text.number_value = atoi(gi->text.value);
 622
 623   if (gi->text.number_value < gi->text.number_min)
 624     gi->text.number_value = gi->text.number_min;
 625   if (gi->text.number_value > gi->text.number_max)
 626     gi->text.number_value = gi->text.number_max;
 627
 628   sprintf(gi->text.value, "%d", gi->text.number_value);
 629
 630   if (gi->text.cursor_position < 0)
 631     gi->text.cursor_position = 0;
 632   else if (gi->text.cursor_position > strlen(gi->text.value))
 633     gi->text.cursor_position = strlen(gi->text.value);
 634 }
 635
 636 /* global pointer to gadget actually in use (when mouse button pressed) */
 637 static struct GadgetInfo *last_gi = NULL;
 638
 639 static void MapGadgetExt(struct GadgetInfo *gi, boolean redraw)
 640 {
 641   if (gi == NULL || gi->mapped)
 642     return;
 643
 644   gi->mapped = TRUE;
 645
 646   if (redraw)
 647     DrawGadget(gi, DG_UNPRESSED, DG_BUFFERED);
 648 }
 649
 650 void MapGadget(struct GadgetInfo *gi)
 651 {
 652   MapGadgetExt(gi, TRUE);
 653 }
 654
 655 void UnmapGadget(struct GadgetInfo *gi)
 656 {
 657   if (gi == NULL || !gi->mapped)
 658     return;
 659
 660   gi->mapped = FALSE;
 661
 662   if (gi == last_gi)
 663     last_gi = NULL;
 664 }
 665
 666 #define MAX_NUM_GADGETS         1024
 667 #define MULTIMAP_UNMAP          (1 << 0)
 668 #define MULTIMAP_REMAP          (1 << 1)
 669 #define MULTIMAP_REDRAW         (1 << 2)
 670 #define MULTIMAP_PLAYFIELD      (1 << 3)
 671 #define MULTIMAP_DOOR_1         (1 << 4)
 672 #define MULTIMAP_DOOR_2         (1 << 5)
 673 #define MULTIMAP_ALL            (MULTIMAP_PLAYFIELD | \
 674                                  MULTIMAP_DOOR_1 | \
 675                                  MULTIMAP_DOOR_2)
 676
 677 static void MultiMapGadgets(int mode)
 678 {
 679   struct GadgetInfo *gi = gadget_list_first_entry;
 680   static boolean map_state[MAX_NUM_GADGETS];
 681   int map_count = 0;
 682
 683   while (gi)
 684   {
 685     if ((mode & MULTIMAP_PLAYFIELD &&
 686          gi->x < gfx.sx + gfx.sxsize) ||
 687         (mode & MULTIMAP_DOOR_1 &&
 688          gi->x >= gfx.dx && gi->y < gfx.dy + gfx.dysize) ||
 689         (mode & MULTIMAP_DOOR_2 &&
 690          gi->x >= gfx.dx && gi->y > gfx.dy + gfx.dysize) ||
 691         (mode & MULTIMAP_ALL) == MULTIMAP_ALL)
 692     {
 693       if (mode & MULTIMAP_UNMAP)
 694       {
 695         map_state[map_count++ % MAX_NUM_GADGETS] = gi->mapped;
 696         UnmapGadget(gi);
 697       }
 698       else
 699       {
 700         if (map_state[map_count++ % MAX_NUM_GADGETS])
 701           MapGadgetExt(gi, (mode & MULTIMAP_REDRAW));
 702       }
 703     }
 704
 705     gi = gi->next;
 706   }
 707 }
 708
 709 void UnmapAllGadgets()
 710 {
 711   MultiMapGadgets(MULTIMAP_ALL | MULTIMAP_UNMAP);
 712 }
 713
 714 void RemapAllGadgets()
 715 {
 716   MultiMapGadgets(MULTIMAP_ALL | MULTIMAP_REMAP);
 717 }
 718
 719 boolean anyTextGadgetActive()
 720 {
 721   return (last_gi && last_gi->type & GD_TYPE_TEXTINPUT && last_gi->mapped);
 722 }
 723
 724 void ClickOnGadget(struct GadgetInfo *gi, int button)
 725 {
 726   /* simulate releasing mouse button over last gadget, if still pressed */
 727   if (button_status)
 728     HandleGadgets(-1, -1, 0);
 729
 730   /* simulate pressing mouse button over specified gadget */
 731   HandleGadgets(gi->x, gi->y, button);
 732
 733   /* simulate releasing mouse button over specified gadget */
 734   HandleGadgets(gi->x, gi->y, 0);
 735 }
 736
 737 void HandleGadgets(int mx, int my, int button)
 738 {
 739   static struct GadgetInfo *last_info_gi = NULL;
 740   static unsigned long pressed_delay = 0;
 741   static int last_button = 0;
 742   static int last_mx = 0, last_my = 0;
 743   int scrollbar_mouse_pos = 0;
 744   struct GadgetInfo *new_gi, *gi;
 745   boolean press_event;
 746   boolean release_event;
 747   boolean mouse_moving;
 748   boolean gadget_pressed;
 749   boolean gadget_pressed_repeated;
 750   boolean gadget_moving;
 751   boolean gadget_moving_inside;
 752   boolean gadget_moving_off_borders;
 753   boolean gadget_released;
 754   boolean gadget_released_inside;
 755   boolean gadget_released_off_borders;
 756   boolean changed_position = FALSE;
 757
 758   /* check if there are any gadgets defined */
 759   if (gadget_list_first_entry == NULL)
 760     return;
 761
 762   /* check which gadget is under the mouse pointer */
 763   new_gi = getGadgetInfoFromMousePosition(mx, my);
 764
 765   /* check if button state has changed since last invocation */
 766   press_event = (button != 0 && last_button == 0);
 767   release_event = (button == 0 && last_button != 0);
 768   last_button = button;
 769
 770   /* check if mouse has been moved since last invocation */
 771   mouse_moving = ((mx != last_mx || my != last_my) && motion_status);
 772   last_mx = mx;
 773   last_my = my;
 774
 775   /* special treatment for text and number input gadgets */
 776   if (anyTextGadgetActive() && button != 0 && !motion_status)
 777   {
 778     struct GadgetInfo *gi = last_gi;
 779
 780     if (new_gi == last_gi)
 781     {
 782       /* if mouse button pressed inside activated text gadget, set cursor */
 783       gi->text.cursor_position =
 784         (mx - gi->x - gi->border.size) /
 785         getFontWidth(FS_SMALL, gi->text.font_type);
 786
 787       if (gi->text.cursor_position < 0)
 788         gi->text.cursor_position = 0;
 789       else if (gi->text.cursor_position > strlen(gi->text.value))
 790         gi->text.cursor_position = strlen(gi->text.value);
 791
 792       DrawGadget(gi, DG_PRESSED, DG_DIRECT);
 793     }
 794     else
 795     {
 796       /* if mouse button pressed outside text input gadget, deactivate it */
 797       CheckRangeOfNumericInputGadget(gi);
 798       DrawGadget(gi, DG_UNPRESSED, DG_DIRECT);
 799
 800       gi->event.type = GD_EVENT_TEXT_LEAVING;
 801
 802       if (gi->event_mask & GD_EVENT_TEXT_LEAVING)
 803         gi->callback_action(gi);
 804
 805       last_gi = NULL;
 806     }
 807   }
 808
 809   gadget_pressed =
 810     (button != 0 && last_gi == NULL && new_gi != NULL && press_event);
 811   gadget_pressed_repeated =
 812     (button != 0 && last_gi != NULL && new_gi == last_gi);
 813
 814   gadget_released =             (release_event && last_gi != NULL);
 815   gadget_released_inside =      (gadget_released && new_gi == last_gi);
 816   gadget_released_off_borders = (gadget_released && new_gi != last_gi);
 817
 818   gadget_moving =             (button != 0 && last_gi != NULL && mouse_moving);
 819   gadget_moving_inside =      (gadget_moving && new_gi == last_gi);
 820   gadget_moving_off_borders = (gadget_moving && new_gi != last_gi);
 821
 822   /* if new gadget pressed, store this gadget  */
 823   if (gadget_pressed)
 824     last_gi = new_gi;
 825
 826   /* 'gi' is actually handled gadget */
 827   gi = last_gi;
 828
 829   /* if gadget is scrollbar, choose mouse position value */
 830   if (gi && gi->type & GD_TYPE_SCROLLBAR)
 831     scrollbar_mouse_pos =
 832       (gi->type == GD_TYPE_SCROLLBAR_HORIZONTAL ? mx - gi->x : my - gi->y);
 833
 834   /* if mouse button released, no gadget needs to be handled anymore */
 835   if (button == 0 && last_gi && !(last_gi->type & GD_TYPE_TEXTINPUT))
 836     last_gi = NULL;
 837
 838   /* modify event position values even if no gadget is pressed */
 839   if (button == 0 && !release_event)
 840     gi = new_gi;
 841
 842   if (gi)
 843   {
 844     int last_x = gi->event.x;
 845     int last_y = gi->event.y;
 846
 847     gi->event.x = mx - gi->x;
 848     gi->event.y = my - gi->y;
 849
 850     if (gi->type == GD_TYPE_DRAWING_AREA)
 851     {
 852       gi->event.x /= gi->drawing.item_xsize;
 853       gi->event.y /= gi->drawing.item_ysize;
 854
 855       if (last_x != gi->event.x || last_y != gi->event.y)
 856         changed_position = TRUE;
 857     }
 858   }
 859
 860   /* handle gadget popup info text */
 861   if (last_info_gi != new_gi ||
 862       (new_gi && new_gi->type == GD_TYPE_DRAWING_AREA && changed_position))
 863   {
 864     if (new_gi != NULL && (button == 0 || new_gi == last_gi))
 865     {
 866       new_gi->event.type = GD_EVENT_INFO_ENTERING;
 867       new_gi->callback_info(new_gi);
 868     }
 869     else if (last_info_gi != NULL)
 870     {
 871       last_info_gi->event.type = GD_EVENT_INFO_LEAVING;
 872       last_info_gi->callback_info(last_info_gi);
 873
 874 #if 0
 875       default_callback_info(NULL);
 876
 877       printf("It seems that we are leaving gadget [%s]!\n",
 878              (last_info_gi != NULL &&
 879               last_info_gi->info_text != NULL ?
 880               last_info_gi->info_text : ""));
 881 #endif
 882     }
 883
 884     last_info_gi = new_gi;
 885   }
 886
 887   if (gadget_pressed)
 888   {
 889     if (gi->type == GD_TYPE_CHECK_BUTTON)
 890     {
 891       gi->checked = !gi->checked;
 892     }
 893     else if (gi->type == GD_TYPE_RADIO_BUTTON)
 894     {
 895       struct GadgetInfo *rgi = gadget_list_first_entry;
 896
 897       while (rgi)
 898       {
 899         if (rgi->mapped &&
 900             rgi->type == GD_TYPE_RADIO_BUTTON &&
 901             rgi->radio_nr == gi->radio_nr &&
 902             rgi != gi)
 903         {
 904           rgi->checked = FALSE;
 905           DrawGadget(rgi, DG_UNPRESSED, DG_DIRECT);
 906         }
 907
 908         rgi = rgi->next;
 909       }
 910
 911       gi->checked = TRUE;
 912     }
 913     else if (gi->type & GD_TYPE_SCROLLBAR)
 914     {
 915       int mpos, gpos;
 916
 917       if (gi->type == GD_TYPE_SCROLLBAR_HORIZONTAL)
 918       {
 919         mpos = mx;
 920         gpos = gi->x;
 921       }
 922       else
 923       {
 924         mpos = my;
 925         gpos = gi->y;
 926       }
 927
 928       if (mpos >= gpos + gi->scrollbar.position &&
 929           mpos < gpos + gi->scrollbar.position + gi->scrollbar.size)
 930       {
 931         /* drag scrollbar */
 932         gi->scrollbar.drag_position =
 933           scrollbar_mouse_pos - gi->scrollbar.position;
 934       }
 935       else
 936       {
 937         /* click scrollbar one scrollbar length up/left or down/right */
 938
 939         struct GadgetScrollbar *gs = &gi->scrollbar;
 940         int old_item_position = gs->item_position;
 941
 942         changed_position = FALSE;
 943
 944         gs->item_position +=
 945           gs->items_visible * (mpos < gpos + gi->scrollbar.position ? -1 : +1);
 946
 947         if (gs->item_position < 0)
 948           gs->item_position = 0;
 949         if (gs->item_position > gs->items_max - gs->items_visible)
 950           gs->item_position = gs->items_max - gs->items_visible;
 951
 952         if (old_item_position != gs->item_position)
 953         {
 954           gi->event.item_position = gs->item_position;
 955           changed_position = TRUE;
 956         }
 957
 958         ModifyGadget(gi, GDI_SCROLLBAR_ITEM_POSITION, gs->item_position,
 959                      GDI_END);
 960
 961         gi->state = GD_BUTTON_UNPRESSED;
 962         gi->event.type = GD_EVENT_MOVING;
 963         gi->event.off_borders = FALSE;
 964
 965         if (gi->event_mask & GD_EVENT_MOVING && changed_position)
 966           gi->callback_action(gi);
 967
 968         /* don't handle this scrollbar anymore while mouse button pressed */
 969         last_gi = NULL;
 970
 971         return;
 972       }
 973     }
 974
 975     DrawGadget(gi, DG_PRESSED, DG_DIRECT);
 976
 977     gi->state = GD_BUTTON_PRESSED;
 978     gi->event.type = GD_EVENT_PRESSED;
 979     gi->event.button = button;
 980     gi->event.off_borders = FALSE;
 981
 982     /* initialize delay counter */
 983     DelayReached(&pressed_delay, 0);
 984
 985     if (gi->event_mask & GD_EVENT_PRESSED)
 986       gi->callback_action(gi);
 987   }
 988
 989   if (gadget_pressed_repeated)
 990   {
 991     gi->event.type = GD_EVENT_PRESSED;
 992
 993     if (gi->event_mask & GD_EVENT_REPEATED &&
 994         DelayReached(&pressed_delay, GADGET_FRAME_DELAY))
 995       gi->callback_action(gi);
 996   }
 997
 998   if (gadget_moving)
 999   {
1000     if (gi->type & GD_TYPE_BUTTON)
1001     {
1002       if (gadget_moving_inside && gi->state == GD_BUTTON_UNPRESSED)
1003         DrawGadget(gi, DG_PRESSED, DG_DIRECT);
1004       else if (gadget_moving_off_borders && gi->state == GD_BUTTON_PRESSED)
1005         DrawGadget(gi, DG_UNPRESSED, DG_DIRECT);
1006     }
1007
1008     if (gi->type & GD_TYPE_SCROLLBAR)
1009     {
1010       struct GadgetScrollbar *gs = &gi->scrollbar;
1011       int old_item_position = gs->item_position;
1012
1013       gs->position = scrollbar_mouse_pos - gs->drag_position;
1014
1015       if (gs->position < 0)
1016         gs->position = 0;
1017       if (gs->position > gs->position_max)
1018         gs->position = gs->position_max;
1019
1020       gs->item_position =
1021         gs->items_max * (gs->position + gs->correction) / gs->size_max;
1022
1023       if (gs->item_position < 0)
1024         gs->item_position = 0;
1025       if (gs->item_position > gs->items_max - 1)
1026         gs->item_position = gs->items_max - 1;
1027
1028       if (old_item_position != gs->item_position)
1029       {
1030         gi->event.item_position = gs->item_position;
1031         changed_position = TRUE;
1032       }
1033
1034       DrawGadget(gi, DG_PRESSED, DG_DIRECT);
1035     }
1036
1037     gi->state = (gadget_moving_inside || gi->type & GD_TYPE_SCROLLBAR ?
1038                  GD_BUTTON_PRESSED : GD_BUTTON_UNPRESSED);
1039     gi->event.type = GD_EVENT_MOVING;
1040     gi->event.off_borders = gadget_moving_off_borders;
1041
1042     if (gi->event_mask & GD_EVENT_MOVING && changed_position &&
1043         (gadget_moving_inside || gi->event_mask & GD_EVENT_OFF_BORDERS))
1044       gi->callback_action(gi);
1045   }
1046
1047   if (gadget_released_inside)
1048   {
1049     if (!(gi->type & GD_TYPE_TEXTINPUT))
1050       DrawGadget(gi, DG_UNPRESSED, DG_DIRECT);
1051
1052     gi->state = GD_BUTTON_UNPRESSED;
1053     gi->event.type = GD_EVENT_RELEASED;
1054
1055     if (gi->event_mask & GD_EVENT_RELEASED)
1056       gi->callback_action(gi);
1057   }
1058
1059   if (gadget_released_off_borders)
1060   {
1061     if (gi->type & GD_TYPE_SCROLLBAR)
1062       DrawGadget(gi, DG_UNPRESSED, DG_DIRECT);
1063
1064     gi->event.type = GD_EVENT_RELEASED;
1065
1066     if (gi->event_mask & GD_EVENT_RELEASED &&
1067         gi->event_mask & GD_EVENT_OFF_BORDERS)
1068       gi->callback_action(gi);
1069   }
1070 }
1071
1072 void HandleGadgetsKeyInput(Key key)
1073 {
1074   struct GadgetInfo *gi = last_gi;
1075   char text[MAX_GADGET_TEXTSIZE];
1076   int text_length;
1077   int cursor_pos;
1078   char letter;
1079   boolean legal_letter;
1080
1081   if (gi == NULL || !(gi->type & GD_TYPE_TEXTINPUT) || !gi->mapped)
1082     return;
1083
1084   text_length = strlen(gi->text.value);
1085   cursor_pos = gi->text.cursor_position;
1086   letter = getCharFromKey(key);
1087   legal_letter = (gi->type == GD_TYPE_TEXTINPUT_NUMERIC ?
1088                   letter >= '0' && letter <= '9' :
1089                   letter != 0);
1090
1091   if (legal_letter && text_length < gi->text.size)
1092   {
1093     strcpy(text, gi->text.value);
1094     strcpy(&gi->text.value[cursor_pos + 1], &text[cursor_pos]);
1095     gi->text.value[cursor_pos] = letter;
1096     gi->text.cursor_position++;
1097     DrawGadget(gi, DG_PRESSED, DG_DIRECT);
1098   }
1099   else if (key == KSYM_Left && cursor_pos > 0)
1100   {
1101     gi->text.cursor_position--;
1102     DrawGadget(gi, DG_PRESSED, DG_DIRECT);
1103   }
1104   else if (key == KSYM_Right && cursor_pos < text_length)
1105   {
1106     gi->text.cursor_position++;
1107     DrawGadget(gi, DG_PRESSED, DG_DIRECT);
1108   }
1109   else if (key == KSYM_BackSpace && cursor_pos > 0)
1110   {
1111     strcpy(text, gi->text.value);
1112     strcpy(&gi->text.value[cursor_pos - 1], &text[cursor_pos]);
1113     gi->text.cursor_position--;
1114     DrawGadget(gi, DG_PRESSED, DG_DIRECT);
1115   }
1116   else if (key == KSYM_Delete && cursor_pos < text_length)
1117   {
1118     strcpy(text, gi->text.value);
1119     strcpy(&gi->text.value[cursor_pos], &text[cursor_pos + 1]);
1120     DrawGadget(gi, DG_PRESSED, DG_DIRECT);
1121   }
1122   else if (key == KSYM_Return)
1123   {
1124     CheckRangeOfNumericInputGadget(gi);
1125     DrawGadget(gi, DG_UNPRESSED, DG_DIRECT);
1126
1127     gi->event.type = GD_EVENT_TEXT_RETURN;
1128
1129     if (gi->event_mask & GD_EVENT_TEXT_RETURN)
1130       gi->callback_action(gi);
1131
1132     last_gi = NULL;
1133   }
1134 }