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   static boolean keep_selectbox_open = FALSE;
1389   int scrollbar_mouse_pos = 0;
1390   struct GadgetInfo *new_gi, *gi;
1391   boolean press_event;
1392   boolean release_event;
1393   boolean mouse_moving;
1394   boolean mouse_inside_select_line;
1395   boolean mouse_inside_select_area;
1396   boolean mouse_released_where_pressed;
1397   boolean gadget_pressed;
1398   boolean gadget_pressed_repeated;
1399   boolean gadget_pressed_off_borders;
1400   boolean gadget_pressed_inside_select_line;
1401   boolean gadget_moving;
1402   boolean gadget_moving_inside;
1403   boolean gadget_moving_off_borders;
1404   boolean gadget_released;
1405   boolean gadget_released_inside;
1406   boolean gadget_released_inside_select_line;
1407   boolean gadget_released_inside_select_area;
1408   boolean gadget_released_off_borders;
1409   boolean changed_position = FALSE;
1410
1411   /* check if there are any gadgets defined */
1412   if (gadget_list_first_entry == NULL)
1413     return FALSE;
1414
1415   /* simulated release of mouse button over last gadget */
1416   if (mx == -1 && my == -1 && button == 0)
1417   {
1418     mx = last_mx;
1419     my = last_my;
1420   }
1421
1422   /* check which gadget is under the mouse pointer */
1423   new_gi = getGadgetInfoFromMousePosition(mx, my);
1424
1425   /* check if button state has changed since last invocation */
1426   press_event = (button != 0 && last_button == 0);
1427   release_event = (button == 0 && last_button != 0);
1428   last_button = button;
1429
1430   /* check if mouse has been moved since last invocation */
1431   mouse_moving = ((mx != last_mx || my != last_my) && motion_status);
1432   last_mx = mx;
1433   last_my = my;
1434
1435   if (press_event && new_gi != last_gi)
1436   {
1437     pressed_mx = mx;
1438     pressed_my = my;
1439   }
1440
1441   mouse_released_where_pressed =
1442     (release_event && mx == pressed_mx && my == pressed_my);
1443
1444   mouse_inside_select_line = insideSelectboxLine(new_gi, mx, my);
1445   mouse_inside_select_area = insideSelectboxArea(new_gi, mx, my);
1446
1447   gadget_pressed_off_borders = (press_event && new_gi != last_gi);
1448
1449   gadget_pressed_inside_select_line =
1450     (press_event && new_gi != NULL &&
1451      new_gi->type & GD_TYPE_SELECTBOX && new_gi->selectbox.open &&
1452      insideSelectboxLine(new_gi, mx, my));
1453
1454   /* if mouse button pressed outside text or selectbox gadget, deactivate it */
1455   if (anyTextGadgetActive() &&
1456       (gadget_pressed_off_borders ||
1457        (gadget_pressed_inside_select_line && !mouse_inside_select_area)))
1458   {
1459     struct GadgetInfo *gi = last_gi;
1460     boolean gadget_changed = (gi->event_mask & GD_EVENT_TEXT_LEAVING);
1461
1462     /* check if text gadget has changed its value */
1463     if (gi->type & GD_TYPE_TEXT_INPUT)
1464     {
1465       CheckRangeOfNumericInputGadget(gi);
1466
1467       if (strcmp(gi->textinput.value, gi->textinput.last_value) != 0)
1468         strcpy(gi->textinput.last_value, gi->textinput.value);
1469       else
1470         gadget_changed = FALSE;
1471     }
1472
1473     /* selectbox does not change its value when closed by clicking outside */
1474     if (gi->type & GD_TYPE_SELECTBOX)
1475       gadget_changed = FALSE;
1476
1477     DrawGadget(gi, DG_UNPRESSED, gi->direct_draw);
1478
1479     gi->event.type = GD_EVENT_TEXT_LEAVING;
1480
1481     if (gadget_changed && !(gi->type & GD_TYPE_SELECTBOX))
1482       gi->callback_action(gi);
1483
1484     last_gi = NULL;
1485
1486     if (gadget_pressed_inside_select_line)
1487       new_gi = NULL;
1488   }
1489
1490   gadget_pressed =
1491     (button != 0 && last_gi == NULL && new_gi != NULL && press_event);
1492   gadget_pressed_repeated =
1493     (button != 0 && last_gi != NULL && new_gi == last_gi);
1494
1495   gadget_released =             (release_event && last_gi != NULL);
1496   gadget_released_inside =      (gadget_released && new_gi == last_gi);
1497   gadget_released_off_borders = (gadget_released && new_gi != last_gi);
1498
1499   gadget_moving =             (button != 0 && last_gi != NULL && mouse_moving);
1500   gadget_moving_inside =      (gadget_moving && new_gi == last_gi);
1501   gadget_moving_off_borders = (gadget_moving && new_gi != last_gi);
1502
1503   /* when handling selectbox, set additional state values */
1504   if (gadget_released_inside && (last_gi->type & GD_TYPE_SELECTBOX))
1505   {
1506     gadget_released_inside_select_line = insideSelectboxLine(last_gi, mx, my);
1507     gadget_released_inside_select_area = insideSelectboxArea(last_gi, mx, my);
1508   }
1509   else
1510   {
1511     gadget_released_inside_select_line = FALSE;
1512     gadget_released_inside_select_area = FALSE;
1513   }
1514
1515   /* setting state for handling over-large selectbox */
1516   if (keep_selectbox_open && (press_event || !mouse_inside_select_line))
1517     keep_selectbox_open = FALSE;
1518
1519   /* if new gadget pressed, store this gadget  */
1520   if (gadget_pressed)
1521     last_gi = new_gi;
1522
1523   /* 'gi' is actually handled gadget */
1524   gi = last_gi;
1525
1526   /* if gadget is scrollbar, choose mouse position value */
1527   if (gi && gi->type & GD_TYPE_SCROLLBAR)
1528     scrollbar_mouse_pos =
1529       (gi->type == GD_TYPE_SCROLLBAR_HORIZONTAL ? mx - gi->x : my - gi->y);
1530
1531   /* if mouse button released, no gadget needs to be handled anymore */
1532   if (gadget_released)
1533   {
1534     if (gi->type & GD_TYPE_SELECTBOX &&
1535         (keep_selectbox_open ||
1536          mouse_released_where_pressed ||
1537          !gadget_released_inside_select_area))       /* selectbox stays open */
1538     {
1539       gi->selectbox.stay_open = TRUE;
1540       pressed_mx = 0;
1541       pressed_my = 0;
1542     }
1543     else if (!(gi->type & GD_TYPE_TEXT_INPUT ||
1544                gi->type & GD_TYPE_TEXT_AREA))       /* text input stays open */
1545       last_gi = NULL;
1546   }
1547
1548   /* modify event position values even if no gadget is pressed */
1549   if (button == 0 && !release_event)
1550     gi = new_gi;
1551
1552   if (gi != NULL)
1553   {
1554     int last_x = gi->event.x;
1555     int last_y = gi->event.y;
1556
1557     gi->event.x = mx - gi->x;
1558     gi->event.y = my - gi->y;
1559
1560     if (gi->type == GD_TYPE_DRAWING_AREA)
1561     {
1562       gi->event.x /= gi->drawing.item_xsize;
1563       gi->event.y /= gi->drawing.item_ysize;
1564
1565       if (last_x != gi->event.x || last_y != gi->event.y)
1566         changed_position = TRUE;
1567     }
1568     else if (gi->type & GD_TYPE_TEXT_INPUT && button != 0 && !motion_status)
1569     {
1570       int old_cursor_position = gi->textinput.cursor_position;
1571
1572       /* if mouse button pressed inside activated text gadget, set cursor */
1573       gi->textinput.cursor_position =
1574         (mx - gi->x - gi->border.xsize) / getFontWidth(gi->font);
1575
1576       if (gi->textinput.cursor_position < 0)
1577         gi->textinput.cursor_position = 0;
1578       else if (gi->textinput.cursor_position > strlen(gi->textinput.value))
1579         gi->textinput.cursor_position = strlen(gi->textinput.value);
1580
1581       if (gi->textinput.cursor_position != old_cursor_position)
1582         DrawGadget(gi, DG_PRESSED, gi->direct_draw);
1583     }
1584     else if (gi->type & GD_TYPE_TEXT_AREA && button != 0 && !motion_status)
1585     {
1586       int old_cursor_position = gi->textarea.cursor_position;
1587       int x = (mx - gi->x - gi->border.xsize) / getFontWidth(gi->font);
1588       int y = (my - gi->y - gi->border.ysize) / getFontHeight(gi->font);
1589
1590       x = (x < 0 ? 0 : x >= gi->textarea.xsize ? gi->textarea.xsize - 1 : x);
1591       y = (y < 0 ? 0 : y >= gi->textarea.ysize ? gi->textarea.ysize - 1 : y);
1592
1593       setTextAreaCursorXY(gi, x, y);
1594
1595       if (gi->textarea.cursor_position != old_cursor_position)
1596         DrawGadget(gi, DG_PRESSED, gi->direct_draw);
1597     }
1598     else if (gi->type & GD_TYPE_SELECTBOX && gi->selectbox.open &&
1599              !keep_selectbox_open)
1600     {
1601       int old_index = gi->selectbox.current_index;
1602
1603       /* if mouse moving inside activated selectbox, select value */
1604       if (my >= gi->selectbox.y && my < gi->selectbox.y + gi->selectbox.height)
1605         gi->selectbox.current_index =
1606           (my - gi->selectbox.y - gi->border.ysize) / getFontHeight(gi->font);
1607
1608       if (gi->selectbox.current_index < 0)
1609         gi->selectbox.current_index = 0;
1610       else if (gi->selectbox.current_index > gi->selectbox.num_values - 1)
1611         gi->selectbox.current_index = gi->selectbox.num_values - 1;
1612
1613       if (gi->selectbox.current_index != old_index)
1614         DrawGadget(gi, DG_PRESSED, gi->direct_draw);
1615     }
1616   }
1617
1618   /* handle gadget popup info text */
1619   if (last_info_gi != new_gi ||
1620       (new_gi && new_gi->type == GD_TYPE_DRAWING_AREA && changed_position))
1621   {
1622     if (new_gi != NULL && (button == 0 || new_gi == last_gi))
1623     {
1624       new_gi->event.type = GD_EVENT_INFO_ENTERING;
1625       new_gi->callback_info(new_gi);
1626     }
1627     else if (last_info_gi != NULL)
1628     {
1629       last_info_gi->event.type = GD_EVENT_INFO_LEAVING;
1630       last_info_gi->callback_info(last_info_gi);
1631     }
1632
1633     last_info_gi = new_gi;
1634   }
1635
1636   if (gadget_pressed)
1637   {
1638     if (gi->type == GD_TYPE_CHECK_BUTTON)
1639     {
1640       gi->checked = !gi->checked;
1641     }
1642     else if (gi->type == GD_TYPE_RADIO_BUTTON)
1643     {
1644       struct GadgetInfo *rgi = gadget_list_first_entry;
1645
1646       while (rgi)
1647       {
1648         if (rgi->mapped &&
1649             rgi->type == GD_TYPE_RADIO_BUTTON &&
1650             rgi->radio_nr == gi->radio_nr &&
1651             rgi != gi)
1652         {
1653           rgi->checked = FALSE;
1654           DrawGadget(rgi, DG_UNPRESSED, rgi->direct_draw);
1655         }
1656
1657         rgi = rgi->next;
1658       }
1659
1660       gi->checked = TRUE;
1661     }
1662     else if (gi->type & GD_TYPE_SCROLLBAR)
1663     {
1664       int mpos, gpos;
1665
1666       if (gi->type == GD_TYPE_SCROLLBAR_HORIZONTAL)
1667       {
1668         mpos = mx;
1669         gpos = gi->x;
1670       }
1671       else
1672       {
1673         mpos = my;
1674         gpos = gi->y;
1675       }
1676
1677       if (mpos >= gpos + gi->scrollbar.position &&
1678           mpos < gpos + gi->scrollbar.position + gi->scrollbar.size)
1679       {
1680         /* drag scrollbar */
1681         gi->scrollbar.drag_position =
1682           scrollbar_mouse_pos - gi->scrollbar.position;
1683       }
1684       else
1685       {
1686         /* click scrollbar one scrollbar length up/left or down/right */
1687
1688         struct GadgetScrollbar *gs = &gi->scrollbar;
1689         int old_item_position = gs->item_position;
1690
1691         changed_position = FALSE;
1692
1693         gs->item_position +=
1694           gs->items_visible * (mpos < gpos + gi->scrollbar.position ? -1 : +1);
1695
1696         if (gs->item_position < 0)
1697           gs->item_position = 0;
1698         else if (gs->item_position > gs->items_max - gs->items_visible)
1699           gs->item_position = gs->items_max - gs->items_visible;
1700
1701         if (old_item_position != gs->item_position)
1702         {
1703           gi->event.item_position = gs->item_position;
1704           changed_position = TRUE;
1705         }
1706
1707         ModifyGadget(gi, GDI_SCROLLBAR_ITEM_POSITION, gs->item_position,
1708                      GDI_END);
1709
1710         gi->state = GD_BUTTON_UNPRESSED;
1711         gi->event.type = GD_EVENT_MOVING;
1712         gi->event.off_borders = FALSE;
1713
1714         if (gi->event_mask & GD_EVENT_MOVING && changed_position)
1715           gi->callback_action(gi);
1716
1717         /* don't handle this scrollbar anymore while mouse button pressed */
1718         last_gi = NULL;
1719
1720         return TRUE;
1721       }
1722     }
1723     else if (gi->type & GD_TYPE_SELECTBOX)
1724     {
1725       /* keep selectbox open in case of over-large selectbox */
1726       keep_selectbox_open = (mouse_inside_select_line &&
1727                              mouse_inside_select_area);
1728     }
1729
1730     DrawGadget(gi, DG_PRESSED, gi->direct_draw);
1731
1732     gi->state = GD_BUTTON_PRESSED;
1733     gi->event.type = GD_EVENT_PRESSED;
1734     gi->event.button = button;
1735     gi->event.off_borders = FALSE;
1736
1737     /* initialize delay counter */
1738     DelayReached(&pressed_delay, 0);
1739
1740     if (gi->event_mask & GD_EVENT_PRESSED)
1741       gi->callback_action(gi);
1742   }
1743
1744   if (gadget_pressed_repeated)
1745   {
1746     gi->event.type = GD_EVENT_PRESSED;
1747
1748     if (gi->event_mask & GD_EVENT_REPEATED &&
1749         DelayReached(&pressed_delay, GADGET_FRAME_DELAY))
1750       gi->callback_action(gi);
1751   }
1752
1753   if (gadget_moving)
1754   {
1755     if (gi->type & GD_TYPE_BUTTON)
1756     {
1757       if (gadget_moving_inside && gi->state == GD_BUTTON_UNPRESSED)
1758         DrawGadget(gi, DG_PRESSED, gi->direct_draw);
1759       else if (gadget_moving_off_borders && gi->state == GD_BUTTON_PRESSED)
1760         DrawGadget(gi, DG_UNPRESSED, gi->direct_draw);
1761     }
1762     else if (gi->type & GD_TYPE_SELECTBOX && !keep_selectbox_open)
1763     {
1764       int old_index = gi->selectbox.current_index;
1765
1766       /* if mouse moving inside activated selectbox, select value */
1767       if (my >= gi->selectbox.y && my < gi->selectbox.y + gi->selectbox.height)
1768         gi->selectbox.current_index =
1769           (my - gi->selectbox.y - gi->border.ysize) / getFontHeight(gi->font);
1770
1771       if (gi->selectbox.current_index < 0)
1772         gi->selectbox.current_index = 0;
1773       else if (gi->selectbox.current_index > gi->selectbox.num_values - 1)
1774         gi->selectbox.current_index = gi->selectbox.num_values - 1;
1775
1776       if (gi->selectbox.current_index != old_index)
1777         DrawGadget(gi, DG_PRESSED, gi->direct_draw);
1778     }
1779     else if (gi->type & GD_TYPE_SCROLLBAR)
1780     {
1781       struct GadgetScrollbar *gs = &gi->scrollbar;
1782       int old_item_position = gs->item_position;
1783
1784       gs->position = scrollbar_mouse_pos - gs->drag_position;
1785
1786       /* make sure to always precisely reach end positions when dragging */
1787       if (gs->position <= 0)
1788       {
1789         gs->position = 0;
1790         gs->item_position = 0;
1791       }
1792       else if (gs->position >= gs->position_max)
1793       {
1794         gs->position = gs->position_max;
1795         gs->item_position = gs->items_max - gs->items_visible;
1796       }
1797       else
1798       {
1799         gs->item_position =
1800           gs->items_max * (gs->position + gs->correction) / gs->size_max_cmp;
1801       }
1802
1803       if (gs->item_position < 0)
1804         gs->item_position = 0;
1805       if (gs->item_position > gs->items_max - 1)
1806         gs->item_position = gs->items_max - 1;
1807
1808       if (old_item_position != gs->item_position)
1809       {
1810         gi->event.item_position = gs->item_position;
1811         changed_position = TRUE;
1812       }
1813
1814       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
1815     }
1816
1817     gi->state = (gadget_moving_inside || gi->type & GD_TYPE_SCROLLBAR ?
1818                  GD_BUTTON_PRESSED : GD_BUTTON_UNPRESSED);
1819     gi->event.type = GD_EVENT_MOVING;
1820     gi->event.off_borders = gadget_moving_off_borders;
1821
1822     if (gi->event_mask & GD_EVENT_MOVING && changed_position &&
1823         (gadget_moving_inside || gi->event_mask & GD_EVENT_OFF_BORDERS))
1824       gi->callback_action(gi);
1825   }
1826
1827   if (gadget_released_inside)
1828   {
1829     boolean deactivate_gadget = TRUE;
1830     boolean gadget_changed = TRUE;
1831
1832     if (gi->type & GD_TYPE_SELECTBOX)
1833     {
1834       if (keep_selectbox_open ||
1835           mouse_released_where_pressed ||
1836           !gadget_released_inside_select_area)       /* selectbox stays open */
1837       {
1838         deactivate_gadget = FALSE;
1839         gadget_changed = FALSE;
1840       }
1841       else if (gi->selectbox.index != gi->selectbox.current_index)
1842         gi->selectbox.index = gi->selectbox.current_index;
1843       else
1844         gadget_changed = FALSE;
1845     }
1846
1847     if (deactivate_gadget &&
1848         !(gi->type & GD_TYPE_TEXT_INPUT ||
1849           gi->type & GD_TYPE_TEXT_AREA))            /* text input stays open */
1850       DrawGadget(gi, DG_UNPRESSED, gi->direct_draw);
1851
1852     gi->state = GD_BUTTON_UNPRESSED;
1853     gi->event.type = GD_EVENT_RELEASED;
1854
1855     if ((gi->event_mask & GD_EVENT_RELEASED) && gadget_changed)
1856     {
1857       gi->callback_action(gi);
1858     }
1859   }
1860
1861   if (gadget_released_off_borders)
1862   {
1863     if (gi->type & GD_TYPE_SCROLLBAR)
1864       DrawGadget(gi, DG_UNPRESSED, gi->direct_draw);
1865
1866     gi->event.type = GD_EVENT_RELEASED;
1867
1868     if (gi->event_mask & GD_EVENT_RELEASED &&
1869         gi->event_mask & GD_EVENT_OFF_BORDERS)
1870       gi->callback_action(gi);
1871   }
1872
1873   /* handle gadgets unmapped/mapped between pressing and releasing */
1874   if (release_event && !gadget_released && new_gi)
1875     new_gi->state = GD_BUTTON_UNPRESSED;
1876
1877   return (gadget_pressed || gadget_pressed_repeated ||
1878           gadget_released || gadget_moving);
1879 }
1880
1881 static void insertCharIntoTextArea(struct GadgetInfo *gi, char c)
1882 {
1883   char text[MAX_GADGET_TEXTSIZE];
1884   int cursor_position = gi->textarea.cursor_position;
1885
1886   if (strlen(gi->textarea.value) == MAX_GADGET_TEXTSIZE) /* no space left */
1887     return;
1888
1889   strcpy(text, gi->textarea.value);
1890   strcpy(&gi->textarea.value[cursor_position + 1], &text[cursor_position]);
1891   gi->textarea.value[cursor_position] = c;
1892
1893   setTextAreaCursorPosition(gi, gi->textarea.cursor_position + 1);
1894 }
1895
1896 boolean HandleGadgetsKeyInput(Key key)
1897 {
1898   struct GadgetInfo *gi = last_gi;
1899
1900   if (gi == NULL || !gi->mapped ||
1901       !(gi->type & GD_TYPE_TEXT_INPUT ||
1902         gi->type & GD_TYPE_TEXT_AREA ||
1903         gi->type & GD_TYPE_SELECTBOX))
1904     return FALSE;
1905
1906   if (key == KSYM_Return)       /* valid for both text input and selectbox */
1907   {
1908     boolean gadget_changed = (gi->event_mask & GD_EVENT_TEXT_RETURN);
1909
1910     if (gi->type & GD_TYPE_TEXT_INPUT)
1911     {
1912       CheckRangeOfNumericInputGadget(gi);
1913
1914       if (strcmp(gi->textinput.value, gi->textinput.last_value) != 0)
1915         strcpy(gi->textinput.last_value, gi->textinput.value);
1916       else
1917         gadget_changed = FALSE;
1918     }
1919     else if (gi->type & GD_TYPE_SELECTBOX)
1920     {
1921       if (gi->selectbox.index != gi->selectbox.current_index)
1922         gi->selectbox.index = gi->selectbox.current_index;
1923       else
1924         gadget_changed = FALSE;
1925     }
1926
1927     if (gi->type & GD_TYPE_TEXT_AREA)
1928     {
1929       insertCharIntoTextArea(gi, '\n');
1930
1931       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
1932     }
1933     else
1934     {
1935       DrawGadget(gi, DG_UNPRESSED, gi->direct_draw);
1936
1937       gi->event.type = GD_EVENT_TEXT_RETURN;
1938
1939       last_gi = NULL;
1940     }
1941
1942     if (gadget_changed)
1943       gi->callback_action(gi);
1944   }
1945   else if (gi->type & GD_TYPE_TEXT_INPUT)       /* only valid for text input */
1946   {
1947     char text[MAX_GADGET_TEXTSIZE];
1948     int text_length = strlen(gi->textinput.value);
1949     int cursor_pos = gi->textinput.cursor_position;
1950     char letter = getCharFromKey(key);
1951     boolean legal_letter = (gi->type == GD_TYPE_TEXT_INPUT_NUMERIC ?
1952                             letter >= '0' && letter <= '9' :
1953                             letter != 0);
1954
1955     if (legal_letter && text_length < gi->textinput.size)
1956     {
1957       strcpy(text, gi->textinput.value);
1958       strcpy(&gi->textinput.value[cursor_pos + 1], &text[cursor_pos]);
1959       gi->textinput.value[cursor_pos] = letter;
1960       gi->textinput.cursor_position++;
1961
1962       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
1963     }
1964     else if (key == KSYM_Left && cursor_pos > 0)
1965     {
1966       gi->textinput.cursor_position--;
1967
1968       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
1969     }
1970     else if (key == KSYM_Right && cursor_pos < text_length)
1971     {
1972       gi->textinput.cursor_position++;
1973
1974       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
1975     }
1976     else if (key == KSYM_BackSpace && cursor_pos > 0)
1977     {
1978       strcpy(text, gi->textinput.value);
1979       strcpy(&gi->textinput.value[cursor_pos - 1], &text[cursor_pos]);
1980       gi->textinput.cursor_position--;
1981
1982       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
1983     }
1984     else if (key == KSYM_Delete && cursor_pos < text_length)
1985     {
1986       strcpy(text, gi->textinput.value);
1987       strcpy(&gi->textinput.value[cursor_pos], &text[cursor_pos + 1]);
1988
1989       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
1990     }
1991   }
1992   else if (gi->type & GD_TYPE_TEXT_AREA)        /* only valid for text area */
1993   {
1994     char text[MAX_GADGET_TEXTSIZE];
1995     int text_length = strlen(gi->textarea.value);
1996     int area_ysize = gi->textarea.ysize;
1997     int cursor_x_pref = gi->textarea.cursor_x_preferred;
1998     int cursor_y = gi->textarea.cursor_y;
1999     int cursor_pos = gi->textarea.cursor_position;
2000     char letter = getCharFromKey(key);
2001     boolean legal_letter = (letter != 0);
2002
2003     if (legal_letter)
2004     {
2005       insertCharIntoTextArea(gi, letter);
2006
2007       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2008     }
2009     else if (key == KSYM_Left && cursor_pos > 0)
2010     {
2011       setTextAreaCursorPosition(gi, gi->textarea.cursor_position - 1);
2012
2013       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2014     }
2015     else if (key == KSYM_Right && cursor_pos < text_length)
2016     {
2017       setTextAreaCursorPosition(gi, gi->textarea.cursor_position + 1);
2018
2019       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2020     }
2021     else if (key == KSYM_Up && cursor_y > 0)
2022     {
2023       setTextAreaCursorXY(gi, cursor_x_pref, cursor_y - 1);
2024       gi->textarea.cursor_x_preferred = cursor_x_pref;
2025
2026       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2027     }
2028     else if (key == KSYM_Down && cursor_y < area_ysize - 1)
2029     {
2030       setTextAreaCursorXY(gi, cursor_x_pref, cursor_y + 1);
2031       gi->textarea.cursor_x_preferred = cursor_x_pref;
2032
2033       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2034     }
2035     else if (key == KSYM_BackSpace && cursor_pos > 0)
2036     {
2037       strcpy(text, gi->textarea.value);
2038       strcpy(&gi->textarea.value[cursor_pos - 1], &text[cursor_pos]);
2039
2040       setTextAreaCursorPosition(gi, gi->textarea.cursor_position - 1);
2041
2042       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2043     }
2044     else if (key == KSYM_Delete && cursor_pos < text_length)
2045     {
2046       strcpy(text, gi->textarea.value);
2047       strcpy(&gi->textarea.value[cursor_pos], &text[cursor_pos + 1]);
2048
2049       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2050     }
2051   }
2052   else if (gi->type & GD_TYPE_SELECTBOX)        /* only valid for selectbox */
2053   {
2054     int index = gi->selectbox.current_index;
2055     int num_values = gi->selectbox.num_values;
2056
2057     if (key == KSYM_Up && index > 0)
2058     {
2059       gi->selectbox.current_index--;
2060
2061       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2062     }
2063     else if (key == KSYM_Down && index < num_values - 1)
2064     {
2065       gi->selectbox.current_index++;
2066
2067       DrawGadget(gi, DG_PRESSED, gi->direct_draw);
2068     }
2069   }
2070
2071   return TRUE;
2072 }