src/libgame/gadgets.c

   1 // ============================================================================
   2 // Artsoft Retro-Game Library
   3 // ----------------------------------------------------------------------------
   4 // (c) 1995-2014 by Artsoft Entertainment
   5 //                  Holger Schemel
   6 //                  info@artsoft.org
   7 //                  http://www.artsoft.org/
   8 // ----------------------------------------------------------------------------
   9 // gadgets.c
  10 // ============================================================================
  11
  12 #include <stdarg.h>
  13 #include <string.h>
  14
  15 #include "gadgets.h"
  16 #include "image.h"
  17 #include "text.h"
  18 #include "misc.h"
  19
  20
  21 // values for DrawGadget()
  22 #define DG_UNPRESSED            0
  23 #define DG_PRESSED              1
  24
  25 #define DG_BUFFERED             0
  26 #define DG_DIRECT               1
  27
  28 #define OPTION_TEXT_SELECTABLE(g, t)                                    \
  29   (t[0] != g->selectbox.char_unselectable &&                            \
  30    t[0] != '\0' &&                                                      \
  31    !strEqual(t, " "))
  32 #define CURRENT_OPTION_SELECTABLE(g)                                    \
  33   OPTION_TEXT_SELECTABLE(g, g->selectbox.options[g->selectbox.current_index].text)
  34
  35
  36 static struct GadgetInfo *gadget_list_first_entry = NULL;
  37 static struct GadgetInfo *gadget_list_last_entry = NULL;
  38 static struct GadgetInfo *last_info_gi = NULL;
  39 static int next_free_gadget_id = 1;
  40 static boolean gadget_id_wrapped = FALSE;
  41
  42 static void (*PlayGadgetSoundActivating)(void) = NULL;
  43 static void (*PlayGadgetSoundSelecting)(void) = NULL;
  44
  45
  46 void InitGadgetsSoundCallback(void (*activating_function)(void),
  47                               void (*selecting_function)(void))
  48 {
  49   PlayGadgetSoundActivating = activating_function;
  50   PlayGadgetSoundSelecting = selecting_function;
  51 }
  52
  53 static struct GadgetInfo *getGadgetInfoFromGadgetID(int id)
  54 {
  55   struct GadgetInfo *gi = gadget_list_first_entry;
  56
  57   while (gi && gi->id != id)
  58     gi = gi->next;
  59
  60   return gi;
  61 }
  62
  63 static int getNewGadgetID(void)
  64 {
  65   int id = next_free_gadget_id++;
  66
  67   if (next_free_gadget_id <= 0)         // counter overrun
  68   {
  69     gadget_id_wrapped = TRUE;           // now we must check each ID
  70     next_free_gadget_id = 0;
  71   }
  72
  73   if (gadget_id_wrapped)
  74   {
  75     next_free_gadget_id++;
  76     while (getGadgetInfoFromGadgetID(next_free_gadget_id) != NULL)
  77       next_free_gadget_id++;
  78   }
  79
  80   if (next_free_gadget_id <= 0)         // cannot get new gadget id
  81     Error(ERR_EXIT, "too much gadgets -- this should not happen");
  82
  83   return id;
  84 }
  85
  86 static struct GadgetInfo *getGadgetInfoFromMousePosition(int mx, int my,
  87                                                          int button)
  88 {
  89   struct GadgetInfo *gi;
  90
  91   // first check for scrollbars in case of mouse scroll wheel button events
  92   if (IS_WHEEL_BUTTON(button))
  93   {
  94     // real horizontal wheel or vertical wheel with modifier key pressed
  95     boolean check_horizontal = (IS_WHEEL_BUTTON_HORIZONTAL(button) ||
  96                                 GetKeyModState() & KMOD_Shift);
  97
  98     // check for the first active scrollbar directly under the mouse pointer
  99     for (gi = gadget_list_first_entry; gi != NULL; gi = gi->next)
 100     {
 101       if (gi->mapped && gi->active &&
 102           (gi->type & GD_TYPE_SCROLLBAR) &&
 103           mx >= gi->x && mx < gi->x + gi->width &&
 104           my >= gi->y && my < gi->y + gi->height)
 105         return gi;
 106     }
 107
 108     // check for the first active scrollbar with matching mouse wheel area
 109     for (gi = gadget_list_first_entry; gi != NULL; gi = gi->next)
 110     {
 111       if (gi->mapped && gi->active &&
 112           ((gi->type & GD_TYPE_SCROLLBAR_HORIZONTAL && check_horizontal) ||
 113            (gi->type & GD_TYPE_SCROLLBAR_VERTICAL && !check_horizontal)) &&
 114           mx >= gi->wheelarea.x && mx < gi->wheelarea.x + gi->wheelarea.width &&
 115           my >= gi->wheelarea.y && my < gi->wheelarea.y + gi->wheelarea.height)
 116         return gi;
 117     }
 118
 119     // no active scrollbar found -- ignore this scroll wheel button event
 120     return NULL;
 121   }
 122
 123   // open selectboxes may overlap other active gadgets, so check them first
 124   for (gi = gadget_list_first_entry; gi != NULL; gi = gi->next)
 125   {
 126     if (gi->mapped && gi->active &&
 127         gi->type & GD_TYPE_SELECTBOX && gi->selectbox.open &&
 128         mx >= gi->selectbox.x && mx < gi->selectbox.x + gi->selectbox.width &&
 129         my >= gi->selectbox.y && my < gi->selectbox.y + gi->selectbox.height)
 130       return gi;
 131   }
 132
 133   // check all other gadgets
 134   for (gi = gadget_list_first_entry; gi != NULL; gi = gi->next)
 135   {
 136     if (gi->mapped && gi->active &&
 137         mx >= gi->x && mx < gi->x + gi->width &&
 138         my >= gi->y && my < gi->y + gi->height)
 139       return gi;
 140   }
 141
 142   return NULL;
 143 }
 144
 145 static void setTextAreaCursorExt(struct GadgetInfo *gi, boolean set_cursor_pos)
 146 {
 147   char *text = gi->textarea.value;
 148   int area_xsize = gi->textarea.xsize;
 149   int area_ysize = gi->textarea.ysize;
 150   int cursor_position = gi->textarea.cursor_position;
 151   int cursor_x = gi->textarea.cursor_x;
 152   int cursor_y = gi->textarea.cursor_y;
 153   int pos = 0;
 154   int x = 0;
 155   int y = 0;
 156
 157   while (*text)
 158   {
 159     if (set_cursor_pos)         // x/y => position
 160     {
 161       if (y == cursor_y && (x == cursor_x || (x < cursor_x && *text == '\n')))
 162         break;
 163     }
 164     else                        // position => x/y
 165     {
 166       if (pos == cursor_position)
 167         break;
 168     }
 169
 170     if (x + 1 >= area_xsize || *text == '\n')
 171     {
 172       if (y + 1 >= area_ysize)
 173         break;
 174
 175       x = 0;
 176       y++;
 177     }
 178     else
 179       x++;
 180
 181     text++;
 182     pos++;
 183   }
 184
 185   gi->textarea.cursor_x = x;
 186   gi->textarea.cursor_y = y;
 187   gi->textarea.cursor_x_preferred = x;
 188   gi->textarea.cursor_position = pos;
 189 }
 190
 191 static void setTextAreaCursorXY(struct GadgetInfo *gi, int x, int y)
 192 {
 193   gi->textarea.cursor_x = x;
 194   gi->textarea.cursor_y = y;
 195
 196   setTextAreaCursorExt(gi, TRUE);
 197 }
 198
 199 static void setTextAreaCursorPosition(struct GadgetInfo *gi, int pos)
 200 {
 201   gi->textarea.cursor_position = pos;
 202
 203   setTextAreaCursorExt(gi, FALSE);
 204 }
 205
 206 static void default_callback_info(void *ptr)
 207 {
 208   return;
 209 }
 210
 211 static void default_callback_action(void *ptr)
 212 {
 213   return;
 214 }
 215
 216 static void DoGadgetCallbackAction(struct GadgetInfo *gi, boolean changed)
 217 {
 218   if (changed || gi->callback_action_always)
 219     gi->callback_action(gi);
 220 }
 221
 222 static void DrawGadget(struct GadgetInfo *gi, boolean pressed, boolean direct)
 223 {
 224   struct GadgetDesign *gd;
 225   int state = (pressed ? GD_BUTTON_PRESSED : GD_BUTTON_UNPRESSED);
 226   boolean redraw_selectbox = FALSE;
 227
 228   if (gi == NULL || gi->deactivated)
 229     return;
 230
 231   if (gi->overlay_touch_button)         // will be drawn later (as texture)
 232     return;
 233
 234   gd = (!gi->active ? &gi->alt_design[state] :
 235         gi->checked ? &gi->alt_design[state] : &gi->design[state]);
 236
 237   switch (gi->type)
 238   {
 239     case GD_TYPE_NORMAL_BUTTON:
 240     case GD_TYPE_CHECK_BUTTON:
 241     case GD_TYPE_RADIO_BUTTON:
 242
 243       BlitBitmapOnBackground(gd->bitmap, drawto,
 244                              gd->x, gd->y, gi->width, gi->height,
 245                              gi->x, gi->y);
 246
 247       if (gi->deco.design.bitmap)
 248       {
 249         // make sure that decoration does not overlap gadget border
 250         int deco_x = gi->deco.x + (pressed ? gi->deco.xshift : 0);
 251         int deco_y = gi->deco.y + (pressed ? gi->deco.yshift : 0);
 252         int deco_width  = MIN(gi->deco.width,  gi->width  - deco_x);
 253         int deco_height = MIN(gi->deco.height, gi->height - deco_y);
 254
 255         if (gi->deco.masked)
 256           BlitBitmapMasked(gi->deco.design.bitmap, drawto,
 257                            gi->deco.design.x, gi->deco.design.y,
 258                            deco_width, deco_height,
 259                            gi->x + deco_x, gi->y + deco_y);
 260         else
 261           BlitBitmap(gi->deco.design.bitmap, drawto,
 262                      gi->deco.design.x, gi->deco.design.y,
 263                      deco_width, deco_height,
 264                      gi->x + deco_x, gi->y + deco_y);
 265       }
 266
 267       break;
 268
 269     case GD_TYPE_TEXT_BUTTON:
 270       {
 271         int i;
 272         int font_nr = (gi->active ? gi->font_active : gi->font);
 273         int font_width = getFontWidth(font_nr);
 274         int border_x = gi->border.xsize;
 275         int border_y = gi->border.ysize;
 276         int text_size = strlen(gi->textbutton.value);
 277         int text_start = (gi->width - text_size * font_width) / 2;
 278
 279         // left part of gadget
 280         BlitBitmapOnBackground(gd->bitmap, drawto, gd->x, gd->y,
 281                                border_x, gi->height, gi->x, gi->y);
 282
 283         // middle part of gadget
 284         for (i=0; i < gi->textbutton.size; i++)
 285           BlitBitmapOnBackground(gd->bitmap, drawto, gd->x + border_x, gd->y,
 286                                  font_width, gi->height,
 287                                  gi->x + border_x + i * font_width, gi->y);
 288
 289         // right part of gadget
 290         BlitBitmapOnBackground(gd->bitmap, drawto,
 291                                gd->x + gi->border.width - border_x, gd->y,
 292                                border_x, gi->height,
 293                                gi->x + gi->width - border_x, gi->y);
 294
 295         // gadget text value
 296         DrawTextExt(drawto,
 297                     gi->x + text_start + (pressed ? gi->deco.xshift : 0),
 298                     gi->y + border_y   + (pressed ? gi->deco.yshift : 0),
 299                     gi->textbutton.value, font_nr, BLIT_MASKED);
 300       }
 301       break;
 302
 303     case GD_TYPE_TEXT_INPUT_ALPHANUMERIC:
 304     case GD_TYPE_TEXT_INPUT_NUMERIC:
 305       {
 306         int i;
 307         char cursor_letter;
 308         char cursor_string[2];
 309         char text[MAX_GADGET_TEXTSIZE + 1];
 310         int font_nr = (pressed ? gi->font_active : gi->font);
 311         int font_width = getFontWidth(font_nr);
 312         int border_x = gi->border.xsize;
 313         int border_y = gi->border.ysize;
 314
 315         // left part of gadget
 316         BlitBitmapOnBackground(gd->bitmap, drawto, gd->x, gd->y,
 317                                border_x, gi->height, gi->x, gi->y);
 318
 319         // middle part of gadget
 320         for (i=0; i < gi->textinput.size + 1; i++)
 321           BlitBitmapOnBackground(gd->bitmap, drawto, gd->x + border_x, gd->y,
 322                                  font_width, gi->height,
 323                                  gi->x + border_x + i * font_width, gi->y);
 324
 325         // right part of gadget
 326         BlitBitmapOnBackground(gd->bitmap, drawto,
 327                                gd->x + gi->border.width - border_x, gd->y,
 328                                border_x, gi->height,
 329                                gi->x + gi->width - border_x, gi->y);
 330
 331         // set text value
 332         strcpy(text, gi->textinput.value);
 333         strcat(text, " ");
 334
 335         // gadget text value
 336         DrawTextExt(drawto,
 337                     gi->x + border_x, gi->y + border_y, text,
 338                     font_nr, BLIT_MASKED);
 339
 340         cursor_letter = gi->textinput.value[gi->textinput.cursor_position];
 341         cursor_string[0] = (cursor_letter != '\0' ? cursor_letter : ' ');
 342         cursor_string[1] = '\0';
 343
 344         // draw cursor, if active
 345         if (pressed)
 346           DrawTextExt(drawto,
 347                       gi->x + border_x +
 348                       gi->textinput.cursor_position * font_width,
 349                       gi->y + border_y, cursor_string,
 350                       font_nr, BLIT_INVERSE);
 351       }
 352       break;
 353
 354     case GD_TYPE_TEXT_AREA:
 355       {
 356         int i;
 357         char cursor_letter;
 358         char cursor_string[2];
 359         int font_nr = (pressed ? gi->font_active : gi->font);
 360         int font_width = getFontWidth(font_nr);
 361         int font_height = getFontHeight(font_nr);
 362         int border_x = gi->border.xsize;
 363         int border_y = gi->border.ysize;
 364         int gd_height = 2 * border_y + font_height;
 365
 366         // top left part of gadget border
 367         BlitBitmapOnBackground(gd->bitmap, drawto, gd->x, gd->y,
 368                                border_x, border_y, gi->x, gi->y);
 369
 370         // top middle part of gadget border
 371         for (i=0; i < gi->textarea.xsize; i++)
 372           BlitBitmapOnBackground(gd->bitmap, drawto, gd->x + border_x, gd->y,
 373                                  font_width, border_y,
 374                                  gi->x + border_x + i * font_width, gi->y);
 375
 376         // top right part of gadget border
 377         BlitBitmapOnBackground(gd->bitmap, drawto,
 378                                gd->x + gi->border.width - border_x, gd->y,
 379                                border_x, border_y,
 380                                gi->x + gi->width - border_x, gi->y);
 381
 382         // left and right part of gadget border for each row
 383         for (i=0; i < gi->textarea.ysize; i++)
 384         {
 385           BlitBitmapOnBackground(gd->bitmap, drawto, gd->x, gd->y + border_y,
 386                                  border_x, font_height,
 387                                  gi->x, gi->y + border_y + i * font_height);
 388           BlitBitmapOnBackground(gd->bitmap, drawto,
 389                                  gd->x + gi->border.width - border_x,
 390                                  gd->y + border_y,
 391                                  border_x, font_height,
 392                                  gi->x + gi->width - border_x,
 393                                  gi->y + border_y + i * font_height);
 394         }
 395
 396         // bottom left part of gadget border
 397         BlitBitmapOnBackground(gd->bitmap, drawto,
 398                                gd->x, gd->y + gd_height - border_y,
 399                                border_x, border_y,
 400                                gi->x, gi->y + gi->height - border_y);
 401
 402         // bottom middle part of gadget border
 403         for (i=0; i < gi->textarea.xsize; i++)
 404           BlitBitmapOnBackground(gd->bitmap, drawto,
 405                                  gd->x + border_x,
 406                                  gd->y + gd_height - border_y,
 407                                  font_width, border_y,
 408                                  gi->x + border_x + i * font_width,
 409                                  gi->y + gi->height - border_y);
 410
 411         // bottom right part of gadget border
 412         BlitBitmapOnBackground(gd->bitmap, drawto,
 413                                gd->x + gi->border.width - border_x,
 414                                gd->y + gd_height - border_y,
 415                                border_x, border_y,
 416                                gi->x + gi->width - border_x,
 417                                gi->y + gi->height - border_y);
 418
 419         ClearRectangleOnBackground(drawto,
 420                                    gi->x + border_x,
 421                                    gi->y + border_y,
 422                                    gi->width - 2 * border_x,
 423                                    gi->height - 2 * border_y);
 424
 425         // gadget text value
 426         DrawTextBuffer(gi->x + border_x, gi->y + border_y, gi->textarea.value,
 427                        font_nr, gi->textarea.xsize, -1, gi->textarea.ysize, 0,
 428                        BLIT_ON_BACKGROUND, FALSE, FALSE, FALSE);
 429
 430         cursor_letter = gi->textarea.value[gi->textarea.cursor_position];
 431         cursor_string[0] = (cursor_letter != '\0' ? cursor_letter : ' ');
 432         cursor_string[1] = '\0';
 433
 434         // draw cursor, if active
 435         if (pressed)
 436           DrawTextExt(drawto,
 437                       gi->x + border_x + gi->textarea.cursor_x * font_width,
 438                       gi->y + border_y + gi->textarea.cursor_y * font_height,
 439                       cursor_string,
 440                       font_nr, BLIT_INVERSE);
 441       }
 442       break;
 443
 444     case GD_TYPE_SELECTBOX:
 445       {
 446         int i;
 447         char text[MAX_GADGET_TEXTSIZE + 1];
 448         int font_nr_default = (pressed ? gi->font_active : gi->font);
 449         int font_nr = font_nr_default;
 450         int font_width = getFontWidth(font_nr);
 451         int font_height = getFontHeight(font_nr);
 452         int border_x = gi->border.xsize;
 453         int border_y = gi->border.ysize;
 454         int button = gi->border.xsize_selectbutton;
 455         int width_inner = gi->border.width - button - 2 * border_x;
 456         int box_width = gi->selectbox.width;
 457         int box_height = gi->selectbox.height;
 458
 459         // left part of gadget
 460         BlitBitmapOnBackground(gd->bitmap, drawto, gd->x, gd->y,
 461                                border_x, gi->height, gi->x, gi->y);
 462
 463         // middle part of gadget
 464         for (i=0; i < gi->selectbox.size; i++)
 465           BlitBitmapOnBackground(gd->bitmap, drawto, gd->x + border_x, gd->y,
 466                                  font_width, gi->height,
 467                                  gi->x + border_x + i * font_width, gi->y);
 468
 469         // button part of gadget
 470         BlitBitmapOnBackground(gd->bitmap, drawto,
 471                                gd->x + border_x + width_inner, gd->y,
 472                                button, gi->height,
 473                                gi->x + gi->width - border_x - button, gi->y);
 474
 475         // right part of gadget
 476         BlitBitmapOnBackground(gd->bitmap, drawto,
 477                                gd->x + gi->border.width - border_x, gd->y,
 478                                border_x, gi->height,
 479                                gi->x + gi->width - border_x, gi->y);
 480
 481         // set text value
 482         strncpy(text, gi->selectbox.options[gi->selectbox.index].text,
 483                 gi->selectbox.size);
 484         text[gi->selectbox.size] = '\0';
 485
 486         // set font value
 487         font_nr = (OPTION_TEXT_SELECTABLE(gi, text) ? font_nr_default :
 488                    gi->font_unselectable);
 489
 490         // gadget text value
 491         DrawTextExt(drawto, gi->x + border_x, gi->y + border_y, text,
 492                     font_nr, BLIT_MASKED);
 493
 494         if (pressed)
 495         {
 496           if (!gi->selectbox.open)
 497           {
 498             gi->selectbox.open = TRUE;
 499             gi->selectbox.stay_open = FALSE;
 500             gi->selectbox.current_index = gi->selectbox.index;
 501
 502             // save background under selectbox
 503             BlitBitmap(drawto, gfx.field_save_buffer,
 504                        gi->selectbox.x,     gi->selectbox.y,
 505                        gi->selectbox.width, gi->selectbox.height,
 506                        gi->selectbox.x,     gi->selectbox.y);
 507           }
 508
 509           // draw open selectbox
 510
 511           // top left part of gadget border
 512           BlitBitmapOnBackground(gd->bitmap, drawto, gd->x, gd->y,
 513                                  border_x, border_y,
 514                                  gi->selectbox.x, gi->selectbox.y);
 515
 516           // top middle part of gadget border
 517           for (i=0; i < gi->selectbox.size; i++)
 518             BlitBitmapOnBackground(gd->bitmap, drawto, gd->x + border_x, gd->y,
 519                                    font_width, border_y,
 520                                    gi->selectbox.x + border_x + i * font_width,
 521                                    gi->selectbox.y);
 522
 523           // top button part of gadget border
 524           BlitBitmapOnBackground(gd->bitmap, drawto,
 525                                  gd->x + border_x + width_inner, gd->y,
 526                                  button, border_y,
 527                                  gi->selectbox.x + box_width -border_x -button,
 528                                  gi->selectbox.y);
 529
 530           // top right part of gadget border
 531           BlitBitmapOnBackground(gd->bitmap, drawto,
 532                                  gd->x + gi->border.width - border_x, gd->y,
 533                                  border_x, border_y,
 534                                  gi->selectbox.x + box_width - border_x,
 535                                  gi->selectbox.y);
 536
 537           // left and right part of gadget border for each row
 538           for (i=0; i < gi->selectbox.num_values; i++)
 539           {
 540             BlitBitmapOnBackground(gd->bitmap, drawto, gd->x, gd->y + border_y,
 541                                    border_x, font_height,
 542                                    gi->selectbox.x,
 543                                    gi->selectbox.y + border_y + i*font_height);
 544             BlitBitmapOnBackground(gd->bitmap, drawto,
 545                                    gd->x + gi->border.width - border_x,
 546                                    gd->y + border_y,
 547                                    border_x, font_height,
 548                                    gi->selectbox.x + box_width - border_x,
 549                                    gi->selectbox.y + border_y + i*font_height);
 550           }
 551
 552           // bottom left part of gadget border
 553           BlitBitmapOnBackground(gd->bitmap, drawto,
 554                                  gd->x, gd->y + gi->height - border_y,
 555                                  border_x, border_y,
 556                                  gi->selectbox.x,
 557                                  gi->selectbox.y + box_height - border_y);
 558
 559           // bottom middle part of gadget border
 560           for (i=0; i < gi->selectbox.size; i++)
 561             BlitBitmapOnBackground(gd->bitmap, drawto,
 562                                    gd->x + border_x,
 563                                    gd->y + gi->height - border_y,
 564                                    font_width, border_y,
 565                                    gi->selectbox.x + border_x + i * font_width,
 566                                    gi->selectbox.y + box_height - border_y);
 567
 568           // bottom button part of gadget border
 569           BlitBitmapOnBackground(gd->bitmap, drawto,
 570                                  gd->x + border_x + width_inner,
 571                                  gd->y + gi->height - border_y,
 572                                  button, border_y,
 573                                  gi->selectbox.x + box_width -border_x -button,
 574                                  gi->selectbox.y + box_height - border_y);
 575
 576           // bottom right part of gadget border
 577           BlitBitmapOnBackground(gd->bitmap, drawto,
 578                                  gd->x + gi->border.width - border_x,
 579                                  gd->y + gi->height - border_y,
 580                                  border_x, border_y,
 581                                  gi->selectbox.x + box_width - border_x,
 582                                  gi->selectbox.y + box_height - border_y);
 583
 584           ClearRectangleOnBackground(drawto,
 585                                      gi->selectbox.x + border_x,
 586                                      gi->selectbox.y + border_y,
 587                                      gi->selectbox.width - 2 * border_x,
 588                                      gi->selectbox.height - 2 * border_y);
 589
 590           // selectbox text values
 591           for (i=0; i < gi->selectbox.num_values; i++)
 592           {
 593             int mask_mode = BLIT_MASKED;
 594
 595             strncpy(text, gi->selectbox.options[i].text, gi->selectbox.size);
 596             text[gi->selectbox.size] = '\0';
 597
 598             font_nr = (OPTION_TEXT_SELECTABLE(gi, text) ? font_nr_default :
 599                        gi->font_unselectable);
 600
 601             if (i == gi->selectbox.current_index &&
 602                 OPTION_TEXT_SELECTABLE(gi, text))
 603             {
 604               FillRectangle(drawto,
 605                             gi->selectbox.x + border_x,
 606                             gi->selectbox.y + border_y + i * font_height,
 607                             gi->selectbox.width - 2 * border_x, font_height,
 608                             gi->selectbox.inverse_color);
 609
 610               // prevent use of cursor graphic by drawing at least two chars
 611               strcat(text, "  ");
 612               text[gi->selectbox.size] = '\0';
 613
 614               mask_mode = BLIT_INVERSE;
 615             }
 616
 617             DrawTextExt(drawto,
 618                         gi->selectbox.x + border_x,
 619                         gi->selectbox.y + border_y + i * font_height, text,
 620                         font_nr, mask_mode);
 621           }
 622
 623           redraw_selectbox = TRUE;
 624         }
 625         else if (gi->selectbox.open)
 626         {
 627           gi->selectbox.open = FALSE;
 628
 629           // restore background under selectbox
 630           BlitBitmap(gfx.field_save_buffer, drawto,
 631                      gi->selectbox.x,     gi->selectbox.y,
 632                      gi->selectbox.width, gi->selectbox.height,
 633                      gi->selectbox.x,     gi->selectbox.y);
 634
 635           // redraw closed selectbox
 636           DrawGadget(gi, FALSE, FALSE);
 637
 638           redraw_selectbox = TRUE;
 639         }
 640       }
 641       break;
 642
 643     case GD_TYPE_SCROLLBAR_VERTICAL:
 644       {
 645         int i;
 646         int xpos = gi->x;
 647         int ypos = gi->y + gi->scrollbar.position;
 648         int design_full = gi->width;
 649         int design_body = design_full - 2 * gi->border.ysize;
 650         int size_full = gi->scrollbar.size;
 651         int size_body = size_full - 2 * gi->border.ysize;
 652         int num_steps = size_body / design_body;
 653         int step_size_remain = size_body - num_steps * design_body;
 654
 655         // clear scrollbar area
 656         ClearRectangleOnBackground(backbuffer, gi->x, gi->y,
 657                                    gi->width, gi->height);
 658
 659         // upper part of gadget
 660         BlitBitmapOnBackground(gd->bitmap, drawto,
 661                                gd->x, gd->y,
 662                                gi->width, gi->border.ysize,
 663                                xpos, ypos);
 664
 665         // middle part of gadget
 666         for (i=0; i < num_steps; i++)
 667           BlitBitmapOnBackground(gd->bitmap, drawto,
 668                                  gd->x, gd->y + gi->border.ysize,
 669                                  gi->width, design_body,
 670                                  xpos,
 671                                  ypos + gi->border.ysize + i * design_body);
 672
 673         // remaining middle part of gadget
 674         if (step_size_remain > 0)
 675           BlitBitmapOnBackground(gd->bitmap, drawto,
 676                                  gd->x,  gd->y + gi->border.ysize,
 677                                  gi->width, step_size_remain,
 678                                  xpos,
 679                                  ypos + gi->border.ysize
 680                                  + num_steps * design_body);
 681
 682         // lower part of gadget
 683         BlitBitmapOnBackground(gd->bitmap, drawto,
 684                                gd->x, gd->y + design_full - gi->border.ysize,
 685                                gi->width, gi->border.ysize,
 686                                xpos, ypos + size_full - gi->border.ysize);
 687       }
 688       break;
 689
 690     case GD_TYPE_SCROLLBAR_HORIZONTAL:
 691       {
 692         int i;
 693         int xpos = gi->x + gi->scrollbar.position;
 694         int ypos = gi->y;
 695         int design_full = gi->height;
 696         int design_body = design_full - 2 * gi->border.xsize;
 697         int size_full = gi->scrollbar.size;
 698         int size_body = size_full - 2 * gi->border.xsize;
 699         int num_steps = size_body / design_body;
 700         int step_size_remain = size_body - num_steps * design_body;
 701
 702         // clear scrollbar area
 703         ClearRectangleOnBackground(backbuffer, gi->x, gi->y,
 704                                    gi->width, gi->height);
 705
 706         // left part of gadget
 707         BlitBitmapOnBackground(gd->bitmap, drawto,
 708                                gd->x, gd->y,
 709                                gi->border.xsize, gi->height,
 710                                xpos, ypos);
 711
 712         // middle part of gadget
 713         for (i=0; i < num_steps; i++)
 714           BlitBitmapOnBackground(gd->bitmap, drawto,
 715                                  gd->x + gi->border.xsize, gd->y,
 716                                  design_body, gi->height,
 717                                  xpos + gi->border.xsize + i * design_body,
 718                                  ypos);
 719
 720         // remaining middle part of gadget
 721         if (step_size_remain > 0)
 722           BlitBitmapOnBackground(gd->bitmap, drawto,
 723                                  gd->x + gi->border.xsize, gd->y,
 724                                  step_size_remain, gi->height,
 725                                  xpos + gi->border.xsize
 726                                  + num_steps * design_body,
 727                                  ypos);
 728
 729         // right part of gadget
 730         BlitBitmapOnBackground(gd->bitmap, drawto,
 731                                gd->x + design_full - gi->border.xsize, gd->y,
 732                                gi->border.xsize, gi->height,
 733                                xpos + size_full - gi->border.xsize, ypos);
 734       }
 735       break;
 736
 737     default:
 738       return;
 739   }
 740
 741   // do not use direct gadget drawing anymore; this worked as a speed-up once,
 742   // but would slow things down a lot now the screen is always fully redrawn
 743   direct = FALSE;
 744
 745   if (direct)
 746   {
 747     BlitBitmap(drawto, window,
 748                gi->x, gi->y, gi->width, gi->height, gi->x, gi->y);
 749
 750     if (gi->type == GD_TYPE_SELECTBOX && redraw_selectbox)
 751       BlitBitmap(drawto, window,
 752                  gi->selectbox.x,     gi->selectbox.y,
 753                  gi->selectbox.width, gi->selectbox.height,
 754                  gi->selectbox.x,     gi->selectbox.y);
 755   }
 756   else
 757   {
 758     int x = gi->x;
 759     int y = gi->y;
 760
 761     redraw_mask |= (IN_GFX_FIELD_FULL(x, y) ? REDRAW_FIELD :
 762                     IN_GFX_DOOR_1(x, y) ? REDRAW_DOOR_1 :
 763                     IN_GFX_DOOR_2(x, y) ? REDRAW_DOOR_2 :
 764                     IN_GFX_DOOR_3(x, y) ? REDRAW_DOOR_3 : REDRAW_ALL);
 765   }
 766 }
 767
 768 static void SetGadgetPosition_OverlayTouchButton(struct GadgetInfo *gi)
 769 {
 770   gi->x = gi->orig_x;
 771   gi->y = gi->orig_y;
 772
 773   if (gi->x < 0)
 774     gi->x += video.screen_width;
 775   if (gi->y < 0)
 776     gi->y += video.screen_height;
 777
 778   gi->x -= video.screen_xoffset;
 779   gi->y -= video.screen_yoffset;
 780 }
 781
 782 void SetGadgetsPosition_OverlayTouchButtons(void)
 783 {
 784   struct GadgetInfo *gi;
 785
 786   if (gadget_list_first_entry == NULL)
 787     return;
 788
 789   for (gi = gadget_list_first_entry; gi != NULL; gi = gi->next)
 790     if (gi->overlay_touch_button)
 791       SetGadgetPosition_OverlayTouchButton(gi);
 792 }
 793
 794 static void DrawGadget_OverlayTouchButton(struct GadgetInfo *gi)
 795 {
 796   struct GadgetDesign *gd;
 797   int state = (gi->state ? GD_BUTTON_PRESSED : GD_BUTTON_UNPRESSED);
 798
 799   if (gi == NULL || gi->deactivated)
 800     return;
 801
 802   gd = (!gi->active ? &gi->alt_design[state] :
 803         gi->checked ? &gi->alt_design[state] : &gi->design[state]);
 804
 805   int x = gi->x + video.screen_xoffset;
 806   int y = gi->y + video.screen_yoffset;
 807   int alpha = gi->overlay_touch_button_alpha;
 808   int alpha_max = SDL_ALPHA_OPAQUE;
 809   int alpha_step = ALPHA_FADING_STEPSIZE(alpha_max);
 810
 811   // only show mapped overlay touch buttons if touch screen is really used
 812   if (gi->mapped && runtime.uses_touch_device)
 813   {
 814     if (alpha < alpha_max)
 815       alpha = MIN(alpha + alpha_step, alpha_max);
 816   }
 817   else
 818   {
 819     alpha = MAX(0, alpha - alpha_step);
 820   }
 821
 822   gi->overlay_touch_button_alpha = alpha;
 823
 824   if (alpha == 0)
 825     return;
 826
 827   switch (gi->type)
 828   {
 829     case GD_TYPE_NORMAL_BUTTON:
 830     case GD_TYPE_CHECK_BUTTON:
 831     case GD_TYPE_RADIO_BUTTON:
 832       SDL_SetTextureAlphaMod(gd->bitmap->texture_masked, alpha);
 833       SDL_SetTextureBlendMode(gd->bitmap->texture_masked, SDL_BLENDMODE_BLEND);
 834
 835       BlitToScreenMasked(gd->bitmap, gd->x, gd->y, gi->width, gi->height, x, y);
 836       break;
 837
 838     default:
 839       return;
 840   }
 841 }
 842
 843 void DrawGadgets_OverlayTouchButtons(void)
 844 {
 845   struct GadgetInfo *gi;
 846
 847   if (gadget_list_first_entry == NULL)
 848     return;
 849
 850   for (gi = gadget_list_first_entry; gi != NULL; gi = gi->next)
 851     if (gi->overlay_touch_button)
 852       DrawGadget_OverlayTouchButton(gi);
 853 }
 854
 855 boolean CheckPosition_OverlayTouchButtons(int mx, int my, int button)
 856 {
 857   struct GadgetInfo *gi = getGadgetInfoFromMousePosition(mx, my, button);
 858
 859   return (gi != NULL && gi->overlay_touch_button);
 860 }
 861
 862 static int get_minimal_size_for_numeric_input(int minmax_value)
 863 {
 864   int min_size = 1;     // value needs at least one digit
 865   int i;
 866
 867   // add number of digits needed for absolute value
 868   for (i = 10; i <= ABS(minmax_value); i *= 10)
 869     min_size++;
 870
 871   // if min/max value is negative, add one digit for minus sign
 872   if (minmax_value < 0)
 873     min_size++;
 874
 875   return min_size;
 876 }
 877
 878 static void HandleGadgetTags(struct GadgetInfo *gi, int first_tag, va_list ap)
 879 {
 880   int tag = first_tag;
 881
 882   if (gi == NULL || gi->deactivated)
 883     return;
 884
 885   while (tag != GDI_END)
 886   {
 887     switch (tag)
 888     {
 889       case GDI_IMAGE_ID:
 890         gi->image_id = va_arg(ap, int);
 891         break;
 892
 893       case GDI_CUSTOM_ID:
 894         gi->custom_id = va_arg(ap, int);
 895         break;
 896
 897       case GDI_CUSTOM_TYPE_ID:
 898         gi->custom_type_id = va_arg(ap, int);
 899         break;
 900
 901       case GDI_INFO_TEXT:
 902         {
 903           int max_textsize = MAX_INFO_TEXTSIZE;
 904           char *text = va_arg(ap, char *);
 905
 906           if (text != NULL)
 907             strncpy(gi->info_text, text, max_textsize);
 908           else
 909             max_textsize = 0;
 910
 911           gi->info_text[max_textsize] = '\0';
 912         }
 913         break;
 914
 915       case GDI_X:
 916         gi->x = gi->orig_x = va_arg(ap, int);
 917         break;
 918
 919       case GDI_Y:
 920         gi->y = gi->orig_y = va_arg(ap, int);
 921         break;
 922
 923       case GDI_WIDTH:
 924         gi->width = va_arg(ap, int);
 925         break;
 926
 927       case GDI_HEIGHT:
 928         gi->height = va_arg(ap, int);
 929         break;
 930
 931       case GDI_TYPE:
 932         gi->type = va_arg(ap, unsigned int);
 933         break;
 934
 935       case GDI_STATE:
 936         gi->state = va_arg(ap, unsigned int);
 937         break;
 938
 939       case GDI_ACTIVE:
 940         gi->active = (boolean)va_arg(ap, int);
 941         break;
 942
 943       case GDI_DIRECT_DRAW:
 944         gi->direct_draw = (boolean)va_arg(ap, int);
 945         break;
 946
 947       case GDI_OVERLAY_TOUCH_BUTTON:
 948         gi->overlay_touch_button = (boolean)va_arg(ap, int);
 949         if (gi->overlay_touch_button)
 950           SetGadgetPosition_OverlayTouchButton(gi);
 951         break;
 952
 953       case GDI_CALLBACK_ACTION_ALWAYS:
 954         gi->callback_action_always = (boolean)va_arg(ap, int);
 955         break;
 956
 957       case GDI_CHECKED:
 958         gi->checked = (boolean)va_arg(ap, int);
 959         break;
 960
 961       case GDI_RADIO_NR:
 962         gi->radio_nr = va_arg(ap, unsigned int);
 963         break;
 964
 965       case GDI_NUMBER_VALUE:
 966         gi->textinput.number_value = va_arg(ap, int);
 967         sprintf(gi->textinput.value, "%d", gi->textinput.number_value);
 968         strcpy(gi->textinput.last_value, gi->textinput.value);
 969         gi->textinput.cursor_position = strlen(gi->textinput.value);
 970         break;
 971
 972       case GDI_NUMBER_MIN:
 973         gi->textinput.number_min = va_arg(ap, int);
 974         if (gi->textinput.number_value < gi->textinput.number_min)
 975         {
 976           gi->textinput.number_value = gi->textinput.number_min;
 977           sprintf(gi->textinput.value, "%d", gi->textinput.number_value);
 978           strcpy(gi->textinput.last_value, gi->textinput.value);
 979         }
 980         break;
 981
 982       case GDI_NUMBER_MAX:
 983         gi->textinput.number_max = va_arg(ap, int);
 984         if (gi->textinput.number_value > gi->textinput.number_max)
 985         {
 986           gi->textinput.number_value = gi->textinput.number_max;
 987           sprintf(gi->textinput.value, "%d", gi->textinput.number_value);
 988           strcpy(gi->textinput.last_value, gi->textinput.value);
 989         }
 990         break;
 991
 992       case GDI_TEXT_VALUE:
 993         {
 994           int max_textsize = MAX_GADGET_TEXTSIZE;
 995
 996           if (gi->textinput.size)
 997             max_textsize = MIN(gi->textinput.size, MAX_GADGET_TEXTSIZE);
 998
 999           strncpy(gi->textinput.value, va_arg(ap, char *), max_textsize);
1000           strcpy(gi->textinput.last_value, gi->textinput.value);
1001
1002           gi->textinput.value[max_textsize] = '\0';
1003           gi->textinput.cursor_position = strlen(gi->textinput.value);
1004
1005           // same tag also used for other gadget definitions
1006           strcpy(gi->textbutton.value, gi->textinput.value);
1007           strcpy(gi->textarea.value, gi->textinput.value);
1008           strcpy(gi->textarea.last_value, gi->textinput.value);
1009         }
1010         break;
1011
1012       case GDI_TEXT_SIZE:
1013         {
1014           int tag_value = va_arg(ap, int);
1015           int max_textsize = MIN(tag_value, MAX_GADGET_TEXTSIZE);
1016
1017           gi->textinput.size = max_textsize;
1018           gi->textinput.value[max_textsize] = '\0';
1019           strcpy(gi->textinput.last_value, gi->textinput.value);
1020
1021           // same tag also used for other gadget definitions
1022
1023           gi->textarea.size = max_textsize;
1024           gi->textarea.value[max_textsize] = '\0';
1025           strcpy(gi->textarea.last_value, gi->textinput.value);
1026
1027           gi->textbutton.size = max_textsize;
1028           gi->textbutton.value[max_textsize] = '\0';
1029
1030           gi->selectbox.size = gi->textinput.size;
1031         }
1032         break;
1033
1034       case GDI_TEXT_FONT:
1035         gi->font = va_arg(ap, int);
1036         if (gi->font_active == 0)
1037           gi->font_active = gi->font;
1038         if (gi->font_unselectable == 0)
1039           gi->font_unselectable = gi->font;
1040         break;
1041
1042       case GDI_TEXT_FONT_ACTIVE:
1043         gi->font_active = va_arg(ap, int);
1044         break;
1045
1046       case GDI_TEXT_FONT_UNSELECTABLE:
1047         gi->font_unselectable = va_arg(ap, int);
1048         break;
1049
1050       case GDI_SELECTBOX_OPTIONS:
1051         gi->selectbox.options = va_arg(ap, struct ValueTextInfo *);
1052         break;
1053
1054       case GDI_SELECTBOX_INDEX:
1055         gi->selectbox.index = va_arg(ap, int);
1056         break;
1057
1058       case GDI_SELECTBOX_CHAR_UNSELECTABLE:
1059         gi->selectbox.char_unselectable = (char)va_arg(ap, int);
1060         break;
1061
1062       case GDI_DESIGN_UNPRESSED:
1063         gi->design[GD_BUTTON_UNPRESSED].bitmap = va_arg(ap, Bitmap *);
1064         gi->design[GD_BUTTON_UNPRESSED].x = va_arg(ap, int);
1065         gi->design[GD_BUTTON_UNPRESSED].y = va_arg(ap, int);
1066         break;
1067
1068       case GDI_DESIGN_PRESSED:
1069         gi->design[GD_BUTTON_PRESSED].bitmap = va_arg(ap, Bitmap *);
1070         gi->design[GD_BUTTON_PRESSED].x = va_arg(ap, int);
1071         gi->design[GD_BUTTON_PRESSED].y = va_arg(ap, int);
1072         break;
1073
1074       case GDI_ALT_DESIGN_UNPRESSED:
1075         gi->alt_design[GD_BUTTON_UNPRESSED].bitmap= va_arg(ap, Bitmap *);
1076         gi->alt_design[GD_BUTTON_UNPRESSED].x = va_arg(ap, int);
1077         gi->alt_design[GD_BUTTON_UNPRESSED].y = va_arg(ap, int);
1078         break;
1079
1080       case GDI_ALT_DESIGN_PRESSED:
1081         gi->alt_design[GD_BUTTON_PRESSED].bitmap = va_arg(ap, Bitmap *);
1082         gi->alt_design[GD_BUTTON_PRESSED].x = va_arg(ap, int);
1083         gi->alt_design[GD_BUTTON_PRESSED].y = va_arg(ap, int);
1084         break;
1085
1086       case GDI_BORDER_SIZE:
1087         gi->border.xsize = va_arg(ap, int);
1088         gi->border.ysize = va_arg(ap, int);
1089         break;
1090
1091       case GDI_BORDER_SIZE_SELECTBUTTON:
1092         gi->border.xsize_selectbutton = va_arg(ap, int);
1093         break;
1094
1095       case GDI_DESIGN_WIDTH:
1096         gi->border.width = va_arg(ap, int);
1097         break;
1098
1099       case GDI_DECORATION_DESIGN:
1100         gi->deco.design.bitmap = va_arg(ap, Bitmap *);
1101         gi->deco.design.x = va_arg(ap, int);
1102         gi->deco.design.y = va_arg(ap, int);
1103         break;
1104
1105       case GDI_DECORATION_POSITION:
1106         gi->deco.x = va_arg(ap, int);
1107         gi->deco.y = va_arg(ap, int);
1108         break;
1109
1110       case GDI_DECORATION_SIZE:
1111         gi->deco.width = va_arg(ap, int);
1112         gi->deco.height = va_arg(ap, int);
1113         break;
1114
1115       case GDI_DECORATION_SHIFTING:
1116         gi->deco.xshift = va_arg(ap, int);
1117         gi->deco.yshift = va_arg(ap, int);
1118         break;
1119
1120       case GDI_DECORATION_MASKED:
1121         gi->deco.masked = (boolean)va_arg(ap, int);
1122         break;
1123
1124       case GDI_EVENT_MASK:
1125         gi->event_mask = va_arg(ap, unsigned int);
1126         break;
1127
1128       case GDI_AREA_SIZE:
1129         gi->drawing.area_xsize = va_arg(ap, int);
1130         gi->drawing.area_ysize = va_arg(ap, int);
1131
1132         // determine dependent values for drawing area gadget, if needed
1133         if (gi->drawing.item_xsize != 0 && gi->drawing.item_ysize != 0)
1134         {
1135           gi->width = gi->drawing.area_xsize * gi->drawing.item_xsize;
1136           gi->height = gi->drawing.area_ysize * gi->drawing.item_ysize;
1137         }
1138         else if (gi->width != 0 && gi->height != 0)
1139         {
1140           gi->drawing.item_xsize = gi->width / gi->drawing.area_xsize;
1141           gi->drawing.item_ysize = gi->height / gi->drawing.area_ysize;
1142         }
1143
1144         // same tag also used for other gadget definitions
1145         gi->textarea.xsize = gi->drawing.area_xsize;
1146         gi->textarea.ysize = gi->drawing.area_ysize;
1147
1148         if (gi->type & GD_TYPE_TEXT_AREA)       // force recalculation
1149         {
1150           gi->width = 0;
1151           gi->height = 0;
1152         }
1153
1154         break;
1155
1156       case GDI_ITEM_SIZE:
1157         gi->drawing.item_xsize = va_arg(ap, int);
1158         gi->drawing.item_ysize = va_arg(ap, int);
1159
1160         // determine dependent values for drawing area gadget, if needed
1161         if (gi->drawing.area_xsize != 0 && gi->drawing.area_ysize != 0)
1162         {
1163           gi->width = gi->drawing.area_xsize * gi->drawing.item_xsize;
1164           gi->height = gi->drawing.area_ysize * gi->drawing.item_ysize;
1165         }
1166         else if (gi->width != 0 && gi->height != 0)
1167         {
1168           gi->drawing.area_xsize = gi->width / gi->drawing.item_xsize;
1169           gi->drawing.area_ysize = gi->height / gi->drawing.item_ysize;
1170         }
1171         break;
1172
1173       case GDI_SCROLLBAR_ITEMS_MAX:
1174         gi->scrollbar.items_max = va_arg(ap, int);
1175         break;
1176
1177       case GDI_SCROLLBAR_ITEMS_VISIBLE:
1178         gi->scrollbar.items_visible = va_arg(ap, int);
1179         break;
1180
1181       case GDI_SCROLLBAR_ITEM_POSITION:
1182         gi->scrollbar.item_position = va_arg(ap, int);
1183         break;
1184
1185       case GDI_WHEEL_AREA_X:
1186         gi->wheelarea.x = va_arg(ap, int);
1187         break;
1188
1189       case GDI_WHEEL_AREA_Y:
1190         gi->wheelarea.y = va_arg(ap, int);
1191         break;
1192
1193       case GDI_WHEEL_AREA_WIDTH:
1194         gi->wheelarea.width = va_arg(ap, int);
1195         break;
1196
1197       case GDI_WHEEL_AREA_HEIGHT:
1198         gi->wheelarea.height = va_arg(ap, int);
1199         break;
1200
1201       case GDI_CALLBACK_INFO:
1202         gi->callback_info = va_arg(ap, gadget_function);
1203         break;
1204
1205       case GDI_CALLBACK_ACTION:
1206         gi->callback_action = va_arg(ap, gadget_function);
1207         break;
1208
1209       default:
1210         Error(ERR_EXIT, "HandleGadgetTags(): unknown tag %d", tag);
1211     }
1212
1213     tag = va_arg(ap, int);      // read next tag
1214   }
1215
1216   gi->deactivated = FALSE;
1217
1218   // check if gadget has undefined bitmaps
1219   if (gi->type != GD_TYPE_DRAWING_AREA &&
1220       (gi->design[GD_BUTTON_UNPRESSED].bitmap == NULL ||
1221        gi->design[GD_BUTTON_PRESSED].bitmap == NULL))
1222     gi->deactivated = TRUE;
1223
1224   // check if gadget is placed off-screen (and is no overlay touch button)
1225   if ((gi->x < 0 || gi->y < 0) && !gi->overlay_touch_button)
1226     gi->deactivated = TRUE;
1227
1228   // adjust gadget values in relation to other gadget values
1229
1230   if (gi->type & GD_TYPE_TEXT_INPUT)
1231   {
1232     int font_nr = gi->font_active;
1233     int font_width = getFontWidth(font_nr);
1234     int font_height = getFontHeight(font_nr);
1235     int border_xsize = gi->border.xsize;
1236     int border_ysize = gi->border.ysize;
1237
1238     if (gi->type == GD_TYPE_TEXT_INPUT_NUMERIC)
1239     {
1240       int number_min = gi->textinput.number_min;
1241       int number_max = gi->textinput.number_max;
1242       int min_size_min = get_minimal_size_for_numeric_input(number_min);
1243       int min_size_max = get_minimal_size_for_numeric_input(number_max);
1244       int min_size = MAX(min_size_min, min_size_max);
1245
1246       // expand gadget text input size, if maximal value is too large
1247       if (gi->textinput.size < min_size)
1248         gi->textinput.size = min_size;
1249     }
1250
1251     gi->width  = 2 * border_xsize + (gi->textinput.size + 1) * font_width;
1252     gi->height = 2 * border_ysize + font_height;
1253   }
1254
1255   if (gi->type & GD_TYPE_SELECTBOX)
1256   {
1257     int font_nr = gi->font_active;
1258     int font_width = getFontWidth(font_nr);
1259     int font_height = getFontHeight(font_nr);
1260     int border_xsize = gi->border.xsize;
1261     int border_ysize = gi->border.ysize;
1262     int button_size = gi->border.xsize_selectbutton;
1263     int bottom_screen_border = gfx.sy + gfx.sysize - font_height;
1264     Bitmap *src_bitmap;
1265     int src_x, src_y;
1266
1267     gi->width  = 2 * border_xsize + gi->textinput.size*font_width +button_size;
1268     gi->height = 2 * border_ysize + font_height;
1269
1270     if (gi->selectbox.options == NULL)
1271       Error(ERR_EXIT, "selectbox gadget incomplete (missing options array)");
1272
1273     gi->selectbox.num_values = 0;
1274     while (gi->selectbox.options[gi->selectbox.num_values].text != NULL)
1275       gi->selectbox.num_values++;
1276
1277     // calculate values for open selectbox
1278     gi->selectbox.width = gi->width;
1279     gi->selectbox.height =
1280       2 * border_ysize + gi->selectbox.num_values * font_height;
1281
1282     gi->selectbox.x = gi->x;
1283     gi->selectbox.y = gi->y + gi->height;
1284     if (gi->selectbox.y + gi->selectbox.height > bottom_screen_border)
1285       gi->selectbox.y = gi->y - gi->selectbox.height;
1286     if (gi->selectbox.y < 0)
1287       gi->selectbox.y = bottom_screen_border - gi->selectbox.height;
1288
1289     getFontCharSource(font_nr, FONT_ASCII_CURSOR, &src_bitmap, &src_x, &src_y);
1290     src_x += font_width / 2;
1291     src_y += font_height / 2;
1292
1293     // there may be esoteric cases with missing or too small font bitmap
1294     if (src_bitmap != NULL &&
1295         src_x < src_bitmap->width && src_y < src_bitmap->height)
1296       gi->selectbox.inverse_color = GetPixel(src_bitmap, src_x, src_y);
1297
1298     // always start with closed selectbox
1299     gi->selectbox.open = FALSE;
1300   }
1301
1302   if (gi->type & GD_TYPE_TEXT_INPUT_NUMERIC)
1303   {
1304     struct GadgetTextInput *text = &gi->textinput;
1305     int value = text->number_value;
1306
1307     text->number_value = (value < text->number_min ? text->number_min :
1308                           value > text->number_max ? text->number_max :
1309                           value);
1310
1311     sprintf(text->value, "%d", text->number_value);
1312   }
1313
1314   if (gi->type & GD_TYPE_TEXT_BUTTON)
1315   {
1316     int font_nr = gi->font_active;
1317     int font_width = getFontWidth(font_nr);
1318     int font_height = getFontHeight(font_nr);
1319     int border_xsize = gi->border.xsize;
1320     int border_ysize = gi->border.ysize;
1321
1322     gi->width  = 2 * border_xsize + gi->textbutton.size * font_width;
1323     gi->height = 2 * border_ysize + font_height;
1324   }
1325
1326   if (gi->type & GD_TYPE_SCROLLBAR)
1327   {
1328     struct GadgetScrollbar *gs = &gi->scrollbar;
1329     int scrollbar_size_cmp;
1330
1331     if (gi->width == 0 || gi->height == 0 ||
1332         gs->items_max == 0 || gs->items_visible == 0)
1333       Error(ERR_EXIT, "scrollbar gadget incomplete (missing tags)");
1334
1335     // calculate internal scrollbar values
1336     gs->size_min = (gi->type == GD_TYPE_SCROLLBAR_VERTICAL ?
1337                     gi->width : gi->height);
1338     gs->size_max = (gi->type == GD_TYPE_SCROLLBAR_VERTICAL ?
1339                     gi->height : gi->width);
1340
1341     scrollbar_size_cmp = gs->size_max * gs->items_visible / gs->items_max;
1342     gs->size = MAX(scrollbar_size_cmp, gs->size_min);
1343     gs->size_max_cmp = (gs->size_max - (gs->size - scrollbar_size_cmp));
1344
1345     gs->position = gs->size_max_cmp * gs->item_position / gs->items_max;
1346     gs->position_max = gs->size_max - gs->size;
1347     gs->correction = gs->size_max / gs->items_max / 2;
1348
1349     // finetuning for maximal right/bottom position
1350     if (gs->item_position == gs->items_max - gs->items_visible)
1351       gs->position = gs->position_max;
1352   }
1353
1354   if (gi->type & GD_TYPE_TEXT_AREA)
1355   {
1356     int font_nr = gi->font_active;
1357     int font_width = getFontWidth(font_nr);
1358     int font_height = getFontHeight(font_nr);
1359     int border_xsize = gi->border.xsize;
1360     int border_ysize = gi->border.ysize;
1361
1362     if (gi->width == 0 || gi->height == 0)
1363     {
1364       gi->width  = 2 * border_xsize + gi->textarea.xsize * font_width;
1365       gi->height = 2 * border_ysize + gi->textarea.ysize * font_height;
1366     }
1367     else
1368     {
1369       gi->textarea.xsize = (gi->width  - 2 * border_xsize) / font_width;
1370       gi->textarea.ysize = (gi->height - 2 * border_ysize) / font_height;
1371     }
1372   }
1373 }
1374
1375 void ModifyGadget(struct GadgetInfo *gi, int first_tag, ...)
1376 {
1377   va_list ap;
1378
1379   va_start(ap, first_tag);
1380   HandleGadgetTags(gi, first_tag, ap);
1381   va_end(ap);
1382
1383   RedrawGadget(gi);
1384 }
1385
1386 void RedrawGadget(struct GadgetInfo *gi)
1387 {
1388   if (gi == NULL || gi->deactivated)
1389     return;
1390
1391   if (gi->mapped)
1392     DrawGadget(gi, gi->state, gi->direct_draw);
1393 }
1394
1395 struct GadgetInfo *CreateGadget(int first_tag, ...)
1396 {
1397   struct GadgetInfo *new_gadget = checked_calloc(sizeof(struct GadgetInfo));
1398   va_list ap;
1399
1400   // always start with reliable default values
1401   new_gadget->id = getNewGadgetID();
1402   new_gadget->image_id = -1;
1403   new_gadget->callback_info = default_callback_info;
1404   new_gadget->callback_action = default_callback_action;
1405   new_gadget->active = TRUE;
1406   new_gadget->direct_draw = TRUE;
1407   new_gadget->overlay_touch_button = FALSE;
1408   new_gadget->overlay_touch_button_alpha = 0;
1409
1410   new_gadget->next = NULL;
1411
1412   va_start(ap, first_tag);
1413   HandleGadgetTags(new_gadget, first_tag, ap);
1414   va_end(ap);
1415
1416   // insert new gadget into global gadget list
1417   if (gadget_list_last_entry)
1418   {
1419     gadget_list_last_entry->next = new_gadget;
1420     gadget_list_last_entry = gadget_list_last_entry->next;
1421   }
1422   else
1423     gadget_list_first_entry = gadget_list_last_entry = new_gadget;
1424
1425   return new_gadget;
1426 }
1427
1428 void FreeGadget(struct GadgetInfo *gi)
1429 {
1430   struct GadgetInfo *gi_previous = gadget_list_first_entry;
1431
1432   if (gi == NULL)
1433     return;
1434
1435   // prevent "last_info_gi" from pointing to memory that will be freed
1436   if (last_info_gi == gi)
1437     last_info_gi = NULL;
1438
1439   while (gi_previous != NULL && gi_previous->next != gi)
1440     gi_previous = gi_previous->next;
1441
1442   if (gi == gadget_list_first_entry)
1443     gadget_list_first_entry = gi->next;
1444
1445   if (gi == gadget_list_last_entry)
1446     gadget_list_last_entry = gi_previous;
1447
1448   if (gi_previous != NULL)
1449     gi_previous->next = gi->next;
1450
1451   free(gi);
1452 }
1453
1454 static void CheckRangeOfNumericInputGadget(struct GadgetInfo *gi)
1455 {
1456   if (gi->type != GD_TYPE_TEXT_INPUT_NUMERIC)
1457     return;
1458
1459   gi->textinput.number_value = atoi(gi->textinput.value);
1460
1461   if (gi->textinput.number_value < gi->textinput.number_min)
1462     gi->textinput.number_value = gi->textinput.number_min;
1463   if (gi->textinput.number_value > gi->textinput.number_max)
1464     gi->textinput.number_value = gi->textinput.number_max;
1465
1466   sprintf(gi->textinput.value, "%d", gi->textinput.number_value);
1467
1468   if (gi->textinput.cursor_position < 0)
1469     gi->textinput.cursor_position = 0;
1470   else if (gi->textinput.cursor_position > strlen(gi->textinput.value))
1471     gi->textinput.cursor_position = strlen(gi->textinput.value);
1472 }
1473
1474 // global pointer to gadget actually in use (when mouse button pressed)
1475 static struct GadgetInfo *last_gi = NULL;
1476
1477 static void MapGadgetExt(struct GadgetInfo *gi, boolean redraw)
1478 {
1479   if (gi == NULL || gi->deactivated || gi->mapped)
1480     return;
1481
1482   gi->mapped = TRUE;
1483
1484   if (redraw)
1485     DrawGadget(gi, DG_UNPRESSED, DG_BUFFERED);
1486 }
1487
1488 void MapGadget(struct GadgetInfo *gi)
1489 {
1490   MapGadgetExt(gi, TRUE);
1491 }
1492
1493 void UnmapGadget(struct GadgetInfo *gi)
1494 {
1495   if (gi == NULL || gi->deactivated || !gi->mapped)
1496     return;
1497
1498   gi->mapped = FALSE;
1499
1500   if (gi == last_gi)
1501     last_gi = NULL;
1502 }
1503
1504 #define MAX_NUM_GADGETS         1024
1505 #define MULTIMAP_UNMAP          (1 << 0)
1506 #define MULTIMAP_REMAP          (1 << 1)
1507 #define MULTIMAP_REDRAW         (1 << 2)
1508 #define MULTIMAP_PLAYFIELD      (1 << 3)
1509 #define MULTIMAP_DOOR_1         (1 << 4)
1510 #define MULTIMAP_DOOR_2         (1 << 5)
1511 #define MULTIMAP_DOOR_3         (1 << 6)
1512 #define MULTIMAP_ALL            (MULTIMAP_PLAYFIELD | \
1513                                  MULTIMAP_DOOR_1    | \
1514                                  MULTIMAP_DOOR_2    | \
1515                                  MULTIMAP_DOOR_3)
1516
1517 static void MultiMapGadgets(int mode)
1518 {
1519   struct GadgetInfo *gi = gadget_list_first_entry;
1520   static boolean map_state[MAX_NUM_GADGETS];
1521   int map_count = 0;
1522
1523   while (gi != NULL)
1524   {
1525     int x = gi->x;
1526     int y = gi->y;
1527
1528     if ((mode & MULTIMAP_PLAYFIELD && IN_GFX_FIELD_FULL(x, y)) ||
1529         (mode & MULTIMAP_DOOR_1 && IN_GFX_DOOR_1(x, y)) ||
1530         (mode & MULTIMAP_DOOR_2 && IN_GFX_DOOR_2(x, y)) ||
1531         (mode & MULTIMAP_DOOR_3 && IN_GFX_DOOR_3(x, y)) ||
1532         (mode & MULTIMAP_ALL) == MULTIMAP_ALL)
1533     {
1534       if (mode & MULTIMAP_UNMAP)
1535       {
1536         map_state[map_count++ % MAX_NUM_GADGETS] = gi->mapped;
1537         UnmapGadget(gi);
1538       }
1539       else
1540       {
1541         if (map_state[map_count++ % MAX_NUM_GADGETS])
1542           MapGadgetExt(gi, (mode & MULTIMAP_REDRAW));
1543       }
1544     }
1545
1546     gi = gi->next;
1547   }
1548 }
1549
1550 void UnmapAllGadgets(void)
1551 {
1552   MultiMapGadgets(MULTIMAP_ALL | MULTIMAP_UNMAP);
1553 }
1554
1555 void RemapAllGadgets(void)
1556 {
1557   MultiMapGadgets(MULTIMAP_ALL | MULTIMAP_REMAP);
1558 }
1559
1560 boolean anyTextInputGadgetActive(void)
1561 {
1562   return (last_gi && (last_gi->type & GD_TYPE_TEXT_INPUT) && last_gi->mapped);
1563 }
1564
1565 boolean anyTextAreaGadgetActive(void)
1566 {
1567   return (last_gi && (last_gi->type & GD_TYPE_TEXT_AREA) && last_gi->mapped);
1568 }
1569
1570 boolean anySelectboxGadgetActive(void)
1571 {
1572   return (last_gi && (last_gi->type & GD_TYPE_SELECTBOX) && last_gi->mapped);
1573 }
1574
1575 boolean anyScrollbarGadgetActive(void)
1576 {
1577   return (last_gi && (last_gi->type & GD_TYPE_SCROLLBAR) && last_gi->mapped);
1578 }
1579
1580 boolean anyTextGadgetActive(void)
1581 {
1582   return (anyTextInputGadgetActive() ||
1583           anyTextAreaGadgetActive() ||
1584           anySelectboxGadgetActive());
1585 }
1586
1587 static boolean insideSelectboxLine(struct GadgetInfo *gi, int mx, int my)
1588 {
1589   return (gi != NULL &&
1590           gi->type & GD_TYPE_SELECTBOX &&
1591           mx >= gi->x && mx < gi->x + gi->width &&
1592           my >= gi->y && my < gi->y + gi->height);
1593 }
1594
1595 static boolean insideSelectboxArea(struct GadgetInfo *gi, int mx, int my)
1596 {
1597   return (gi != NULL &&
1598           gi->type & GD_TYPE_SELECTBOX &&
1599           mx >= gi->selectbox.x && mx < gi->selectbox.x + gi->selectbox.width &&
1600           my >= gi->selectbox.y && my < gi->selectbox.y + gi->selectbox.height);
1601 }
1602
1603 void ClickOnGadget(struct GadgetInfo *gi, int button)
1604 {
1605   if (gi == NULL || gi->deactivated || !gi->mapped)
1606     return;
1607
1608   // simulate releasing mouse button over last gadget, if still pressed
1609   if (button_status)
1610     HandleGadgets(-1, -1, 0);
1611
1612   int x = gi->x;
1613   int y = gi->y;
1614
1615   // set cursor position to the end of the text for text input gadgets
1616   if (gi->type & GD_TYPE_TEXT_INPUT)
1617     x = gi->x + gi->width - 1;
1618
1619   // simulate pressing mouse button over specified gadget
1620   HandleGadgets(x, y, button);
1621
1622   // simulate releasing mouse button over specified gadget
1623   HandleGadgets(x, y, 0);
1624 }
1625
1626 boolean HandleGadgets(int mx, int my, int button)
1627 {
1628   static unsigned int pressed_delay = 0;
1629   static unsigned int pressed_delay_value = GADGET_FRAME_DELAY;
1630   static int last_button = 0;
1631   static int last_mx = 0, last_my = 0;
1632   static int pressed_mx = 0, pressed_my = 0;
1633   static boolean keep_selectbox_open = FALSE;
1634   static boolean gadget_stopped = FALSE;
1635   int scrollbar_mouse_pos = 0;
1636   struct GadgetInfo *new_gi, *gi;
1637   boolean press_event;
1638   boolean release_event;
1639   boolean mouse_moving;
1640   boolean mouse_inside_select_line;
1641   boolean mouse_inside_select_area;
1642   boolean mouse_released_where_pressed;
1643   boolean gadget_pressed;
1644   boolean gadget_pressed_repeated;
1645   boolean gadget_pressed_off_borders;
1646   boolean gadget_pressed_inside_select_line;
1647   boolean gadget_pressed_delay_reached;
1648   boolean gadget_moving;
1649   boolean gadget_moving_inside;
1650   boolean gadget_moving_off_borders;
1651   boolean gadget_draggable;
1652   boolean gadget_dragging;
1653   boolean gadget_released;
1654   boolean gadget_released_inside;
1655   boolean gadget_released_inside_select_area;
1656   boolean gadget_released_off_borders;
1657   boolean changed_position = FALSE;
1658
1659   // check if there are any gadgets defined
1660   if (gadget_list_first_entry == NULL)
1661     return FALSE;
1662
1663   // simulated release of mouse button over last gadget
1664   if (mx == -1 && my == -1 && button == 0)
1665   {
1666     mx = last_mx;
1667     my = last_my;
1668   }
1669
1670   // check which gadget is under the mouse pointer
1671   new_gi = getGadgetInfoFromMousePosition(mx, my, button);
1672
1673   // check if button state has changed since last invocation
1674   press_event   = (button != 0 && last_button == 0);
1675   release_event = (button == 0 && last_button != 0);
1676   last_button = button;
1677
1678   // check if mouse has been moved since last invocation
1679   mouse_moving = ((mx != last_mx || my != last_my) && motion_status);
1680   last_mx = mx;
1681   last_my = my;
1682
1683   if (press_event && new_gi != last_gi)
1684   {
1685     pressed_mx = mx;
1686     pressed_my = my;
1687   }
1688
1689   mouse_released_where_pressed =
1690     (release_event && mx == pressed_mx && my == pressed_my);
1691
1692   mouse_inside_select_line = insideSelectboxLine(new_gi, mx, my);
1693   mouse_inside_select_area = insideSelectboxArea(new_gi, mx, my);
1694
1695   gadget_pressed_off_borders = (press_event && new_gi != last_gi);
1696
1697   gadget_pressed_inside_select_line =
1698     (press_event && new_gi != NULL &&
1699      new_gi->type & GD_TYPE_SELECTBOX && new_gi->selectbox.open &&
1700      insideSelectboxLine(new_gi, mx, my));
1701
1702   // if mouse button pressed outside text or selectbox gadget, deactivate it
1703   if (anyTextGadgetActive() &&
1704       (gadget_pressed_off_borders ||
1705        (gadget_pressed_inside_select_line && !mouse_inside_select_area)))
1706   {
1707     struct GadgetInfo *gi = last_gi;
1708     boolean gadget_changed = ((gi->event_mask & GD_EVENT_TEXT_LEAVING) != 0);
1709
1710     // check if text gadget has changed its value
1711     if (gi->type & GD_TYPE_TEXT_INPUT)
1712     {
1713       CheckRangeOfNumericInputGadget(gi);
1714
1715       if (!strEqual(gi->textinput.last_value, gi->textinput.value))
1716         strcpy(gi->textinput.last_value, gi->textinput.value);
1717       else
1718         gadget_changed = FALSE;
1719     }
1720
1721     // selectbox does not change its value when closed by clicking outside
1722     if (gi->type & GD_TYPE_SELECTBOX)
1723       gadget_changed = FALSE;
1724
1725     DrawGadget(gi, DG_UNPRESSED, gi->direct_draw);
1726
1727     gi->event.type = GD_EVENT_TEXT_LEAVING;
1728
1729     if (!(gi->type & GD_TYPE_SELECTBOX))
1730       DoGadgetCallbackAction(gi, gadget_changed);
1731
1732     last_gi = NULL;
1733
1734     if (gadget_pressed_inside_select_line)
1735       new_gi = NULL;
1736
1737     StopTextInput();
1738   }
1739
1740   gadget_pressed =
1741     (button != 0 && last_gi == NULL && new_gi != NULL && press_event);
1742   gadget_pressed_repeated =
1743     (button != 0 && last_gi != NULL && new_gi == last_gi);
1744
1745   gadget_pressed_delay_reached =
1746     DelayReached(&pressed_delay, pressed_delay_value);
1747
1748   gadget_released =             (release_event && last_gi != NULL);
1749   gadget_released_inside =      (gadget_released && new_gi == last_gi);
1750   gadget_released_off_borders = (gadget_released && new_gi != last_gi);
1751
1752   gadget_moving =             (button != 0 && last_gi != NULL && mouse_moving);
1753   gadget_moving_inside =      (gadget_moving && new_gi == last_gi);
1754   gadget_moving_off_borders = (gadget_moving && new_gi != last_gi);
1755
1756   // when handling selectbox, set additional state values
1757   if (gadget_released_inside && (last_gi->type & GD_TYPE_SELECTBOX))
1758     gadget_released_inside_select_area = insideSelectboxArea(last_gi, mx, my);
1759   else
1760     gadget_released_inside_select_area = FALSE;
1761
1762   // setting state for handling over-large selectbox
1763   if (keep_selectbox_open && (press_event || !mouse_inside_select_line))
1764     keep_selectbox_open = FALSE;
1765
1766   // if new gadget pressed, store this gadget
1767   if (gadget_pressed)
1768     last_gi = new_gi;
1769
1770   // 'gi' is actually handled gadget
1771   gi = last_gi;
1772
1773   // if gadget is scrollbar, choose mouse position value
1774   if (gi && gi->type & GD_TYPE_SCROLLBAR)
1775     scrollbar_mouse_pos =
1776       (gi->type == GD_TYPE_SCROLLBAR_HORIZONTAL ? mx - gi->x : my - gi->y);
1777
1778   // if mouse button released, no gadget needs to be handled anymore
1779   if (gadget_released)
1780   {
1781     if (gi->type & GD_TYPE_SELECTBOX &&
1782         (keep_selectbox_open ||
1783          mouse_released_where_pressed ||
1784          !gadget_released_inside_select_area ||
1785          !CURRENT_OPTION_SELECTABLE(gi)))           // selectbox stays open
1786     {
1787       gi->selectbox.stay_open = TRUE;
1788       pressed_mx = 0;
1789       pressed_my = 0;
1790     }
1791     else if (!(gi->type & GD_TYPE_TEXT_INPUT ||
1792                gi->type & GD_TYPE_TEXT_AREA))       // text input stays open
1793       last_gi = NULL;
1794   }
1795
1796   // modify event position values even if no gadget is pressed
1797   if (button == 0 && !release_event)
1798     gi = new_gi;
1799
1800   // if new gadget or if no gadget was pressed, release stopped processing
1801   if (gadget_pressed || new_gi == NULL)
1802     gadget_stopped = FALSE;
1803
1804   // if gadget was stopped while being handled, stop gadget processing here
1805   if (gadget_stopped)
1806     return TRUE;
1807
1808   if (gi != NULL)
1809   {
1810     int last_x = gi->event.x;
1811     int last_y = gi->event.y;
1812     int last_mx = gi->event.mx;
1813     int last_my = gi->event.my;
1814
1815     gi->event.x = gi->event.mx = mx - gi->x;
1816     gi->event.y = gi->event.my = my - gi->y;
1817
1818     if (gi->type == GD_TYPE_DRAWING_AREA)
1819     {
1820       gi->event.x /= gi->drawing.item_xsize;
1821       gi->event.y /= gi->drawing.item_ysize;
1822
1823       if (last_x != gi->event.x || last_y != gi->event.y ||
1824           ((last_mx != gi->event.mx || last_my != gi->event.my) &&
1825            gi->event_mask & GD_EVENT_PIXEL_PRECISE))
1826         changed_position = TRUE;
1827     }
1828     else if (gi->type & GD_TYPE_TEXT_INPUT && button != 0 && !motion_status)
1829     {
1830       int old_cursor_position = gi->textinput.cursor_position;
1831
1832       // if mouse button pressed inside activated text gadget, set cursor
1833       gi->textinput.cursor_position =
1834         (mx - gi->x - gi->border.xsize) / getFontWidth(gi->font);
1835
1836       if (gi->textinput.cursor_position < 0)
1837         gi->textinput.cursor_position = 0;
1838       else if (gi->textinput.cursor_position > strlen(gi->textinput.value))
1839         gi->textinput.cursor_position = strlen(gi->textinput.value);
1840
1841       if (gi->textinput.cursor_position != old_cursor_position)
1842         DrawGadget(gi, DG_PRESSED, gi->direct_draw);
1843
1844       if (press_event)
1845         StartTextInput(gi->x, gi->y, gi->width, gi->height);
1846     }
1847     else if (gi->type & GD_TYPE_TEXT_AREA && button != 0 && !motion_status)
1848     {
1849       int old_cursor_position = gi->textarea.cursor_position;
1850       int x = (mx - gi->x - gi->border.xsize) / getFontWidth(gi->font);
1851       int y = (my - gi->y - gi->border.ysize) / getFontHeight(gi->font);
1852
1853       x = (x < 0 ? 0 : x >= gi->textarea.xsize ? gi->textarea.xsize - 1 : x);
1854       y = (y < 0 ? 0 : y >= gi->textarea.ysize ? gi->textarea.ysize - 1 : y);
1855
1856       setTextAreaCursorXY(gi, x, y);
1857
1858       if (gi->textarea.cursor_position != old_cursor_position)
1859         DrawGadget(gi, DG_PRESSED, gi->direct_draw);
1860
1861       if (press_event)
1862         StartTextInput(gi->x, gi->y, gi->width, gi->height);
1863     }
1864     else if (gi->type & GD_TYPE_SELECTBOX && gi->selectbox.open &&
1865              !keep_selectbox_open)
1866     {
1867       int old_index = gi->selectbox.current_index;
1868
1869       // if mouse moving inside activated selectbox, select value
1870       if (my >= gi->selectbox.y && my < gi->selectbox.y + gi->selectbox.height)
1871         gi->selectbox.current_index =
1872           (my - gi->selectbox.y - gi->border.ysize) / getFontHeight(gi->font);
1873
1874       if (gi->selectbox.current_index < 0)
1875         gi->selectbox.current_index = 0;
1876       else if (gi->selectbox.current_index > gi->selectbox.num_values - 1)
1877         gi->selectbox.current_index = gi->selectbox.num_values - 1;
1878
1879       if (gi->selectbox.current_index != old_index)
1880         DrawGadget(gi, DG_PRESSED, gi->direct_draw);
1881     }
1882   }
1883
1884   // handle gadget popup info text
1885   if (last_info_gi != new_gi ||
1886       (new_gi && new_gi->type == GD_TYPE_DRAWING_AREA && changed_position))
1887   {
1888     if (new_gi != NULL && (button == 0 || new_gi == last_gi))
1889     {
1890       new_gi->event.type = GD_EVENT_INFO_ENTERING;
1891       new_gi->callback_info(new_gi);
1892     }
1893     else if (last_info_gi != NULL && last_info_gi->mapped)
1894     {
1895       last_info_gi->event.type = GD_EVENT_INFO_LEAVING;
1896       last_info_gi->callback_info(last_info_gi);
1897     }
1898
1899     last_info_gi = new_gi;
1900   }
1901
1902   gadget_draggable = (gi && gi->type & GD_TYPE_SCROLLBAR);
1903
1904   // reset drag position for newly pressed scrollbar to "not dragging"
1905   if (gadget_pressed && gadget_draggable)
1906     gi->scrollbar.drag_position = -1;
1907
1908   gadget_dragging = (gadget_draggable && gi->scrollbar.drag_position != -1);
1909
1910   // clicking next to a scrollbar to move it is not considered "moving"
1911   if (gadget_draggable && !gadget_dragging)
1912     gadget_moving = FALSE;
1913
1914   // when leaving scrollbar area when jump-scrolling, stop gadget processing
1915   if (gadget_draggable && !gadget_dragging && gadget_moving_off_borders)
1916     gadget_stopped = TRUE;
1917
1918   if ((gadget_pressed) ||
1919       (gadget_pressed_repeated && gadget_pressed_delay_reached))
1920   {
1921     if (gadget_pressed)         // gadget pressed the first time
1922     {
1923       // initialize delay counter
1924       DelayReached(&pressed_delay, 0);
1925
1926       // start gadget delay with longer delay after first click on gadget
1927       pressed_delay_value = GADGET_FRAME_DELAY_FIRST;
1928     }
1929     else                        // gadget hold pressed for some time
1930     {
1931       // after first repeated gadget click, continue with shorter delay value
1932       pressed_delay_value = GADGET_FRAME_DELAY;
1933     }
1934
1935     if (gi->type & GD_TYPE_SCROLLBAR && !gadget_dragging)
1936     {
1937       int mpos = (gi->type == GD_TYPE_SCROLLBAR_HORIZONTAL ? mx    : my);
1938       int gpos = (gi->type == GD_TYPE_SCROLLBAR_HORIZONTAL ? gi->x : gi->y);
1939       int slider_start = gpos + gi->scrollbar.position;
1940       int slider_end   = gpos + gi->scrollbar.position + gi->scrollbar.size - 1;
1941       boolean inside_slider = (mpos >= slider_start && mpos <= slider_end);
1942
1943       if (IS_WHEEL_BUTTON(button) || !inside_slider)
1944       {
1945         // click scrollbar one scrollbar length up/left or down/right
1946
1947         struct GadgetScrollbar *gs = &gi->scrollbar;
1948         int old_item_position = gs->item_position;
1949         int item_steps = gs->items_visible - 1;
1950         int item_direction = (mpos < gpos + gi->scrollbar.position ? -1 : +1);
1951
1952         if (IS_WHEEL_BUTTON(button))
1953         {
1954           boolean scroll_single_step = ((GetKeyModState() & KMOD_Alt) != 0);
1955
1956           item_steps = (scroll_single_step ? 1 : wheel_steps);
1957           item_direction = (button == MB_WHEEL_UP ||
1958                             button == MB_WHEEL_LEFT ? -1 : +1);
1959         }
1960
1961         changed_position = FALSE;
1962
1963         gs->item_position += item_steps * item_direction;
1964
1965         if (gs->item_position < 0)
1966           gs->item_position = 0;
1967         else if (gs->item_position > gs->items_max - gs->items_visible)
1968           gs->item_position = gs->items_max - gs->items_visible;
1969
1970         if (old_item_position != gs->item_position)
1971         {
1972           gi->event.item_position = gs->item_position;
1973           changed_position = TRUE;
1974         }
1975
1976         ModifyGadget(gi, GDI_SCROLLBAR_ITEM_POSITION, gs->item_position,
1977                      GDI_END);
1978
1979         gi->state = GD_BUTTON_UNPRESSED;
1980         gi->event.type = GD_EVENT_MOVING;
1981         gi->event.off_borders = FALSE;
1982
1983         if (gi->event_mask & GD_EVENT_MOVING)
1984           DoGadgetCallbackAction(gi, changed_position);
1985
1986         return TRUE;
1987       }
1988       else
1989       {
1990         // don't handle this scrollbar anymore when mouse position reached
1991         if (gadget_pressed_repeated)
1992         {
1993           gadget_stopped = TRUE;
1994
1995           return TRUE;
1996         }
1997       }
1998     }
1999   }
2000
2001   if (gadget_pressed)
2002   {
2003     PlayGadgetSoundActivating();
2004
2005     if (gi->type == GD_TYPE_CHECK_BUTTON)
2006     {
2007       gi->checked = !gi->checked;
2008     }
2009     else if (gi->type == GD_TYPE_RADIO_BUTTON)
2010     {
2011       struct GadgetInfo *rgi = gadget_list_first_entry;
2012
2013       while (rgi)
2014       {
2015         if (rgi->mapped &&
2016             rgi->type == GD_TYPE_RADIO_BUTTON &&
2017             rgi->radio_nr == gi->radio_nr &&
2018             rgi != gi)
2019         {
2020           rgi->checked = FALSE;
2021           DrawGadget(rgi, DG_UNPRESSED, rgi->direct_draw);
2022         }
2023
2024         rgi = rgi->next;
2025       }
2026
2027       gi->checked = TRUE;
2028     }
2029     else if (gi->type & GD_TYPE_SCROLLBAR)
2030     {
2031       int mpos = (gi->type == GD_TYPE_SCROLLBAR_HORIZONTAL ? mx    : my);
2032       int gpos = (gi->type == GD_TYPE_SCROLLBAR_HORIZONTAL ? gi->x : gi->y);
2033       int slider_start = gpos + gi->scrollbar.position;
2034       int slider_end   = gpos + gi->scrollbar.position + gi->scrollbar.size - 1;
2035       boolean inside_slider = (mpos >= slider_start && mpos <= slider_end);
2036
2037       if (!IS_WHEEL_BUTTON(button) && inside_slider)
2038       {
2039         // start dragging scrollbar
2040         gi->scrollbar.drag_position =
2041           scrollbar_mouse_pos - gi->scrollbar.position;
2042       }
2043     }
2044     else if (gi->type & GD_TYPE_SELECTBOX)
2045     {
2046       // keep selectbox open in case of over-large selectbox
2047       keep_selectbox_open = (mouse_inside_select_line &&
2048                              mouse_inside_select_area);
2049     }
2050
2051     DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2052
2053     gi->state = GD_BUTTON_PRESSED;
2054     gi->event.type = GD_EVENT_PRESSED;
2055     gi->event.button = button;
2056     gi->event.off_borders = FALSE;
2057
2058     if (gi->event_mask & GD_EVENT_PRESSED)
2059       gi->callback_action(gi);
2060   }
2061
2062   if (gadget_pressed_repeated)
2063   {
2064     gi->event.type = GD_EVENT_PRESSED;
2065
2066     if (gi->event_mask & GD_EVENT_REPEATED && gadget_pressed_delay_reached)
2067       gi->callback_action(gi);
2068   }
2069
2070   if (gadget_moving)
2071   {
2072     if (gi->type & GD_TYPE_BUTTON)
2073     {
2074       if (gadget_moving_inside && gi->state == GD_BUTTON_UNPRESSED)
2075         DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2076       else if (gadget_moving_off_borders && gi->state == GD_BUTTON_PRESSED)
2077         DrawGadget(gi, DG_UNPRESSED, gi->direct_draw);
2078     }
2079     else if (gi->type & GD_TYPE_SELECTBOX && !keep_selectbox_open)
2080     {
2081       int old_index = gi->selectbox.current_index;
2082
2083       // if mouse moving inside activated selectbox, select value
2084       if (my >= gi->selectbox.y && my < gi->selectbox.y + gi->selectbox.height)
2085         gi->selectbox.current_index =
2086           (my - gi->selectbox.y - gi->border.ysize) / getFontHeight(gi->font);
2087
2088       if (gi->selectbox.current_index < 0)
2089         gi->selectbox.current_index = 0;
2090       else if (gi->selectbox.current_index > gi->selectbox.num_values - 1)
2091         gi->selectbox.current_index = gi->selectbox.num_values - 1;
2092
2093       if (gi->selectbox.current_index != old_index)
2094         DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2095     }
2096     else if (gi->type & GD_TYPE_SCROLLBAR)
2097     {
2098       struct GadgetScrollbar *gs = &gi->scrollbar;
2099       int old_item_position = gs->item_position;
2100
2101       gs->position = scrollbar_mouse_pos - gs->drag_position;
2102
2103       // make sure to always precisely reach end positions when dragging
2104       if (gs->position <= 0)
2105       {
2106         gs->position = 0;
2107         gs->item_position = 0;
2108       }
2109       else if (gs->position >= gs->position_max)
2110       {
2111         gs->position = gs->position_max;
2112         gs->item_position = gs->items_max - gs->items_visible;
2113       }
2114       else
2115       {
2116         gs->item_position =
2117           gs->items_max * (gs->position + gs->correction) / gs->size_max_cmp;
2118       }
2119
2120       if (gs->item_position < 0)
2121         gs->item_position = 0;
2122       if (gs->item_position > gs->items_max - 1)
2123         gs->item_position = gs->items_max - 1;
2124
2125       if (old_item_position != gs->item_position)
2126       {
2127         gi->event.item_position = gs->item_position;
2128         changed_position = TRUE;
2129       }
2130
2131       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2132     }
2133
2134     gi->state = (gadget_moving_inside || gadget_draggable ?
2135                  GD_BUTTON_PRESSED : GD_BUTTON_UNPRESSED);
2136     gi->event.type = GD_EVENT_MOVING;
2137     gi->event.off_borders = gadget_moving_off_borders;
2138
2139     if (gi->event_mask & GD_EVENT_MOVING &&
2140         (gadget_moving_inside || gi->event_mask & GD_EVENT_OFF_BORDERS))
2141       DoGadgetCallbackAction(gi, changed_position);
2142   }
2143
2144   if (gadget_released_inside)
2145   {
2146     boolean deactivate_gadget = TRUE;
2147     boolean gadget_changed = TRUE;
2148
2149     if (gi->type & GD_TYPE_SELECTBOX)
2150     {
2151       if (keep_selectbox_open ||
2152           mouse_released_where_pressed ||
2153           !gadget_released_inside_select_area ||
2154           !CURRENT_OPTION_SELECTABLE(gi))           // selectbox stays open
2155       {
2156         deactivate_gadget = FALSE;
2157         gadget_changed = FALSE;
2158       }
2159       else if (gi->selectbox.index != gi->selectbox.current_index)
2160         gi->selectbox.index = gi->selectbox.current_index;
2161       else
2162         gadget_changed = FALSE;
2163     }
2164
2165     if (deactivate_gadget &&
2166         !(gi->type & GD_TYPE_TEXT_INPUT ||
2167           gi->type & GD_TYPE_TEXT_AREA))            // text input stays open
2168       DrawGadget(gi, DG_UNPRESSED, gi->direct_draw);
2169
2170     gi->state = GD_BUTTON_UNPRESSED;
2171     gi->event.type = GD_EVENT_RELEASED;
2172
2173     if ((gi->event_mask & GD_EVENT_RELEASED))
2174       DoGadgetCallbackAction(gi, gadget_changed);
2175   }
2176
2177   if (gadget_released_off_borders)
2178   {
2179     if (gi->type & GD_TYPE_SCROLLBAR)
2180       DrawGadget(gi, DG_UNPRESSED, gi->direct_draw);
2181
2182     gi->state = GD_BUTTON_UNPRESSED;
2183     gi->event.type = GD_EVENT_RELEASED;
2184
2185     if (gi->event_mask & GD_EVENT_RELEASED &&
2186         gi->event_mask & GD_EVENT_OFF_BORDERS)
2187       gi->callback_action(gi);
2188   }
2189
2190   // handle gadgets unmapped/mapped between pressing and releasing
2191   if (release_event && !gadget_released && new_gi)
2192     new_gi->state = GD_BUTTON_UNPRESSED;
2193
2194   return (gadget_pressed || gadget_pressed_repeated ||
2195           gadget_released || gadget_moving);
2196 }
2197
2198 static void insertCharIntoTextArea(struct GadgetInfo *gi, char c)
2199 {
2200   char text[MAX_GADGET_TEXTSIZE + 1];
2201   int cursor_position = gi->textarea.cursor_position;
2202
2203   if (strlen(gi->textarea.value) >= MAX_GADGET_TEXTSIZE) // no space left
2204     return;
2205
2206   strcpy(text, gi->textarea.value);
2207   strcpy(&gi->textarea.value[cursor_position + 1], &text[cursor_position]);
2208   gi->textarea.value[cursor_position] = c;
2209
2210   setTextAreaCursorPosition(gi, gi->textarea.cursor_position + 1);
2211 }
2212
2213 boolean HandleGadgetsKeyInput(Key key)
2214 {
2215   struct GadgetInfo *gi = last_gi;
2216
2217   if (gi == NULL || gi->deactivated || !gi->mapped ||
2218       !(gi->type & GD_TYPE_TEXT_INPUT ||
2219         gi->type & GD_TYPE_TEXT_AREA ||
2220         gi->type & GD_TYPE_SELECTBOX))
2221     return FALSE;
2222
2223   if (key == KSYM_Escape)
2224   {
2225     if (anyTextGadgetActive())
2226     {
2227       // restore previous text (before activating text gadget)
2228       if (gi->type & GD_TYPE_TEXT_INPUT)
2229         strcpy(gi->textinput.value, gi->textinput.last_value);
2230
2231       DrawGadget(gi, DG_UNPRESSED, gi->direct_draw);
2232
2233       last_gi = NULL;
2234
2235       StopTextInput();
2236     }
2237   }
2238   else if (key == KSYM_Return)  // valid for both text input and selectbox
2239   {
2240     boolean gadget_changed = ((gi->event_mask & GD_EVENT_TEXT_RETURN) != 0);
2241
2242     if (gi->type & GD_TYPE_TEXT_INPUT)
2243     {
2244       CheckRangeOfNumericInputGadget(gi);
2245
2246       if (!strEqual(gi->textinput.last_value, gi->textinput.value))
2247         strcpy(gi->textinput.last_value, gi->textinput.value);
2248       else
2249         gadget_changed = FALSE;
2250
2251       StopTextInput();
2252     }
2253     else if (gi->type & GD_TYPE_SELECTBOX)
2254     {
2255       if (gi->selectbox.index != gi->selectbox.current_index)
2256         gi->selectbox.index = gi->selectbox.current_index;
2257       else
2258         gadget_changed = FALSE;
2259     }
2260
2261     if (gi->type & GD_TYPE_TEXT_AREA)
2262     {
2263       insertCharIntoTextArea(gi, '\n');
2264
2265       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2266     }
2267     else
2268     {
2269       DrawGadget(gi, DG_UNPRESSED, gi->direct_draw);
2270
2271       gi->event.type = GD_EVENT_TEXT_RETURN;
2272
2273       last_gi = NULL;
2274     }
2275
2276     DoGadgetCallbackAction(gi, gadget_changed);
2277   }
2278   else if (gi->type & GD_TYPE_TEXT_INPUT)       // only valid for text input
2279   {
2280     char text[MAX_GADGET_TEXTSIZE + 1];
2281     int text_length = strlen(gi->textinput.value);
2282     int cursor_pos = gi->textinput.cursor_position;
2283     char letter = getCharFromKey(key);
2284     boolean legal_letter = (gi->type == GD_TYPE_TEXT_INPUT_NUMERIC ?
2285                             letter >= '0' && letter <= '9' :
2286                             letter != 0);
2287
2288     if (legal_letter && text_length < gi->textinput.size)
2289     {
2290       strcpy(text, gi->textinput.value);
2291       strcpy(&gi->textinput.value[cursor_pos + 1], &text[cursor_pos]);
2292       gi->textinput.value[cursor_pos] = letter;
2293       gi->textinput.cursor_position++;
2294
2295       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2296     }
2297     else if (key == KSYM_Left && cursor_pos > 0)
2298     {
2299       gi->textinput.cursor_position--;
2300
2301       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2302     }
2303     else if (key == KSYM_Right && cursor_pos < text_length)
2304     {
2305       gi->textinput.cursor_position++;
2306
2307       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2308     }
2309     else if (key == KSYM_BackSpace && cursor_pos > 0)
2310     {
2311       strcpy(text, gi->textinput.value);
2312       strcpy(&gi->textinput.value[cursor_pos - 1], &text[cursor_pos]);
2313       gi->textinput.cursor_position--;
2314
2315       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2316     }
2317     else if (key == KSYM_Delete && cursor_pos < text_length)
2318     {
2319       strcpy(text, gi->textinput.value);
2320       strcpy(&gi->textinput.value[cursor_pos], &text[cursor_pos + 1]);
2321
2322       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2323     }
2324   }
2325   else if (gi->type & GD_TYPE_TEXT_AREA)        // only valid for text area
2326   {
2327     char text[MAX_GADGET_TEXTSIZE + 1];
2328     int text_length = strlen(gi->textarea.value);
2329     int area_ysize = gi->textarea.ysize;
2330     int cursor_x_pref = gi->textarea.cursor_x_preferred;
2331     int cursor_y = gi->textarea.cursor_y;
2332     int cursor_pos = gi->textarea.cursor_position;
2333     char letter = getCharFromKey(key);
2334     boolean legal_letter = (letter != 0);
2335
2336     if (legal_letter)
2337     {
2338       insertCharIntoTextArea(gi, letter);
2339
2340       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2341     }
2342     else if (key == KSYM_Left && cursor_pos > 0)
2343     {
2344       setTextAreaCursorPosition(gi, gi->textarea.cursor_position - 1);
2345
2346       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2347     }
2348     else if (key == KSYM_Right && cursor_pos < text_length)
2349     {
2350       setTextAreaCursorPosition(gi, gi->textarea.cursor_position + 1);
2351
2352       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2353     }
2354     else if (key == KSYM_Up && cursor_y > 0)
2355     {
2356       setTextAreaCursorXY(gi, cursor_x_pref, cursor_y - 1);
2357       gi->textarea.cursor_x_preferred = cursor_x_pref;
2358
2359       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2360     }
2361     else if (key == KSYM_Down && cursor_y < area_ysize - 1)
2362     {
2363       setTextAreaCursorXY(gi, cursor_x_pref, cursor_y + 1);
2364       gi->textarea.cursor_x_preferred = cursor_x_pref;
2365
2366       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2367     }
2368     else if (key == KSYM_BackSpace && cursor_pos > 0)
2369     {
2370       strcpy(text, gi->textarea.value);
2371       strcpy(&gi->textarea.value[cursor_pos - 1], &text[cursor_pos]);
2372
2373       setTextAreaCursorPosition(gi, gi->textarea.cursor_position - 1);
2374
2375       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2376     }
2377     else if (key == KSYM_Delete && cursor_pos < text_length)
2378     {
2379       strcpy(text, gi->textarea.value);
2380       strcpy(&gi->textarea.value[cursor_pos], &text[cursor_pos + 1]);
2381
2382       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2383     }
2384   }
2385   else if (gi->type & GD_TYPE_SELECTBOX)        // only valid for selectbox
2386   {
2387     int index = gi->selectbox.current_index;
2388     int num_values = gi->selectbox.num_values;
2389
2390     if (key == KSYM_Up && index > 0)
2391     {
2392       gi->selectbox.current_index--;
2393
2394       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2395     }
2396     else if (key == KSYM_Down && index < num_values - 1)
2397     {
2398       gi->selectbox.current_index++;
2399
2400       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2401     }
2402   }
2403
2404   return TRUE;
2405 }
2406
2407 void DumpGadgetIdentifiers(void)
2408 {
2409   struct GadgetInfo *gi;
2410
2411   Print("Gadgets on current screen:\n");
2412
2413   for (gi = gadget_list_first_entry; gi != NULL; gi = gi->next)
2414   {
2415     if (gi->mapped && gi->image_id != -1)
2416     {
2417       char *token = getTokenFromImageID(gi->image_id);
2418       char *prefix = "gfx.";
2419
2420       if (strPrefix(token, prefix))
2421         token = &token[strlen(prefix)];
2422
2423       Print("- '%s'\n", token);
2424     }
2425   }
2426
2427   Print("Done.\n");
2428 }
2429
2430 boolean DoGadgetAction(int image_id)
2431 {
2432   struct GadgetInfo *gi;
2433
2434   for (gi = gadget_list_first_entry; gi != NULL; gi = gi->next)
2435   {
2436     if (gi->mapped && gi->image_id == image_id)
2437     {
2438       gi->callback_action(gi);
2439
2440       return TRUE;
2441     }
2442   }
2443
2444   return FALSE;
2445 }