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