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