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_CUSTOM_ID:
 786         gi->custom_id = va_arg(ap, int);
 787         break;
 788
 789       case GDI_CUSTOM_TYPE_ID:
 790         gi->custom_type_id = va_arg(ap, int);
 791         break;
 792
 793       case GDI_INFO_TEXT:
 794         {
 795           int max_textsize = MAX_INFO_TEXTSIZE;
 796           char *text = va_arg(ap, char *);
 797
 798           if (text != NULL)
 799             strncpy(gi->info_text, text, max_textsize);
 800           else
 801             max_textsize = 0;
 802
 803           gi->info_text[max_textsize] = '\0';
 804         }
 805         break;
 806
 807       case GDI_X:
 808         gi->x = va_arg(ap, int);
 809         break;
 810
 811       case GDI_Y:
 812         gi->y = va_arg(ap, int);
 813         break;
 814
 815       case GDI_WIDTH:
 816         gi->width = va_arg(ap, int);
 817         break;
 818
 819       case GDI_HEIGHT:
 820         gi->height = va_arg(ap, int);
 821         break;
 822
 823       case GDI_TYPE:
 824         gi->type = va_arg(ap, unsigned int);
 825         break;
 826
 827       case GDI_STATE:
 828         gi->state = va_arg(ap, unsigned int);
 829         break;
 830
 831       case GDI_ACTIVE:
 832         gi->active = (boolean)va_arg(ap, int);
 833         break;
 834
 835       case GDI_DIRECT_DRAW:
 836         gi->direct_draw = (boolean)va_arg(ap, int);
 837         break;
 838
 839       case GDI_CHECKED:
 840         gi->checked = (boolean)va_arg(ap, int);
 841         break;
 842
 843       case GDI_RADIO_NR:
 844         gi->radio_nr = va_arg(ap, unsigned int);
 845         break;
 846
 847       case GDI_NUMBER_VALUE:
 848         gi->textinput.number_value = va_arg(ap, int);
 849         sprintf(gi->textinput.value, "%d", gi->textinput.number_value);
 850         strcpy(gi->textinput.last_value, gi->textinput.value);
 851         gi->textinput.cursor_position = strlen(gi->textinput.value);
 852         break;
 853
 854       case GDI_NUMBER_MIN:
 855         gi->textinput.number_min = va_arg(ap, int);
 856         if (gi->textinput.number_value < gi->textinput.number_min)
 857         {
 858           gi->textinput.number_value = gi->textinput.number_min;
 859           sprintf(gi->textinput.value, "%d", gi->textinput.number_value);
 860           strcpy(gi->textinput.last_value, gi->textinput.value);
 861         }
 862         break;
 863
 864       case GDI_NUMBER_MAX:
 865         gi->textinput.number_max = va_arg(ap, int);
 866         if (gi->textinput.number_value > gi->textinput.number_max)
 867         {
 868           gi->textinput.number_value = gi->textinput.number_max;
 869           sprintf(gi->textinput.value, "%d", gi->textinput.number_value);
 870           strcpy(gi->textinput.last_value, gi->textinput.value);
 871         }
 872         break;
 873
 874       case GDI_TEXT_VALUE:
 875         {
 876           int max_textsize = MAX_GADGET_TEXTSIZE;
 877
 878           if (gi->textinput.size)
 879             max_textsize = MIN(gi->textinput.size, MAX_GADGET_TEXTSIZE);
 880
 881           strncpy(gi->textinput.value, va_arg(ap, char *), max_textsize);
 882           strcpy(gi->textinput.last_value, gi->textinput.value);
 883
 884           gi->textinput.value[max_textsize] = '\0';
 885           gi->textinput.cursor_position = strlen(gi->textinput.value);
 886
 887           /* same tag also used for other gadget definitions */
 888           strcpy(gi->textbutton.value, gi->textinput.value);
 889           strcpy(gi->textarea.value, gi->textinput.value);
 890           strcpy(gi->textarea.last_value, gi->textinput.value);
 891         }
 892         break;
 893
 894       case GDI_TEXT_SIZE:
 895         {
 896           int tag_value = va_arg(ap, int);
 897           int max_textsize = MIN(tag_value, MAX_GADGET_TEXTSIZE);
 898
 899           gi->textinput.size = max_textsize;
 900           gi->textinput.value[max_textsize] = '\0';
 901           strcpy(gi->textinput.last_value, gi->textinput.value);
 902
 903           /* same tag also used for other gadget definitions */
 904
 905           gi->textarea.size = max_textsize;
 906           gi->textarea.value[max_textsize] = '\0';
 907           strcpy(gi->textarea.last_value, gi->textinput.value);
 908
 909           gi->textbutton.size = max_textsize;
 910           gi->textbutton.value[max_textsize] = '\0';
 911
 912           gi->selectbox.size = gi->textinput.size;
 913         }
 914         break;
 915
 916       case GDI_TEXT_FONT:
 917         gi->font = va_arg(ap, int);
 918         if (gi->font_active == 0)
 919           gi->font_active = gi->font;
 920         if (gi->font_unselectable == 0)
 921           gi->font_unselectable = gi->font;
 922         break;
 923
 924       case GDI_TEXT_FONT_ACTIVE:
 925         gi->font_active = va_arg(ap, int);
 926         break;
 927
 928       case GDI_TEXT_FONT_UNSELECTABLE:
 929         gi->font_unselectable = va_arg(ap, int);
 930         break;
 931
 932       case GDI_SELECTBOX_OPTIONS:
 933         gi->selectbox.options = va_arg(ap, struct ValueTextInfo *);
 934         break;
 935
 936       case GDI_SELECTBOX_INDEX:
 937         gi->selectbox.index = va_arg(ap, int);
 938         break;
 939
 940       case GDI_SELECTBOX_CHAR_UNSELECTABLE:
 941         gi->selectbox.char_unselectable = (char)va_arg(ap, int);
 942         break;
 943
 944       case GDI_DESIGN_UNPRESSED:
 945         gi->design[GD_BUTTON_UNPRESSED].bitmap = va_arg(ap, Bitmap *);
 946         gi->design[GD_BUTTON_UNPRESSED].x = va_arg(ap, int);
 947         gi->design[GD_BUTTON_UNPRESSED].y = va_arg(ap, int);
 948         break;
 949
 950       case GDI_DESIGN_PRESSED:
 951         gi->design[GD_BUTTON_PRESSED].bitmap = va_arg(ap, Bitmap *);
 952         gi->design[GD_BUTTON_PRESSED].x = va_arg(ap, int);
 953         gi->design[GD_BUTTON_PRESSED].y = va_arg(ap, int);
 954         break;
 955
 956       case GDI_ALT_DESIGN_UNPRESSED:
 957         gi->alt_design[GD_BUTTON_UNPRESSED].bitmap= va_arg(ap, Bitmap *);
 958         gi->alt_design[GD_BUTTON_UNPRESSED].x = va_arg(ap, int);
 959         gi->alt_design[GD_BUTTON_UNPRESSED].y = va_arg(ap, int);
 960         break;
 961
 962       case GDI_ALT_DESIGN_PRESSED:
 963         gi->alt_design[GD_BUTTON_PRESSED].bitmap = va_arg(ap, Bitmap *);
 964         gi->alt_design[GD_BUTTON_PRESSED].x = va_arg(ap, int);
 965         gi->alt_design[GD_BUTTON_PRESSED].y = va_arg(ap, int);
 966         break;
 967
 968       case GDI_BORDER_SIZE:
 969         gi->border.xsize = va_arg(ap, int);
 970         gi->border.ysize = va_arg(ap, int);
 971         break;
 972
 973       case GDI_BORDER_SIZE_SELECTBUTTON:
 974         gi->border.xsize_selectbutton = va_arg(ap, int);
 975         break;
 976
 977       case GDI_DESIGN_WIDTH:
 978         gi->border.width = va_arg(ap, int);
 979         break;
 980
 981       case GDI_DECORATION_DESIGN:
 982         gi->deco.design.bitmap = va_arg(ap, Bitmap *);
 983         gi->deco.design.x = va_arg(ap, int);
 984         gi->deco.design.y = va_arg(ap, int);
 985         break;
 986
 987       case GDI_DECORATION_POSITION:
 988         gi->deco.x = va_arg(ap, int);
 989         gi->deco.y = va_arg(ap, int);
 990         break;
 991
 992       case GDI_DECORATION_SIZE:
 993         gi->deco.width = va_arg(ap, int);
 994         gi->deco.height = va_arg(ap, int);
 995         break;
 996
 997       case GDI_DECORATION_SHIFTING:
 998         gi->deco.xshift = va_arg(ap, int);
 999         gi->deco.yshift = va_arg(ap, int);
