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