src/libgame/gadgets.c

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