1000         break;
1001
1002       case GDI_DECORATION_MASKED:
1003         gi->deco.masked = (boolean)va_arg(ap, int);
1004         break;
1005
1006       case GDI_EVENT_MASK:
1007         gi->event_mask = va_arg(ap, unsigned int);
1008         break;
1009
1010       case GDI_AREA_SIZE:
1011         gi->drawing.area_xsize = va_arg(ap, int);
1012         gi->drawing.area_ysize = va_arg(ap, int);
1013
1014         /* determine dependent values for drawing area gadget, if needed */
1015         if (gi->drawing.item_xsize != 0 && gi->drawing.item_ysize != 0)
1016         {
1017           gi->width = gi->drawing.area_xsize * gi->drawing.item_xsize;
1018           gi->height = gi->drawing.area_ysize * gi->drawing.item_ysize;
1019         }
1020         else if (gi->width != 0 && gi->height != 0)
1021         {
1022           gi->drawing.item_xsize = gi->width / gi->drawing.area_xsize;
1023           gi->drawing.item_ysize = gi->height / gi->drawing.area_ysize;
1024         }
1025
1026         /* same tag also used for other gadget definitions */
1027         gi->textarea.xsize = gi->drawing.area_xsize;
1028         gi->textarea.ysize = gi->drawing.area_ysize;
1029
1030         if (gi->type & GD_TYPE_TEXT_AREA)       /* force recalculation */
1031         {
1032           gi->width = 0;
1033           gi->height = 0;
1034         }
1035
1036         break;
1037
1038       case GDI_ITEM_SIZE:
1039         gi->drawing.item_xsize = va_arg(ap, int);
1040         gi->drawing.item_ysize = va_arg(ap, int);
1041
1042         /* determine dependent values for drawing area gadget, if needed */
1043         if (gi->drawing.area_xsize != 0 && gi->drawing.area_ysize != 0)
1044         {
1045           gi->width = gi->drawing.area_xsize * gi->drawing.item_xsize;
1046           gi->height = gi->drawing.area_ysize * gi->drawing.item_ysize;
1047         }
1048         else if (gi->width != 0 && gi->height != 0)
1049         {
1050           gi->drawing.area_xsize = gi->width / gi->drawing.item_xsize;
1051           gi->drawing.area_ysize = gi->height / gi->drawing.item_ysize;
1052         }
1053         break;
1054
1055       case GDI_SCROLLBAR_ITEMS_MAX:
1056         gi->scrollbar.items_max = va_arg(ap, int);
1057         break;
1058
1059       case GDI_SCROLLBAR_ITEMS_VISIBLE:
1060         gi->scrollbar.items_visible = va_arg(ap, int);
1061         break;
1062
1063       case GDI_SCROLLBAR_ITEM_POSITION:
1064         gi->scrollbar.item_position = va_arg(ap, int);
1065         break;
1066
1067       case GDI_WHEEL_AREA_X:
1068         gi->wheelarea.x = va_arg(ap, int);
1069         break;
1070
1071       case GDI_WHEEL_AREA_Y:
1072         gi->wheelarea.y = va_arg(ap, int);
1073         break;
1074
1075       case GDI_WHEEL_AREA_WIDTH:
1076         gi->wheelarea.width = va_arg(ap, int);
1077         break;
1078
1079       case GDI_WHEEL_AREA_HEIGHT:
1080         gi->wheelarea.height = va_arg(ap, int);
1081         break;
1082
1083       case GDI_CALLBACK_INFO:
1084         gi->callback_info = va_arg(ap, gadget_function);
1085         break;
1086
1087       case GDI_CALLBACK_ACTION:
1088         gi->callback_action = va_arg(ap, gadget_function);
1089         break;
1090
1091       default:
1092         Error(ERR_EXIT, "HandleGadgetTags(): unknown tag %d", tag);
1093     }
1094
1095     tag = va_arg(ap, int);      /* read next tag */
1096   }
1097
1098   gi->deactivated = FALSE;
1099
1100   /* check if gadget has undefined bitmaps */
1101   if (gi->type != GD_TYPE_DRAWING_AREA &&
1102       (gi->design[GD_BUTTON_UNPRESSED].bitmap == NULL ||
1103        gi->design[GD_BUTTON_PRESSED].bitmap == NULL))
1104     gi->deactivated = TRUE;
1105
1106   /* check if gadget is placed off-screen */
1107   if (gi->x < 0 || gi->y < 0)
1108     gi->deactivated = TRUE;
1109
1110   /* adjust gadget values in relation to other gadget values */
1111
1112   if (gi->type & GD_TYPE_TEXT_INPUT)
1113   {
1114     int font_nr = gi->font_active;
1115     int font_width = getFontWidth(font_nr);
1116     int font_height = getFontHeight(font_nr);
1117     int border_xsize = gi->border.xsize;
1118     int border_ysize = gi->border.ysize;
1119
1120     if (gi->type == GD_TYPE_TEXT_INPUT_NUMERIC)
1121     {
1122       int number_min = gi->textinput.number_min;
1123       int number_max = gi->textinput.number_max;
1124       int min_size_min = get_minimal_size_for_numeric_input(number_min);
1125       int min_size_max = get_minimal_size_for_numeric_input(number_max);
1126       int min_size = MAX(min_size_min, min_size_max);
1127
1128       /* expand gadget text input size, if maximal value is too large */
1129       if (gi->textinput.size < min_size)
1130         gi->textinput.size = min_size;
1131     }
1132
1133     gi->width  = 2 * border_xsize + (gi->textinput.size + 1) * font_width;
1134     gi->height = 2 * border_ysize + font_height;
1135   }
1136
1137   if (gi->type & GD_TYPE_SELECTBOX)
1138   {
1139     int font_nr = gi->font_active;
1140     int font_width = getFontWidth(font_nr);
1141     int font_height = getFontHeight(font_nr);
1142     int border_xsize = gi->border.xsize;
1143     int border_ysize = gi->border.ysize;
1144     int button_size = gi->border.xsize_selectbutton;
1145     int bottom_screen_border = gfx.sy + gfx.sysize - font_height;
1146     Bitmap *src_bitmap;
1147     int src_x, src_y;
1148
1149     gi->width  = 2 * border_xsize + gi->textinput.size*font_width +button_size;
1150     gi->height = 2 * border_ysize + font_height;
1151
1152     if (gi->selectbox.options == NULL)
1153       Error(ERR_EXIT, "selectbox gadget incomplete (missing options array)");
1154
1155     gi->selectbox.num_values = 0;
1156     while (gi->selectbox.options[gi->selectbox.num_values].text != NULL)
1157       gi->selectbox.num_values++;
1158
1159     /* calculate values for open selectbox */
1160     gi->selectbox.width = gi->width;
1161     gi->selectbox.height =
1162       2 * border_ysize + gi->selectbox.num_values * font_height;
1163
1164     gi->selectbox.x = gi->x;
1165     gi->selectbox.y = gi->y + gi->height;
1166     if (gi->selectbox.y + gi->selectbox.height > bottom_screen_border)
1167       gi->selectbox.y = gi->y - gi->selectbox.height;
1168     if (gi->selectbox.y < 0)
1169       gi->selectbox.y = bottom_screen_border - gi->selectbox.height;
1170
1171     getFontCharSource(font_nr, FONT_ASCII_CURSOR, &src_bitmap, &src_x, &src_y);
1172     src_x += font_width / 2;
1173     src_y += font_height / 2;
1174
1175     /* there may be esoteric cases with missing or too small font bitmap */
1176     if (src_bitmap != NULL &&
1177         src_x < src_bitmap->width && src_y < src_bitmap->height)
1178       gi->selectbox.inverse_color = GetPixel(src_bitmap, src_x, src_y);
1179
1180     /* always start with closed selectbox */
1181     gi->selectbox.open = FALSE;
1182   }
1183
1184   if (gi->type & GD_TYPE_TEXT_INPUT_NUMERIC)
1185   {
1186     struct GadgetTextInput *text = &gi->textinput;
1187     int value = text->number_value;
1188
1189     text->number_value = (value < text->number_min ? text->number_min :
1190                           value > text->number_max ? text->number_max :
1191                           value);
1192
1193     sprintf(text->value, "%d", text->number_value);
1194   }
1195
1196   if (gi->type & GD_TYPE_TEXT_BUTTON)
1197   {
1198     int font_nr = gi->font_active;
1199     int font_width = getFontWidth(font_nr);
1200     int font_height = getFontHeight(font_nr);
1201     int border_xsize = gi->border.xsize;
1202     int border_ysize = gi->border.ysize;
1203
1204     gi->width  = 2 * border_xsize + gi->textbutton.size * font_width;
1205     gi->height = 2 * border_ysize + font_height;
1206   }
1207
1208   if (gi->type & GD_TYPE_SCROLLBAR)
1209   {
1210     struct GadgetScrollbar *gs = &gi->scrollbar;
1211     int scrollbar_size_cmp;
1212
1213     if (gi->width == 0 || gi->height == 0 ||
1214         gs->items_max == 0 || gs->items_visible == 0)
1215       Error(ERR_EXIT, "scrollbar gadget incomplete (missing tags)");
1216
1217     /* calculate internal scrollbar values */
1218     gs->size_min = (gi->type == GD_TYPE_SCROLLBAR_VERTICAL ?
1219                     gi->width : gi->height);
1220     gs->size_max = (gi->type == GD_TYPE_SCROLLBAR_VERTICAL ?
1221                     gi->height : gi->width);
1222
1223     scrollbar_size_cmp = gs->size_max * gs->items_visible / gs->items_max;
1224     gs->size = MAX(scrollbar_size_cmp, gs->size_min);
1225     gs->size_max_cmp = (gs->size_max - (gs->size - scrollbar_size_cmp));
1226
1227     gs->position = gs->size_max_cmp * gs->item_position / gs->items_max;
1228     gs->position_max = gs->size_max - gs->size;
1229     gs->correction = gs->size_max / gs->items_max / 2;
1230
1231     /* finetuning for maximal right/bottom position */
1232     if (gs->item_position == gs->items_max - gs->items_visible)
1233       gs->position = gs->position_max;
1234   }
1235
1236   if (gi->type & GD_TYPE_TEXT_AREA)
1237   {
1238     int font_nr = gi->font_active;
1239     int font_width = getFontWidth(font_nr);
1240     int font_height = getFontHeight(font_nr);
1241     int border_xsize = gi->border.xsize;
1242     int border_ysize = gi->border.ysize;
1243
1244     if (gi->width == 0 || gi->height == 0)
1245     {
1246       gi->width  = 2 * border_xsize + gi->textarea.xsize * font_width;
1247       gi->height = 2 * border_ysize + gi->textarea.ysize * font_height;
1248     }
1249     else
1250     {
1251       gi->textarea.xsize = (gi->width  - 2 * border_xsize) / font_width;
1252       gi->textarea.ysize = (gi->height - 2 * border_ysize) / font_height;
1253     }
1254   }
1255 }
1256
1257 void ModifyGadget(struct GadgetInfo *gi, int first_tag, ...)
1258 {
1259   va_list ap;
1260
1261   va_start(ap, first_tag);
1262   HandleGadgetTags(gi, first_tag, ap);
1263   va_end(ap);
1264
1265   RedrawGadget(gi);
1266 }
1267
1268 void RedrawGadget(struct GadgetInfo *gi)
1269 {
1270   if (gi == NULL || gi->deactivated)
1271     return;
1272
1273   if (gi->mapped)
1274     DrawGadget(gi, gi->state, gi->direct_draw);
1275 }
1276
1277 struct GadgetInfo *CreateGadget(int first_tag, ...)
1278 {
1279   struct GadgetInfo *new_gadget = checked_calloc(sizeof(struct GadgetInfo));
1280   va_list ap;
1281
1282   /* always start with reliable default values */
1283   new_gadget->id = getNewGadgetID();
1284   new_gadget->callback_info = default_callback_info;
1285   new_gadget->callback_action = default_callback_action;
1286   new_gadget->active = TRUE;
1287   new_gadget->direct_draw = TRUE;
1288
1289   new_gadget->next = NULL;
1290
1291   va_start(ap, first_tag);
1292   HandleGadgetTags(new_gadget, first_tag, ap);
1293   va_end(ap);
1294
1295   /* insert new gadget into global gadget list */
1296   if (gadget_list_last_entry)
1297   {
1298     gadget_list_last_entry->next = new_gadget;
1299     gadget_list_last_entry = gadget_list_last_entry->next;
1300   }
1301   else
1302     gadget_list_first_entry = gadget_list_last_entry = new_gadget;
1303
1304   return new_gadget;
1305 }
1306
1307 void FreeGadget(struct GadgetInfo *gi)
1308 {
1309   struct GadgetInfo *gi_previous = gadget_list_first_entry;
1310
1311   if (gi == NULL)
1312     return;
1313
1314   /* prevent "last_info_gi" from pointing to memory that will be freed */
1315   if (last_info_gi == gi)
1316     last_info_gi = NULL;
1317
1318   while (gi_previous != NULL && gi_previous->next != gi)
1319     gi_previous = gi_previous->next;
1320
1321   if (gi == gadget_list_first_entry)
1322     gadget_list_first_entry = gi->next;
1323
1324   if (gi == gadget_list_last_entry)
1325     gadget_list_last_entry = gi_previous;
1326
1327   if (gi_previous != NULL)
1328     gi_previous->next = gi->next;
1329
1330   free(gi);
1331 }
1332
1333 static void CheckRangeOfNumericInputGadget(struct GadgetInfo *gi)
1334 {
1335   if (gi->type != GD_TYPE_TEXT_INPUT_NUMERIC)
1336     return;
1337
1338   gi->textinput.number_value = atoi(gi->textinput.value);
1339
1340   if (gi->textinput.number_value < gi->textinput.number_min)
1341     gi->textinput.number_value = gi->textinput.number_min;
1342   if (gi->textinput.number_value > gi->textinput.number_max)
1343     gi->textinput.number_value = gi->textinput.number_max;
1344
1345   sprintf(gi->textinput.value, "%d", gi->textinput.number_value);
1346
1347   if (gi->textinput.cursor_position < 0)
1348     gi->textinput.cursor_position = 0;
1349   else if (gi->textinput.cursor_position > strlen(gi->textinput.value))
1350     gi->textinput.cursor_position = strlen(gi->textinput.value);
1351 }
1352
1353 /* global pointer to gadget actually in use (when mouse button pressed) */
1354 static struct GadgetInfo *last_gi = NULL;
1355
1356 static void MapGadgetExt(struct GadgetInfo *gi, boolean redraw)
1357 {
1358   if (gi == NULL || gi->deactivated || gi->mapped)
1359     return;
1360
1361   gi->mapped = TRUE;
1362
1363   if (redraw)
1364     DrawGadget(gi, DG_UNPRESSED, DG_BUFFERED);
1365 }
1366
1367 void MapGadget(struct GadgetInfo *gi)
1368 {
1369   MapGadgetExt(gi, TRUE);
1370 }
1371
1372 void UnmapGadget(struct GadgetInfo *gi)
1373 {
1374   if (gi == NULL || gi->deactivated || !gi->mapped)
1375     return;
1376
1377   gi->mapped = FALSE;
1378
1379   if (gi == last_gi)
1380     last_gi = NULL;
1381 }
1382
1383 #define MAX_NUM_GADGETS         1024
1384 #define MULTIMAP_UNMAP          (1 << 0)
1385 #define MULTIMAP_REMAP          (1 << 1)
1386 #define MULTIMAP_REDRAW         (1 << 2)
1387 #define MULTIMAP_PLAYFIELD      (1 << 3)
1388 #define MULTIMAP_DOOR_1         (1 << 4)
1389 #define MULTIMAP_DOOR_2         (1 << 5)
1390 #define MULTIMAP_DOOR_3         (1 << 6)
1391 #define MULTIMAP_ALL            (MULTIMAP_PLAYFIELD | \
1392                                  MULTIMAP_DOOR_1    | \
1393                                  MULTIMAP_DOOR_2    | \
1394                                  MULTIMAP_DOOR_3)
1395
1396 static void MultiMapGadgets(int mode)
1397 {
1398   struct GadgetInfo *gi = gadget_list_first_entry;
1399   static boolean map_state[MAX_NUM_GADGETS];
1400   int map_count = 0;
1401
1402   while (gi != NULL)
1403   {
1404     int x = gi->x;
1405     int y = gi->y;
1406
1407     if ((mode & MULTIMAP_PLAYFIELD && IN_GFX_FIELD_FULL(x, y)) ||
1408         (mode & MULTIMAP_DOOR_1 && IN_GFX_DOOR_1(x, y)) ||
1409         (mode & MULTIMAP_DOOR_2 && IN_GFX_DOOR_2(x, y)) ||
1410         (mode & MULTIMAP_DOOR_3 && IN_GFX_DOOR_3(x, y)) ||
1411         (mode & MULTIMAP_ALL) == MULTIMAP_ALL)
1412     {
1413       if (mode & MULTIMAP_UNMAP)
1414       {
1415         map_state[map_count++ % MAX_NUM_GADGETS] = gi->mapped;
1416         UnmapGadget(gi);
1417       }
1418       else
1419       {
1420         if (map_state[map_count++ % MAX_NUM_GADGETS])
1421           MapGadgetExt(gi, (mode & MULTIMAP_REDRAW));
1422       }
1423     }
1424
1425     gi = gi->next;
1426   }
1427 }
1428
1429 void UnmapAllGadgets()
1430 {
1431   MultiMapGadgets(MULTIMAP_ALL | MULTIMAP_UNMAP);
1432 }
1433
1434 void RemapAllGadgets()
1435 {
1436   MultiMapGadgets(MULTIMAP_ALL | MULTIMAP_REMAP);
1437 }
1438
1439 boolean anyTextInputGadgetActive()
1440 {
1441   return (last_gi && (last_gi->type & GD_TYPE_TEXT_INPUT) && last_gi->mapped);
1442 }
1443
1444 boolean anyTextAreaGadgetActive()
1445 {
1446   return (last_gi && (last_gi->type & GD_TYPE_TEXT_AREA) && last_gi->mapped);
1447 }
1448
1449 boolean anySelectboxGadgetActive()
1450 {
1451   return (last_gi && (last_gi->type & GD_TYPE_SELECTBOX) && last_gi->mapped);
1452 }
1453
1454 boolean anyScrollbarGadgetActive()
1455 {
1456   return (last_gi && (last_gi->type & GD_TYPE_SCROLLBAR) && last_gi->mapped);
1457 }
1458
1459 boolean anyTextGadgetActive()
1460 {
1461   return (anyTextInputGadgetActive() ||
1462           anyTextAreaGadgetActive() ||
1463           anySelectboxGadgetActive());
1464 }
1465
1466 static boolean insideSelectboxLine(struct GadgetInfo *gi, int mx, int my)
1467 {
1468   return (gi != NULL &&
1469           gi->type & GD_TYPE_SELECTBOX &&
1470           mx >= gi->x && mx < gi->x + gi->width &&
1471           my >= gi->y && my < gi->y + gi->height);
1472 }
1473
1474 static boolean insideSelectboxArea(struct GadgetInfo *gi, int mx, int my)
1475 {
1476   return (gi != NULL &&
1477           gi->type & GD_TYPE_SELECTBOX &&
1478           mx >= gi->selectbox.x && mx < gi->selectbox.x + gi->selectbox.width &&
1479           my >= gi->selectbox.y && my < gi->selectbox.y + gi->selectbox.height);
1480 }
1481
1482 void ClickOnGadget(struct GadgetInfo *gi, int button)
1483 {
1484   if (!gi->mapped)
1485     return;
1486
1487   /* simulate releasing mouse button over last gadget, if still pressed */
1488   if (button_status)
1489     HandleGadgets(-1, -1, 0);
1490
1491   /* simulate pressing mouse button over specified gadget */
1492   HandleGadgets(gi->x, gi->y, button);
1493
1494   /* simulate releasing mouse button over specified gadget */
1495   HandleGadgets(gi->x, gi->y, 0);
1496 }
1497
1498 boolean HandleGadgets(int mx, int my, int button)
1499 {
1500   static unsigned int pressed_delay = 0;
1501   static unsigned int pressed_delay_value = GADGET_FRAME_DELAY;
1502   static int last_button = 0;
1503   static int last_mx = 0, last_my = 0;
1504   static int pressed_mx = 0, pressed_my = 0;
1505   static boolean keep_selectbox_open = FALSE;
1506   static boolean gadget_stopped = FALSE;
1507   int scrollbar_mouse_pos = 0;
1508   struct GadgetInfo *new_gi, *gi;
1509   boolean press_event;
1510   boolean release_event;
1511   boolean mouse_moving;
1512   boolean mouse_inside_select_line;
1513   boolean mouse_inside_select_area;
1514   boolean mouse_released_where_pressed;
1515   boolean gadget_pressed;
1516   boolean gadget_pressed_repeated;
1517   boolean gadget_pressed_off_borders;
1518   boolean gadget_pressed_inside_select_line;
1519   boolean gadget_pressed_delay_reached;
1520   boolean gadget_moving;
1521   boolean gadget_moving_inside;
1522   boolean gadget_moving_off_borders;
1523   boolean gadget_draggable;
1524   boolean gadget_dragging;
1525   boolean gadget_released;
1526   boolean gadget_released_inside;
1527   boolean gadget_released_inside_select_area;
1528   boolean gadget_released_off_borders;
1529   boolean changed_position = FALSE;
1530
1531   /* check if there are any gadgets defined */
1532   if (gadget_list_first_entry == NULL)
1533     return FALSE;
1534
1535   /* simulated release of mouse button over last gadget */
1536   if (mx == -1 && my == -1 && button == 0)
1537   {
1538     mx = last_mx;
1539     my = last_my;
1540   }
1541
1542   /* check which gadget is under the mouse pointer */
1543   new_gi = getGadgetInfoFromMousePosition(mx, my, button);
1544
1545   /* check if button state has changed since last invocation */
1546   press_event   = (button != 0 && last_button == 0);
1547   release_event = (button == 0 && last_button != 0);
1548   last_button = button;
1549
1550   /* check if mouse has been moved since last invocation */
1551   mouse_moving = ((mx != last_mx || my != last_my) && motion_status);
1552   last_mx = mx;
1553   last_my = my;
1554
1555   if (press_event && new_gi != last_gi)
1556   {
1557     pressed_mx = mx;
1558     pressed_my = my;
1559   }
1560
1561   mouse_released_where_pressed =
1562     (release_event && mx == pressed_mx && my == pressed_my);
1563
1564   mouse_inside_select_line = insideSelectboxLine(new_gi, mx, my);
1565   mouse_inside_select_area = insideSelectboxArea(new_gi, mx, my);
1566
1567   gadget_pressed_off_borders = (press_event && new_gi != last_gi);
1568
1569   gadget_pressed_inside_select_line =
1570     (press_event && new_gi != NULL &&
1571      new_gi->type & GD_TYPE_SELECTBOX && new_gi->selectbox.open &&
1572      insideSelectboxLine(new_gi, mx, my));
1573
1574   /* if mouse button pressed outside text or selectbox gadget, deactivate it */
1575   if (anyTextGadgetActive() &&
1576       (gadget_pressed_off_borders ||
1577        (gadget_pressed_inside_select_line && !mouse_inside_select_area)))
1578   {
1579     struct GadgetInfo *gi = last_gi;
1580     boolean gadget_changed = ((gi->event_mask & GD_EVENT_TEXT_LEAVING) != 0);
1581
1582     /* check if text gadget has changed its value */
1583     if (gi->type & GD_TYPE_TEXT_INPUT)
1584     {
1585       CheckRangeOfNumericInputGadget(gi);
1586
1587       if (!strEqual(gi->textinput.last_value, gi->textinput.value))
1588         strcpy(gi->textinput.last_value, gi->textinput.value);
1589       else
1590         gadget_changed = FALSE;
1591     }
1592
1593     /* selectbox does not change its value when closed by clicking outside */
1594     if (gi->type & GD_TYPE_SELECTBOX)
1595       gadget_changed = FALSE;
1596
1597     DrawGadget(gi, DG_UNPRESSED, gi->direct_draw);
1598
1599     gi->event.type = GD_EVENT_TEXT_LEAVING;
1600
1601     if (gadget_changed && !(gi->type & GD_TYPE_SELECTBOX))
1602       gi->callback_action(gi);
1603
1604     last_gi = NULL;
1605
1606     if (gadget_pressed_inside_select_line)
1607       new_gi = NULL;
1608
1609     StopTextInput();
1610   }
1611
1612   gadget_pressed =
1613     (button != 0 && last_gi == NULL && new_gi != NULL && press_event);
1614   gadget_pressed_repeated =
1615     (button != 0 && last_gi != NULL && new_gi == last_gi);
1616
1617   gadget_pressed_delay_reached =
1618     DelayReached(&pressed_delay, pressed_delay_value);
1619
1620   gadget_released =             (release_event && last_gi != NULL);
1621   gadget_released_inside =      (gadget_released && new_gi == last_gi);
1622   gadget_released_off_borders = (gadget_released && new_gi != last_gi);
1623
1624   gadget_moving =             (button != 0 && last_gi != NULL && mouse_moving);
1625   gadget_moving_inside =      (gadget_moving && new_gi == last_gi);
1626   gadget_moving_off_borders = (gadget_moving && new_gi != last_gi);
1627
1628   /* when handling selectbox, set additional state values */
1629   if (gadget_released_inside && (last_gi->type & GD_TYPE_SELECTBOX))
1630     gadget_released_inside_select_area = insideSelectboxArea(last_gi, mx, my);
1631   else
1632     gadget_released_inside_select_area = FALSE;
1633
1634   /* setting state for handling over-large selectbox */
1635   if (keep_selectbox_open && (press_event || !mouse_inside_select_line))
1636     keep_selectbox_open = FALSE;
1637
1638   /* if new gadget pressed, store this gadget  */
1639   if (gadget_pressed)
1640     last_gi = new_gi;
1641
1642   /* 'gi' is actually handled gadget */
1643   gi = last_gi;
1644
1645   /* if gadget is scrollbar, choose mouse position value */
1646   if (gi && gi->type & GD_TYPE_SCROLLBAR)
1647     scrollbar_mouse_pos =
1648       (gi->type == GD_TYPE_SCROLLBAR_HORIZONTAL ? mx - gi->x : my - gi->y);
1649
1650   /* if mouse button released, no gadget needs to be handled anymore */
1651   if (gadget_released)
1652   {
1653     if (gi->type & GD_TYPE_SELECTBOX &&
1654         (keep_selectbox_open ||
1655          mouse_released_where_pressed ||
1656          !gadget_released_inside_select_area ||
1657          !CURRENT_OPTION_SELECTABLE(gi)))           /* selectbox stays open */
1658     {
1659       gi->selectbox.stay_open = TRUE;
1660       pressed_mx = 0;
1661       pressed_my = 0;
1662     }
1663     else if (!(gi->type & GD_TYPE_TEXT_INPUT ||
1664                gi->type & GD_TYPE_TEXT_AREA))       /* text input stays open */
1665       last_gi = NULL;
1666   }
1667
1668   /* modify event position values even if no gadget is pressed */
1669   if (button == 0 && !release_event)
1670     gi = new_gi;
1671
1672   /* if new gadget or if no gadget was pressed, release stopped processing */
1673   if (gadget_pressed || new_gi == NULL)
1674     gadget_stopped = FALSE;
1675
1676   /* if gadget was stopped while being handled, stop gadget processing here */
1677   if (gadget_stopped)
1678     return TRUE;
1679
1680   if (gi != NULL)
1681   {
1682     int last_x = gi->event.x;
1683     int last_y = gi->event.y;
1684
1685     gi->event.x = mx - gi->x;
1686     gi->event.y = my - gi->y;
1687
1688     if (gi->type == GD_TYPE_DRAWING_AREA)
1689     {
1690       gi->event.x /= gi->drawing.item_xsize;
1691       gi->event.y /= gi->drawing.item_ysize;
1692
1693       if (last_x != gi->event.x || last_y != gi->event.y)
1694         changed_position = TRUE;
1695     }
1696     else if (gi->type & GD_TYPE_TEXT_INPUT && button != 0 && !motion_status)
1697     {
1698       int old_cursor_position = gi->textinput.cursor_position;
1699
1700       /* if mouse button pressed inside activated text gadget, set cursor */
1701       gi->textinput.cursor_position =
1702         (mx - gi->x - gi->border.xsize) / getFontWidth(gi->font);
1703
1704       if (gi->textinput.cursor_position < 0)
1705         gi->textinput.cursor_position = 0;
1706       else if (gi->textinput.cursor_position > strlen(gi->textinput.value))
1707         gi->textinput.cursor_position = strlen(gi->textinput.value);
1708
1709       if (gi->textinput.cursor_position != old_cursor_position)
1710         DrawGadget(gi, DG_PRESSED, gi->direct_draw);
1711
1712       if (press_event)
1713         StartTextInput(gi->x, gi->y, gi->width, gi->height);
1714     }
1715     else if (gi->type & GD_TYPE_TEXT_AREA && button != 0 && !motion_status)
1716     {
1717       int old_cursor_position = gi->textarea.cursor_position;
1718       int x = (mx - gi->x - gi->border.xsize) / getFontWidth(gi->font);
1719       int y = (my - gi->y - gi->border.ysize) / getFontHeight(gi->font);
1720
1721       x = (x < 0 ? 0 : x >= gi->textarea.xsize ? gi->textarea.xsize - 1 : x);
1722       y = (y < 0 ? 0 : y >= gi->textarea.ysize ? gi->textarea.ysize - 1 : y);
1723
1724       setTextAreaCursorXY(gi, x, y);
1725
1726       if (gi->textarea.cursor_position != old_cursor_position)
1727         DrawGadget(gi, DG_PRESSED, gi->direct_draw);
1728
1729       if (press_event)
1730         StartTextInput(gi->x, gi->y, gi->width, gi->height);
1731     }
1732     else if (gi->type & GD_TYPE_SELECTBOX && gi->selectbox.open &&
1733              !keep_selectbox_open)
1734     {
1735       int old_index = gi->selectbox.current_index;
1736
1737       /* if mouse moving inside activated selectbox, select value */
1738       if (my >= gi->selectbox.y && my < gi->selectbox.y + gi->selectbox.height)
1739         gi->selectbox.current_index =
1740           (my - gi->selectbox.y - gi->border.ysize) / getFontHeight(gi->font);
1741
1742       if (gi->selectbox.current_index < 0)
1743         gi->selectbox.current_index = 0;
1744       else if (gi->selectbox.current_index > gi->selectbox.num_values - 1)
1745         gi->selectbox.current_index = gi->selectbox.num_values - 1;
1746
1747       if (gi->selectbox.current_index != old_index)
1748         DrawGadget(gi, DG_PRESSED, gi->direct_draw);
1749     }
1750   }
1751
1752   /* handle gadget popup info text */
1753   if (last_info_gi != new_gi ||
1754       (new_gi && new_gi->type == GD_TYPE_DRAWING_AREA && changed_position))
1755   {
1756     if (new_gi != NULL && (button == 0 || new_gi == last_gi))
1757     {
1758       new_gi->event.type = GD_EVENT_INFO_ENTERING;
1759       new_gi->callback_info(new_gi);
1760     }
1761     else if (last_info_gi != NULL && last_info_gi->mapped)
1762     {
1763       last_info_gi->event.type = GD_EVENT_INFO_LEAVING;
1764       last_info_gi->callback_info(last_info_gi);
1765     }
1766
1767     last_info_gi = new_gi;
1768   }
1769
1770   gadget_draggable = (gi && gi->type & GD_TYPE_SCROLLBAR);
1771
1772   /* reset drag position for newly pressed scrollbar to "not dragging" */
1773   if (gadget_pressed && gadget_draggable)
1774     gi->scrollbar.drag_position = -1;
1775
1776   gadget_dragging = (gadget_draggable && gi->scrollbar.drag_position != -1);
1777
1778   /* clicking next to a scrollbar to move it is not considered "moving" */
1779   if (gadget_draggable && !gadget_dragging)
1780     gadget_moving = FALSE;
1781
1782   /* when leaving scrollbar area when jump-scrolling, stop gadget processing */
1783   if (gadget_draggable && !gadget_dragging && gadget_moving_off_borders)
1784     gadget_stopped = TRUE;
1785
1786   if ((gadget_pressed) ||
1787       (gadget_pressed_repeated && gadget_pressed_delay_reached))
1788   {
1789     if (gadget_pressed)         /* gadget pressed the first time */
1790     {
1791       /* initialize delay counter */
1792       DelayReached(&pressed_delay, 0);
1793
1794       /* start gadget delay with longer delay after first click on gadget */
1795       pressed_delay_value = GADGET_FRAME_DELAY_FIRST;
1796     }
1797     else                        /* gadget hold pressed for some time */
1798     {
1799       /* after first repeated gadget click, continue with shorter delay value */
1800       pressed_delay_value = GADGET_FRAME_DELAY;
1801     }
1802
1803     if (gi->type & GD_TYPE_SCROLLBAR && !gadget_dragging)
1804     {
1805       int mpos = (gi->type == GD_TYPE_SCROLLBAR_HORIZONTAL ? mx    : my);
1806       int gpos = (gi->type == GD_TYPE_SCROLLBAR_HORIZONTAL ? gi->x : gi->y);
1807       int slider_start = gpos + gi->scrollbar.position;
1808       int slider_end   = gpos + gi->scrollbar.position + gi->scrollbar.size - 1;
1809       boolean inside_slider = (mpos >= slider_start && mpos <= slider_end);
1810
1811       if (IS_WHEEL_BUTTON(button) || !inside_slider)
1812       {
1813         /* click scrollbar one scrollbar length up/left or down/right */
1814
1815         struct GadgetScrollbar *gs = &gi->scrollbar;
1816         int old_item_position = gs->item_position;
1817         int item_steps = gs->items_visible - 1;
1818         int item_direction = (mpos < gpos + gi->scrollbar.position ? -1 : +1);
1819
1820         if (IS_WHEEL_BUTTON(button))
1821         {
1822           boolean scroll_single_step = ((GetKeyModState() & KMOD_Alt) != 0);
1823
1824           item_steps = (scroll_single_step ? 1 : wheel_steps);
1825           item_direction = (button == MB_WHEEL_UP ||
1826                             button == MB_WHEEL_LEFT ? -1 : +1);
1827         }
1828
1829         changed_position = FALSE;
1830
1831         gs->item_position += item_steps * item_direction;
1832
1833         if (gs->item_position < 0)
1834           gs->item_position = 0;
1835         else if (gs->item_position > gs->items_max - gs->items_visible)
1836           gs->item_position = gs->items_max - gs->items_visible;
1837
1838         if (old_item_position != gs->item_position)
1839         {
1840           gi->event.item_position = gs->item_position;
1841           changed_position = TRUE;
1842         }
1843
1844         ModifyGadget(gi, GDI_SCROLLBAR_ITEM_POSITION, gs->item_position,
1845                      GDI_END);
1846
1847         gi->state = GD_BUTTON_UNPRESSED;
1848         gi->event.type = GD_EVENT_MOVING;
1849         gi->event.off_borders = FALSE;
1850
1851         if (gi->event_mask & GD_EVENT_MOVING && changed_position)
1852           gi->callback_action(gi);
1853
1854         return TRUE;
1855       }
1856       else
1857       {
1858         /* don't handle this scrollbar anymore when mouse position reached */
1859         if (gadget_pressed_repeated)
1860         {
1861           gadget_stopped = TRUE;
1862
1863           return TRUE;
1864         }
1865       }
1866     }
1867   }
1868
1869   if (gadget_pressed)
1870   {
1871     PlayGadgetSoundActivating();
1872
1873     if (gi->type == GD_TYPE_CHECK_BUTTON)
1874     {
1875       gi->checked = !gi->checked;
1876     }
1877     else if (gi->type == GD_TYPE_RADIO_BUTTON)
1878     {
1879       struct GadgetInfo *rgi = gadget_list_first_entry;
1880
1881       while (rgi)
1882       {
1883         if (rgi->mapped &&
1884             rgi->type == GD_TYPE_RADIO_BUTTON &&
1885             rgi->radio_nr == gi->radio_nr &&
1886             rgi != gi)
1887         {
1888           rgi->checked = FALSE;
1889           DrawGadget(rgi, DG_UNPRESSED, rgi->direct_draw);
1890         }
1891
1892         rgi = rgi->next;
1893       }
1894
1895       gi->checked = TRUE;
1896     }
1897     else if (gi->type & GD_TYPE_SCROLLBAR)
1898     {
1899       int mpos = (gi->type == GD_TYPE_SCROLLBAR_HORIZONTAL ? mx    : my);
1900       int gpos = (gi->type == GD_TYPE_SCROLLBAR_HORIZONTAL ? gi->x : gi->y);
1901       int slider_start = gpos + gi->scrollbar.position;
1902       int slider_end   = gpos + gi->scrollbar.position + gi->scrollbar.size - 1;
1903       boolean inside_slider = (mpos >= slider_start && mpos <= slider_end);
1904
1905       if (!IS_WHEEL_BUTTON(button) && inside_slider)
1906       {
1907         /* start dragging scrollbar */
1908         gi->scrollbar.drag_position =
1909           scrollbar_mouse_pos - gi->scrollbar.position;
1910       }
1911     }
1912     else if (gi->type & GD_TYPE_SELECTBOX)
1913     {
1914       /* keep selectbox open in case of over-large selectbox */
1915       keep_selectbox_open = (mouse_inside_select_line &&
1916                              mouse_inside_select_area);
1917     }
1918
1919     DrawGadget(gi, DG_PRESSED, gi->direct_draw);
1920
1921     gi->state = GD_BUTTON_PRESSED;
1922     gi->event.type = GD_EVENT_PRESSED;
1923     gi->event.button = button;
1924     gi->event.off_borders = FALSE;
1925
1926     if (gi->event_mask & GD_EVENT_PRESSED)
1927       gi->callback_action(gi);
1928   }
1929
1930   if (gadget_pressed_repeated)
1931   {
1932     gi->event.type = GD_EVENT_PRESSED;
1933
1934     if (gi->event_mask & GD_EVENT_REPEATED && gadget_pressed_delay_reached)
1935       gi->callback_action(gi);
1936   }
1937
1938   if (gadget_moving)
1939   {
1940     if (gi->type & GD_TYPE_BUTTON)
1941     {
1942       if (gadget_moving_inside && gi->state == GD_BUTTON_UNPRESSED)
1943         DrawGadget(gi, DG_PRESSED, gi->direct_draw);
1944       else if (gadget_moving_off_borders && gi->state == GD_BUTTON_PRESSED)
1945         DrawGadget(gi, DG_UNPRESSED, gi->direct_draw);
1946     }
1947     else if (gi->type & GD_TYPE_SELECTBOX && !keep_selectbox_open)
1948     {
1949       int old_index = gi->selectbox.current_index;
1950
1951       /* if mouse moving inside activated selectbox, select value */
1952       if (my >= gi->selectbox.y && my < gi->selectbox.y + gi->selectbox.height)
1953         gi->selectbox.current_index =
1954           (my - gi->selectbox.y - gi->border.ysize) / getFontHeight(gi->font);
1955
1956       if (gi->selectbox.current_index < 0)
1957         gi->selectbox.current_index = 0;
1958       else if (gi->selectbox.current_index > gi->selectbox.num_values - 1)
1959         gi->selectbox.current_index = gi->selectbox.num_values - 1;
1960
1961       if (gi->selectbox.current_index != old_index)
1962         DrawGadget(gi, DG_PRESSED, gi->direct_draw);
1963     }
1964     else if (gi->type & GD_TYPE_SCROLLBAR)
1965     {
1966       struct GadgetScrollbar *gs = &gi->scrollbar;
1967       int old_item_position = gs->item_position;
1968
1969       gs->position = scrollbar_mouse_pos - gs->drag_position;
1970
1971       /* make sure to always precisely reach end positions when dragging */
1972       if (gs->position <= 0)
1973       {
1974         gs->position = 0;
1975         gs->item_position = 0;
1976       }
1977       else if (gs->position >= gs->position_max)
1978       {
1979         gs->position = gs->position_max;
1980         gs->item_position = gs->items_max - gs->items_visible;
1981       }
1982       else
1983       {
1984         gs->item_position =
1985           gs->items_max * (gs->position + gs->correction) / gs->size_max_cmp;
1986       }
1987
1988       if (gs->item_position < 0)
1989         gs->item_position = 0;
1990       if (gs->item_position > gs->items_max - 1)
1991         gs->item_position = gs->items_max - 1;
1992
1993       if (old_item_position != gs->item_position)
1994       {
1995         gi->event.item_position = gs->item_position;
1996         changed_position = TRUE;
1997       }
1998
1999       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2000     }
2001
2002     gi->state = (gadget_moving_inside || gadget_draggable ?
2003                  GD_BUTTON_PRESSED : GD_BUTTON_UNPRESSED);
2004     gi->event.type = GD_EVENT_MOVING;
2005     gi->event.off_borders = gadget_moving_off_borders;
2006
2007     if (gi->event_mask & GD_EVENT_MOVING && changed_position &&
2008         (gadget_moving_inside || gi->event_mask & GD_EVENT_OFF_BORDERS))
2009       gi->callback_action(gi);
2010   }
2011
2012   if (gadget_released_inside)
2013   {
2014     boolean deactivate_gadget = TRUE;
2015     boolean gadget_changed = TRUE;
2016
2017     if (gi->type & GD_TYPE_SELECTBOX)
2018     {
2019       if (keep_selectbox_open ||
2020           mouse_released_where_pressed ||
2021           !gadget_released_inside_select_area ||
2022           !CURRENT_OPTION_SELECTABLE(gi))           /* selectbox stays open */
2023       {
2024         deactivate_gadget = FALSE;
2025         gadget_changed = FALSE;
2026       }
2027       else if (gi->selectbox.index != gi->selectbox.current_index)
2028         gi->selectbox.index = gi->selectbox.current_index;
2029       else
2030         gadget_changed = FALSE;
2031     }
2032
2033     if (deactivate_gadget &&
2034         !(gi->type & GD_TYPE_TEXT_INPUT ||
2035           gi->type & GD_TYPE_TEXT_AREA))            /* text input stays open */
2036       DrawGadget(gi, DG_UNPRESSED, gi->direct_draw);
2037
2038     gi->state = GD_BUTTON_UNPRESSED;
2039     gi->event.type = GD_EVENT_RELEASED;
2040
2041     if ((gi->event_mask & GD_EVENT_RELEASED) && gadget_changed)
2042     {
2043       gi->callback_action(gi);
2044     }
2045   }
2046
2047   if (gadget_released_off_borders)
2048   {
2049     if (gi->type & GD_TYPE_SCROLLBAR)
2050       DrawGadget(gi, DG_UNPRESSED, gi->direct_draw);
2051
2052     gi->state = GD_BUTTON_UNPRESSED;
2053     gi->event.type = GD_EVENT_RELEASED;
2054
2055     if (gi->event_mask & GD_EVENT_RELEASED &&
2056         gi->event_mask & GD_EVENT_OFF_BORDERS)
2057       gi->callback_action(gi);
2058   }
2059
2060   /* handle gadgets unmapped/mapped between pressing and releasing */
2061   if (release_event && !gadget_released && new_gi)
2062     new_gi->state = GD_BUTTON_UNPRESSED;
2063
2064   return (gadget_pressed || gadget_pressed_repeated ||
2065           gadget_released || gadget_moving);
2066 }
2067
2068 static void insertCharIntoTextArea(struct GadgetInfo *gi, char c)
2069 {
2070   char text[MAX_GADGET_TEXTSIZE + 1];
2071   int cursor_position = gi->textarea.cursor_position;
2072
2073   if (strlen(gi->textarea.value) >= MAX_GADGET_TEXTSIZE) /* no space left */
2074     return;
2075
2076   strcpy(text, gi->textarea.value);
2077   strcpy(&gi->textarea.value[cursor_position + 1], &text[cursor_position]);
2078   gi->textarea.value[cursor_position] = c;
2079
2080   setTextAreaCursorPosition(gi, gi->textarea.cursor_position + 1);
2081 }
2082
2083 boolean HandleGadgetsKeyInput(Key key)
2084 {
2085   struct GadgetInfo *gi = last_gi;
2086
2087   if (gi == NULL || gi->deactivated || !gi->mapped ||
2088       !(gi->type & GD_TYPE_TEXT_INPUT ||
2089         gi->type & GD_TYPE_TEXT_AREA ||
2090         gi->type & GD_TYPE_SELECTBOX))
2091     return FALSE;
2092
2093   if (key == KSYM_Escape)
2094   {
2095     StopTextInput();
2096   }
2097   else if (key == KSYM_Return)  /* valid for both text input and selectbox */
2098   {
2099     boolean gadget_changed = ((gi->event_mask & GD_EVENT_TEXT_RETURN) != 0);
2100
2101     if (gi->type & GD_TYPE_TEXT_INPUT)
2102     {
2103       CheckRangeOfNumericInputGadget(gi);
2104
2105       if (!strEqual(gi->textinput.last_value, gi->textinput.value))
2106         strcpy(gi->textinput.last_value, gi->textinput.value);
2107       else
2108         gadget_changed = FALSE;
2109
2110       StopTextInput();
2111     }
2112     else if (gi->type & GD_TYPE_SELECTBOX)
2113     {
2114       if (gi->selectbox.index != gi->selectbox.current_index)
2115         gi->selectbox.index = gi->selectbox.current_index;
2116       else
2117         gadget_changed = FALSE;
2118     }
2119
2120     if (gi->type & GD_TYPE_TEXT_AREA)
2121     {
2122       insertCharIntoTextArea(gi, '\n');
2123
2124       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2125     }
2126     else
2127     {
2128       DrawGadget(gi, DG_UNPRESSED, gi->direct_draw);
2129
2130       gi->event.type = GD_EVENT_TEXT_RETURN;
2131
2132       last_gi = NULL;
2133     }
2134
2135     if (gadget_changed)
2136       gi->callback_action(gi);
2137   }
2138   else if (gi->type & GD_TYPE_TEXT_INPUT)       /* only valid for text input */
2139   {
2140     char text[MAX_GADGET_TEXTSIZE + 1];
2141     int text_length = strlen(gi->textinput.value);
2142     int cursor_pos = gi->textinput.cursor_position;
2143     char letter = getCharFromKey(key);
2144     boolean legal_letter = (gi->type == GD_TYPE_TEXT_INPUT_NUMERIC ?
2145                             letter >= '0' && letter <= '9' :
2146                             letter != 0);
2147
2148     if (legal_letter && text_length < gi->textinput.size)
2149     {
2150       strcpy(text, gi->textinput.value);
2151       strcpy(&gi->textinput.value[cursor_pos + 1], &text[cursor_pos]);
2152       gi->textinput.value[cursor_pos] = letter;
2153       gi->textinput.cursor_position++;
2154
2155       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2156     }
2157     else if (key == KSYM_Left && cursor_pos > 0)
2158     {
2159       gi->textinput.cursor_position--;
2160
2161       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2162     }
2163     else if (key == KSYM_Right && cursor_pos < text_length)
2164     {
2165       gi->textinput.cursor_position++;
2166
2167       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2168     }
2169     else if (key == KSYM_BackSpace && cursor_pos > 0)
2170     {
2171       strcpy(text, gi->textinput.value);
2172       strcpy(&gi->textinput.value[cursor_pos - 1], &text[cursor_pos]);
2173       gi->textinput.cursor_position--;
2174
2175       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2176     }
2177     else if (key == KSYM_Delete && cursor_pos < text_length)
2178     {
2179       strcpy(text, gi->textinput.value);
2180       strcpy(&gi->textinput.value[cursor_pos], &text[cursor_pos + 1]);
2181
2182       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2183     }
2184   }
2185   else if (gi->type & GD_TYPE_TEXT_AREA)        /* only valid for text area */
2186   {
2187     char text[MAX_GADGET_TEXTSIZE + 1];
2188     int text_length = strlen(gi->textarea.value);
2189     int area_ysize = gi->textarea.ysize;
2190     int cursor_x_pref = gi->textarea.cursor_x_preferred;
2191     int cursor_y = gi->textarea.cursor_y;
2192     int cursor_pos = gi->textarea.cursor_position;
2193     char letter = getCharFromKey(key);
2194     boolean legal_letter = (letter != 0);
2195
2196     if (legal_letter)
2197     {
2198       insertCharIntoTextArea(gi, letter);
2199
2200       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2201     }
2202     else if (key == KSYM_Left && cursor_pos > 0)
2203     {
2204       setTextAreaCursorPosition(gi, gi->textarea.cursor_position - 1);
2205
2206       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2207     }
2208     else if (key == KSYM_Right && cursor_pos < text_length)
2209     {
2210       setTextAreaCursorPosition(gi, gi->textarea.cursor_position + 1);
2211
2212       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2213     }
2214     else if (key == KSYM_Up && cursor_y > 0)
2215     {
2216       setTextAreaCursorXY(gi, cursor_x_pref, cursor_y - 1);
2217       gi->textarea.cursor_x_preferred = cursor_x_pref;
2218
2219       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2220     }
2221     else if (key == KSYM_Down && cursor_y < area_ysize - 1)
2222     {
2223       setTextAreaCursorXY(gi, cursor_x_pref, cursor_y + 1);
2224       gi->textarea.cursor_x_preferred = cursor_x_pref;
2225
2226       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2227     }
2228     else if (key == KSYM_BackSpace && cursor_pos > 0)
2229     {
2230       strcpy(text, gi->textarea.value);
2231       strcpy(&gi->textarea.value[cursor_pos - 1], &text[cursor_pos]);
2232
2233       setTextAreaCursorPosition(gi, gi->textarea.cursor_position - 1);
2234
2235       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2236     }
2237     else if (key == KSYM_Delete && cursor_pos < text_length)
2238     {
2239       strcpy(text, gi->textarea.value);
2240       strcpy(&gi->textarea.value[cursor_pos], &text[cursor_pos + 1]);
2241
2242       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2243     }
2244   }
2245   else if (gi->type & GD_TYPE_SELECTBOX)        /* only valid for selectbox */
2246   {
2247     int index = gi->selectbox.current_index;
2248     int num_values = gi->selectbox.num_values;
2249
2250     if (key == KSYM_Up && index > 0)
2251     {
2252       gi->selectbox.current_index--;
2253
2254       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2255     }
2256     else if (key == KSYM_Down && index < num_values - 1)
2257     {
2258       gi->selectbox.current_index++;
2259
2260       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2261     }
2262   }
2263
2264   return TRUE;
2265 }