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