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