src/editor.c

   1 /***********************************************************
   2 * Rocks'n'Diamonds -- McDuffin Strikes Back!               *
   3 *----------------------------------------------------------*
   4 * (c) 1995-2002 Artsoft Entertainment                      *
   5 *               Holger Schemel                             *
   6 *               Detmolder Strasse 189                      *
   7 *               33604 Bielefeld                            *
   8 *               Germany                                    *
   9 *               e-mail: info@artsoft.org                   *
  10 *----------------------------------------------------------*
  11 * editor.c                                                 *
  12 ***********************************************************/
  13
  14 #include <math.h>
  15
  16 #include "libgame/libgame.h"
  17
  18 #include "editor.h"
  19 #include "screens.h"
  20 #include "tools.h"
  21 #include "files.h"
  22 #include "game.h"
  23 #include "tape.h"
  24
  25
  26 /*
  27   -----------------------------------------------------------------------------
  28   screen and artwork graphic pixel position definitions
  29   -----------------------------------------------------------------------------
  30 */
  31
  32 /* positions in the level editor */
  33 #define ED_WIN_MB_LEFT_XPOS             6
  34 #define ED_WIN_MB_LEFT_YPOS             258
  35 #define ED_WIN_MB_MIDDLE_XPOS           42
  36 #define ED_WIN_MB_MIDDLE_YPOS           ED_WIN_MB_LEFT_YPOS
  37 #define ED_WIN_MB_RIGHT_XPOS            78
  38 #define ED_WIN_MB_RIGHT_YPOS            ED_WIN_MB_LEFT_YPOS
  39
  40 /* values for the control window */
  41 #define ED_CTRL_BUTTONS_GFX_YPOS        236
  42 #define ED_CTRL_BUTTONS_ALT_GFX_YPOS    142
  43
  44 #define ED_CTRL1_BUTTONS_HORIZ          4
  45 #define ED_CTRL1_BUTTONS_VERT           4
  46 #define ED_CTRL1_BUTTON_XSIZE           22
  47 #define ED_CTRL1_BUTTON_YSIZE           22
  48 #define ED_CTRL1_BUTTONS_XPOS           6
  49 #define ED_CTRL1_BUTTONS_YPOS           6
  50 #define ED_CTRL2_BUTTONS_HORIZ          3
  51 #define ED_CTRL2_BUTTONS_VERT           2
  52 #define ED_CTRL2_BUTTON_XSIZE           30
  53 #define ED_CTRL2_BUTTON_YSIZE           20
  54 #define ED_CTRL2_BUTTONS_XPOS           5
  55 #define ED_CTRL2_BUTTONS_YPOS           99
  56 #define ED_NUM_CTRL1_BUTTONS   (ED_CTRL1_BUTTONS_HORIZ * ED_CTRL1_BUTTONS_VERT)
  57 #define ED_NUM_CTRL2_BUTTONS   (ED_CTRL2_BUTTONS_HORIZ * ED_CTRL2_BUTTONS_VERT)
  58 #define ED_NUM_CTRL_BUTTONS    (ED_NUM_CTRL1_BUTTONS + ED_NUM_CTRL2_BUTTONS)
  59
  60 /* values for the element list */
  61 #define ED_ELEMENTLIST_XPOS             5
  62 #define ED_ELEMENTLIST_YPOS             30
  63 #define ED_ELEMENTLIST_XSIZE            20
  64 #define ED_ELEMENTLIST_YSIZE            20
  65 #define ED_ELEMENTLIST_BUTTONS_HORIZ    4
  66 #define ED_ELEMENTLIST_BUTTONS_VERT     11
  67 #define ED_NUM_ELEMENTLIST_BUTTONS      (ED_ELEMENTLIST_BUTTONS_HORIZ * \
  68                                          ED_ELEMENTLIST_BUTTONS_VERT)
  69
  70 /* values for the setting windows */
  71 #define ED_SETTINGS_XPOS                (MINI_TILEX + 8)
  72 #define ED_SETTINGS2_XPOS               MINI_TILEX
  73 #define ED_SETTINGS_YPOS                MINI_TILEY
  74 #define ED_SETTINGS2_YPOS               (ED_SETTINGS_YPOS + 12 * TILEY - 2)
  75
  76 /* values for counter gadgets */
  77 #define ED_COUNT_ELEM_SCORE_XPOS        ED_SETTINGS_XPOS
  78 #define ED_COUNT_ELEM_SCORE_YPOS        (11 * MINI_TILEY)
  79 #define ED_COUNT_ELEM_CONTENT_XPOS      ED_SETTINGS_XPOS
  80 #define ED_COUNT_ELEM_CONTENT_YPOS      (19 * MINI_TILEY)
  81
  82 #define ED_COUNTER_YSTART               (ED_SETTINGS_YPOS + 2 * TILEY)
  83 #define ED_COUNTER_YDISTANCE            (3 * MINI_TILEY)
  84 #define ED_COUNTER_YPOS(n)              (ED_COUNTER_YSTART + \
  85                                          n * ED_COUNTER_YDISTANCE)
  86 #define ED_COUNTER_YPOS2(n)             (ED_COUNTER_YSTART + \
  87                                          n * ED_COUNTER_YDISTANCE / 2)
  88 #define ED_COUNTER2_YPOS(n)             (ED_COUNTER_YSTART + \
  89                                          n * ED_COUNTER_YDISTANCE - 2)
  90
  91 /* standard distances */
  92 #define ED_BORDER_SIZE                  3
  93 #define ED_BORDER2_SIZE                 5
  94 #define ED_GADGET_DISTANCE              2
  95
  96 /* values for element content drawing areas */
  97 #define ED_AREA_ELEM_CONTENT_XPOS       ( 2 * MINI_TILEX)
  98 #define ED_AREA_ELEM_CONTENT_YPOS       (22 * MINI_TILEY)
  99
 100 #define ED_AREA_ELEM_CONTENT2_XPOS      ( 2 * MINI_TILEX)
 101 #define ED_AREA_ELEM_CONTENT2_YPOS      (28 * MINI_TILEY)
 102
 103 /* values for random placement background drawing area */
 104 #define ED_AREA_RANDOM_BACKGROUND_XPOS  (29 * MINI_TILEX)
 105 #define ED_AREA_RANDOM_BACKGROUND_YPOS  (31 * MINI_TILEY)
 106
 107 /* values for scrolling gadgets for drawing area */
 108 #define ED_SCROLLBUTTON_XPOS            24
 109 #define ED_SCROLLBUTTON_YPOS            0
 110 #define ED_SCROLLBAR_XPOS               24
 111 #define ED_SCROLLBAR_YPOS               64
 112
 113 #define ED_SCROLLBUTTON_XSIZE           16
 114 #define ED_SCROLLBUTTON_YSIZE           16
 115
 116 #define ED_SCROLL_UP_XPOS               (SXSIZE - ED_SCROLLBUTTON_XSIZE)
 117 #define ED_SCROLL_UP_YPOS               (0)
 118 #define ED_SCROLL_DOWN_XPOS             ED_SCROLL_UP_XPOS
 119 #define ED_SCROLL_DOWN_YPOS             (SYSIZE - 3 * ED_SCROLLBUTTON_YSIZE)
 120 #define ED_SCROLL_LEFT_XPOS             (0)
 121 #define ED_SCROLL_LEFT_YPOS             (SYSIZE - 2 * ED_SCROLLBUTTON_YSIZE)
 122 #define ED_SCROLL_RIGHT_XPOS            (SXSIZE - 2 * ED_SCROLLBUTTON_XSIZE)
 123 #define ED_SCROLL_RIGHT_YPOS            ED_SCROLL_LEFT_YPOS
 124 #define ED_SCROLL_HORIZONTAL_XPOS (ED_SCROLL_LEFT_XPOS + ED_SCROLLBUTTON_XSIZE)
 125 #define ED_SCROLL_HORIZONTAL_YPOS       ED_SCROLL_LEFT_YPOS
 126 #define ED_SCROLL_HORIZONTAL_XSIZE      (SXSIZE - 3 * ED_SCROLLBUTTON_XSIZE)
 127 #define ED_SCROLL_HORIZONTAL_YSIZE      ED_SCROLLBUTTON_YSIZE
 128 #define ED_SCROLL_VERTICAL_XPOS         ED_SCROLL_UP_XPOS
 129 #define ED_SCROLL_VERTICAL_YPOS   (ED_SCROLL_UP_YPOS + ED_SCROLLBUTTON_YSIZE)
 130 #define ED_SCROLL_VERTICAL_XSIZE        ED_SCROLLBUTTON_XSIZE
 131 #define ED_SCROLL_VERTICAL_YSIZE        (SYSIZE - 4 * ED_SCROLLBUTTON_YSIZE)
 132
 133 /* values for scrolling gadgets for element list */
 134 #define ED_SCROLLBUTTON2_XPOS           50
 135 #define ED_SCROLLBUTTON2_YPOS           0
 136 #define ED_SCROLLBAR2_XPOS              50
 137 #define ED_SCROLLBAR2_YPOS              20
 138
 139 #define ED_SCROLLBUTTON2_XSIZE          10
 140 #define ED_SCROLLBUTTON2_YSIZE          10
 141
 142 #define ED_SCROLL2_UP_XPOS              85
 143 #define ED_SCROLL2_UP_YPOS              30
 144 #define ED_SCROLL2_DOWN_XPOS            ED_SCROLL2_UP_XPOS
 145 #define ED_SCROLL2_DOWN_YPOS            (ED_SCROLL2_UP_YPOS + \
 146                                          ED_ELEMENTLIST_BUTTONS_VERT * \
 147                                          ED_ELEMENTLIST_YSIZE - \
 148                                          ED_SCROLLBUTTON2_YSIZE)
 149 #define ED_SCROLL2_VERTICAL_XPOS        ED_SCROLL2_UP_XPOS
 150 #define ED_SCROLL2_VERTICAL_YPOS        (ED_SCROLL2_UP_YPOS + \
 151                                          ED_SCROLLBUTTON2_YSIZE)
 152 #define ED_SCROLL2_VERTICAL_XSIZE       ED_SCROLLBUTTON2_XSIZE
 153 #define ED_SCROLL2_VERTICAL_YSIZE       (ED_ELEMENTLIST_BUTTONS_VERT * \
 154                                          ED_ELEMENTLIST_YSIZE - \
 155                                          2 * ED_SCROLLBUTTON2_YSIZE)
 156
 157 /* values for checkbutton gadgets */
 158 #define ED_CHECKBUTTON_XSIZE            ED_BUTTON_COUNT_XSIZE
 159 #define ED_CHECKBUTTON_YSIZE            ED_BUTTON_COUNT_YSIZE
 160 #define ED_CHECKBUTTON_UNCHECKED_XPOS   ED_BUTTON_MINUS_XPOS
 161 #define ED_CHECKBUTTON_CHECKED_XPOS     ED_BUTTON_PLUS_XPOS
 162 #define ED_CHECKBUTTON_YPOS             (ED_BUTTON_MINUS_YPOS + 22)
 163 #define ED_RADIOBUTTON_YPOS             (ED_BUTTON_MINUS_YPOS + 44)
 164 #define ED_STICKYBUTTON_YPOS            (ED_BUTTON_MINUS_YPOS + 66)
 165
 166 /* some positions in the editor control window */
 167 #define ED_BUTTON_ELEM_XPOS             6
 168 #define ED_BUTTON_ELEM_YPOS             30
 169 #define ED_BUTTON_ELEM_XSIZE            22
 170 #define ED_BUTTON_ELEM_YSIZE            22
 171
 172 /* some values for text input, selectbox and counter gadgets */
 173 #define ED_BUTTON_COUNT_YPOS            60
 174 #define ED_BUTTON_COUNT_XSIZE           20
 175 #define ED_BUTTON_COUNT_YSIZE           20
 176 #define ED_WIN_COUNT_XPOS               (2 + ED_BUTTON_COUNT_XSIZE + 2)
 177 #define ED_WIN_COUNT_YPOS               ED_BUTTON_COUNT_YPOS
 178 #define ED_WIN_COUNT_XSIZE              52
 179 #define ED_WIN_COUNT_YSIZE              ED_BUTTON_COUNT_YSIZE
 180 #define ED_WIN_COUNT2_XPOS              27
 181 #define ED_WIN_COUNT2_YPOS              3
 182 #define ED_WIN_COUNT2_XSIZE             46
 183 #define ED_WIN_COUNT2_YSIZE             ED_BUTTON_COUNT_YSIZE
 184
 185 #define ED_BUTTON_MINUS_XPOS            2
 186 #define ED_BUTTON_MINUS_YPOS            ED_BUTTON_COUNT_YPOS
 187 #define ED_BUTTON_MINUS_XSIZE           ED_BUTTON_COUNT_XSIZE
 188 #define ED_BUTTON_MINUS_YSIZE           ED_BUTTON_COUNT_YSIZE
 189 #define ED_BUTTON_PLUS_XPOS             (ED_WIN_COUNT_XPOS + \
 190                                          ED_WIN_COUNT_XSIZE + 2)
 191 #define ED_BUTTON_PLUS_YPOS             ED_BUTTON_COUNT_YPOS
 192 #define ED_BUTTON_PLUS_XSIZE            ED_BUTTON_COUNT_XSIZE
 193 #define ED_BUTTON_PLUS_YSIZE            ED_BUTTON_COUNT_YSIZE
 194
 195 #define ED_SELECTBOX_XPOS               ED_WIN_COUNT_XPOS
 196 #define ED_SELECTBOX_YPOS               (ED_WIN_COUNT_YPOS + \
 197                                          2 + ED_WIN_COUNT_YSIZE)
 198 #define ED_SELECTBOX_XSIZE              ED_WIN_COUNT_XSIZE
 199 #define ED_SELECTBOX_YSIZE              ED_WIN_COUNT_YSIZE
 200
 201 #define ED_TEXTBUTTON_XPOS              ED_WIN_COUNT_XPOS
 202 #define ED_TEXTBUTTON_YPOS              (ED_WIN_COUNT_YPOS + \
 203                                          2 * (2 + ED_WIN_COUNT_YSIZE))
 204 #define ED_TEXTBUTTON_INACTIVE_YPOS     (ED_WIN_COUNT_YPOS + \
 205                                          3 * (2 + ED_WIN_COUNT_YSIZE))
 206 #define ED_TEXTBUTTON_XSIZE             ED_WIN_COUNT_XSIZE
 207 #define ED_TEXTBUTTON_YSIZE             ED_WIN_COUNT_YSIZE
 208
 209 /* values for ClearEditorGadgetInfoText() and HandleGadgetInfoText() */
 210 #define INFOTEXT_XPOS                   SX
 211 #define INFOTEXT_YPOS                   (SY + SYSIZE - MINI_TILEX + 2)
 212 #define INFOTEXT_XSIZE                  SXSIZE
 213 #define INFOTEXT_YSIZE                  MINI_TILEX
 214
 215
 216 /*
 217   -----------------------------------------------------------------------------
 218   editor gadget definitions
 219   -----------------------------------------------------------------------------
 220 */
 221
 222 /* drawing toolbox buttons */
 223 #define GADGET_ID_NONE                  -1
 224 #define GADGET_ID_TOOLBOX_FIRST         0
 225
 226 #define GADGET_ID_SINGLE_ITEMS          (GADGET_ID_TOOLBOX_FIRST + 0)
 227 #define GADGET_ID_CONNECTED_ITEMS       (GADGET_ID_TOOLBOX_FIRST + 1)
 228 #define GADGET_ID_LINE                  (GADGET_ID_TOOLBOX_FIRST + 2)
 229 #define GADGET_ID_ARC                   (GADGET_ID_TOOLBOX_FIRST + 3)
 230 #define GADGET_ID_RECTANGLE             (GADGET_ID_TOOLBOX_FIRST + 4)
 231 #define GADGET_ID_FILLED_BOX            (GADGET_ID_TOOLBOX_FIRST + 5)
 232 #define GADGET_ID_WRAP_UP               (GADGET_ID_TOOLBOX_FIRST + 6)
 233 #define GADGET_ID_TEXT                  (GADGET_ID_TOOLBOX_FIRST + 7)
 234 #define GADGET_ID_FLOOD_FILL            (GADGET_ID_TOOLBOX_FIRST + 8)
 235 #define GADGET_ID_WRAP_LEFT             (GADGET_ID_TOOLBOX_FIRST + 9)
 236 #define GADGET_ID_PROPERTIES            (GADGET_ID_TOOLBOX_FIRST + 10)
 237 #define GADGET_ID_WRAP_RIGHT            (GADGET_ID_TOOLBOX_FIRST + 11)
 238 #define GADGET_ID_RANDOM_PLACEMENT      (GADGET_ID_TOOLBOX_FIRST + 12)
 239 #define GADGET_ID_GRAB_BRUSH            (GADGET_ID_TOOLBOX_FIRST + 13)
 240 #define GADGET_ID_WRAP_DOWN             (GADGET_ID_TOOLBOX_FIRST + 14)
 241 #define GADGET_ID_PICK_ELEMENT          (GADGET_ID_TOOLBOX_FIRST + 15)
 242 #define GADGET_ID_UNDO                  (GADGET_ID_TOOLBOX_FIRST + 16)
 243 #define GADGET_ID_INFO                  (GADGET_ID_TOOLBOX_FIRST + 17)
 244 #define GADGET_ID_SAVE                  (GADGET_ID_TOOLBOX_FIRST + 18)
 245 #define GADGET_ID_CLEAR                 (GADGET_ID_TOOLBOX_FIRST + 19)
 246 #define GADGET_ID_TEST                  (GADGET_ID_TOOLBOX_FIRST + 20)
 247 #define GADGET_ID_EXIT                  (GADGET_ID_TOOLBOX_FIRST + 21)
 248
 249 /* counter button identifiers */
 250 #define GADGET_ID_COUNTER_FIRST         (GADGET_ID_TOOLBOX_FIRST + 22)
 251
 252 #define GADGET_ID_ELEM_SCORE_DOWN       (GADGET_ID_COUNTER_FIRST + 0)
 253 #define GADGET_ID_ELEM_SCORE_TEXT       (GADGET_ID_COUNTER_FIRST + 1)
 254 #define GADGET_ID_ELEM_SCORE_UP         (GADGET_ID_COUNTER_FIRST + 2)
 255 #define GADGET_ID_ELEM_CONTENT_DOWN     (GADGET_ID_COUNTER_FIRST + 3)
 256 #define GADGET_ID_ELEM_CONTENT_TEXT     (GADGET_ID_COUNTER_FIRST + 4)
 257 #define GADGET_ID_ELEM_CONTENT_UP       (GADGET_ID_COUNTER_FIRST + 5)
 258 #define GADGET_ID_LEVEL_XSIZE_DOWN      (GADGET_ID_COUNTER_FIRST + 6)
 259 #define GADGET_ID_LEVEL_XSIZE_TEXT      (GADGET_ID_COUNTER_FIRST + 7)
 260 #define GADGET_ID_LEVEL_XSIZE_UP        (GADGET_ID_COUNTER_FIRST + 8)
 261 #define GADGET_ID_LEVEL_YSIZE_DOWN      (GADGET_ID_COUNTER_FIRST + 9)
 262 #define GADGET_ID_LEVEL_YSIZE_TEXT      (GADGET_ID_COUNTER_FIRST + 10)
 263 #define GADGET_ID_LEVEL_YSIZE_UP        (GADGET_ID_COUNTER_FIRST + 11)
 264 #define GADGET_ID_LEVEL_RANDOM_DOWN     (GADGET_ID_COUNTER_FIRST + 12)
 265 #define GADGET_ID_LEVEL_RANDOM_TEXT     (GADGET_ID_COUNTER_FIRST + 13)
 266 #define GADGET_ID_LEVEL_RANDOM_UP       (GADGET_ID_COUNTER_FIRST + 14)
 267 #define GADGET_ID_LEVEL_COLLECT_DOWN    (GADGET_ID_COUNTER_FIRST + 15)
 268 #define GADGET_ID_LEVEL_COLLECT_TEXT    (GADGET_ID_COUNTER_FIRST + 16)
 269 #define GADGET_ID_LEVEL_COLLECT_UP      (GADGET_ID_COUNTER_FIRST + 17)
 270 #define GADGET_ID_LEVEL_TIMELIMIT_DOWN  (GADGET_ID_COUNTER_FIRST + 18)
 271 #define GADGET_ID_LEVEL_TIMELIMIT_TEXT  (GADGET_ID_COUNTER_FIRST + 19)
 272 #define GADGET_ID_LEVEL_TIMELIMIT_UP    (GADGET_ID_COUNTER_FIRST + 20)
 273 #define GADGET_ID_LEVEL_TIMESCORE_DOWN  (GADGET_ID_COUNTER_FIRST + 21)
 274 #define GADGET_ID_LEVEL_TIMESCORE_TEXT  (GADGET_ID_COUNTER_FIRST + 22)
 275 #define GADGET_ID_LEVEL_TIMESCORE_UP    (GADGET_ID_COUNTER_FIRST + 23)
 276 #define GADGET_ID_SELECT_LEVEL_DOWN     (GADGET_ID_COUNTER_FIRST + 24)
 277 #define GADGET_ID_SELECT_LEVEL_TEXT     (GADGET_ID_COUNTER_FIRST + 25)
 278 #define GADGET_ID_SELECT_LEVEL_UP       (GADGET_ID_COUNTER_FIRST + 26)
 279
 280 /* drawing area identifiers */
 281 #define GADGET_ID_DRAWING_AREA_FIRST    (GADGET_ID_COUNTER_FIRST + 27)
 282
 283 #define GADGET_ID_DRAWING_LEVEL         (GADGET_ID_DRAWING_AREA_FIRST + 0)
 284 #define GADGET_ID_ELEM_CONTENT_0        (GADGET_ID_DRAWING_AREA_FIRST + 1)
 285 #define GADGET_ID_ELEM_CONTENT_1        (GADGET_ID_DRAWING_AREA_FIRST + 2)
 286 #define GADGET_ID_ELEM_CONTENT_2        (GADGET_ID_DRAWING_AREA_FIRST + 3)
 287 #define GADGET_ID_ELEM_CONTENT_3        (GADGET_ID_DRAWING_AREA_FIRST + 4)
 288 #define GADGET_ID_ELEM_CONTENT_4        (GADGET_ID_DRAWING_AREA_FIRST + 5)
 289 #define GADGET_ID_ELEM_CONTENT_5        (GADGET_ID_DRAWING_AREA_FIRST + 6)
 290 #define GADGET_ID_ELEM_CONTENT_6        (GADGET_ID_DRAWING_AREA_FIRST + 7)
 291 #define GADGET_ID_ELEM_CONTENT_7        (GADGET_ID_DRAWING_AREA_FIRST + 8)
 292 #define GADGET_ID_AMOEBA_CONTENT        (GADGET_ID_DRAWING_AREA_FIRST + 9)
 293 #define GADGET_ID_CUSTOM_CHANGED        (GADGET_ID_DRAWING_AREA_FIRST + 10)
 294 #define GADGET_ID_RANDOM_BACKGROUND     (GADGET_ID_DRAWING_AREA_FIRST + 11)
 295
 296 /* text input identifiers */
 297 #define GADGET_ID_TEXT_INPUT_FIRST      (GADGET_ID_DRAWING_AREA_FIRST + 12)
 298
 299 #define GADGET_ID_LEVEL_NAME            (GADGET_ID_TEXT_INPUT_FIRST + 0)
 300 #define GADGET_ID_LEVEL_AUTHOR          (GADGET_ID_TEXT_INPUT_FIRST + 1)
 301
 302 /* selectbox identifiers */
 303 #define GADGET_ID_SELECTBOX_FIRST       (GADGET_ID_TEXT_INPUT_FIRST + 2)
 304
 305 #define GADGET_ID_CUSTOM_CHANGE_CAUSE   (GADGET_ID_SELECTBOX_FIRST + 0)
 306
 307 /* textbutton identifiers */
 308 #define GADGET_ID_TEXTBUTTON_FIRST      (GADGET_ID_SELECTBOX_FIRST + 1)
 309
 310 #define GADGET_ID_PROPERTIES_INFO       (GADGET_ID_TEXTBUTTON_FIRST + 0)
 311 #define GADGET_ID_PROPERTIES_CONFIG     (GADGET_ID_TEXTBUTTON_FIRST + 1)
 312 #define GADGET_ID_PROPERTIES_ADVANCED   (GADGET_ID_TEXTBUTTON_FIRST + 2)
 313
 314 /* gadgets for scrolling of drawing area */
 315 #define GADGET_ID_SCROLLING_FIRST       (GADGET_ID_TEXTBUTTON_FIRST + 3)
 316
 317 #define GADGET_ID_SCROLL_UP             (GADGET_ID_SCROLLING_FIRST + 0)
 318 #define GADGET_ID_SCROLL_DOWN           (GADGET_ID_SCROLLING_FIRST + 1)
 319 #define GADGET_ID_SCROLL_LEFT           (GADGET_ID_SCROLLING_FIRST + 2)
 320 #define GADGET_ID_SCROLL_RIGHT          (GADGET_ID_SCROLLING_FIRST + 3)
 321 #define GADGET_ID_SCROLL_HORIZONTAL     (GADGET_ID_SCROLLING_FIRST + 4)
 322 #define GADGET_ID_SCROLL_VERTICAL       (GADGET_ID_SCROLLING_FIRST + 5)
 323
 324 /* gadgets for scrolling element list */
 325 #define GADGET_ID_SCROLLING_LIST_FIRST  (GADGET_ID_SCROLLING_FIRST + 6)
 326
 327 #define GADGET_ID_SCROLL_LIST_UP        (GADGET_ID_SCROLLING_LIST_FIRST + 0)
 328 #define GADGET_ID_SCROLL_LIST_DOWN      (GADGET_ID_SCROLLING_LIST_FIRST + 1)
 329 #define GADGET_ID_SCROLL_LIST_VERTICAL  (GADGET_ID_SCROLLING_LIST_FIRST + 2)
 330
 331 /* buttons for level/element properties */
 332 #define GADGET_ID_CHECKBUTTON_FIRST     (GADGET_ID_SCROLLING_LIST_FIRST + 3)
 333
 334 #define GADGET_ID_RANDOM_PERCENTAGE     (GADGET_ID_CHECKBUTTON_FIRST + 0)
 335 #define GADGET_ID_RANDOM_QUANTITY       (GADGET_ID_CHECKBUTTON_FIRST + 1)
 336 #define GADGET_ID_RANDOM_RESTRICTED     (GADGET_ID_CHECKBUTTON_FIRST + 2)
 337 #define GADGET_ID_DOUBLE_SPEED          (GADGET_ID_CHECKBUTTON_FIRST + 3)
 338 #define GADGET_ID_GRAVITY               (GADGET_ID_CHECKBUTTON_FIRST + 4)
 339 #define GADGET_ID_STICK_ELEMENT         (GADGET_ID_CHECKBUTTON_FIRST + 5)
 340 #define GADGET_ID_EM_SLIPPERY_GEMS      (GADGET_ID_CHECKBUTTON_FIRST + 6)
 341 #define GADGET_ID_CUSTOM_INDESTRUCTIBLE (GADGET_ID_CHECKBUTTON_FIRST + 7)
 342 #define GADGET_ID_CUSTOM_DIGGABLE       (GADGET_ID_CHECKBUTTON_FIRST + 8)
 343 #define GADGET_ID_CUSTOM_COLLECTIBLE    (GADGET_ID_CHECKBUTTON_FIRST + 9)
 344 #define GADGET_ID_CUSTOM_PUSHABLE       (GADGET_ID_CHECKBUTTON_FIRST + 10)
 345 #define GADGET_ID_CUSTOM_CAN_FALL       (GADGET_ID_CHECKBUTTON_FIRST + 11)
 346 #define GADGET_ID_CUSTOM_CAN_SMASH      (GADGET_ID_CHECKBUTTON_FIRST + 12)
 347 #define GADGET_ID_CUSTOM_CAN_MOVE       (GADGET_ID_CHECKBUTTON_FIRST + 13)
 348 #define GADGET_ID_CUSTOM_SLIPPERY       (GADGET_ID_CHECKBUTTON_FIRST + 14)
 349 #define GADGET_ID_CUSTOM_WALKABLE_OVER  (GADGET_ID_CHECKBUTTON_FIRST + 15)
 350 #define GADGET_ID_CUSTOM_WALKABLE_INSIDE (GADGET_ID_CHECKBUTTON_FIRST+ 16)
 351 #define GADGET_ID_CUSTOM_WALKABLE_UNDER (GADGET_ID_CHECKBUTTON_FIRST + 17)
 352
 353 /* gadgets for buttons in element list */
 354 #define GADGET_ID_ELEMENTLIST_FIRST     (GADGET_ID_CHECKBUTTON_FIRST + 18)
 355 #define GADGET_ID_ELEMENTLIST_LAST      (GADGET_ID_ELEMENTLIST_FIRST +  \
 356                                         ED_NUM_ELEMENTLIST_BUTTONS - 1)
 357
 358 #define NUM_EDITOR_GADGETS              (GADGET_ID_ELEMENTLIST_LAST + 1)
 359
 360 /* radio button numbers */
 361 #define RADIO_NR_NONE                   0
 362 #define RADIO_NR_DRAWING_TOOLBOX        1
 363 #define RADIO_NR_RANDOM_ELEMENTS        2
 364
 365 /* values for counter gadgets */
 366 #define ED_COUNTER_ID_ELEM_SCORE        0
 367 #define ED_COUNTER_ID_ELEM_CONTENT      1
 368 #define ED_COUNTER_ID_LEVEL_XSIZE       2
 369 #define ED_COUNTER_ID_LEVEL_YSIZE       3
 370 #define ED_COUNTER_ID_LEVEL_COLLECT     4
 371 #define ED_COUNTER_ID_LEVEL_TIMELIMIT   5
 372 #define ED_COUNTER_ID_LEVEL_TIMESCORE   6
 373 #define ED_COUNTER_ID_LEVEL_RANDOM      7
 374 #define ED_COUNTER_ID_SELECT_LEVEL      8
 375
 376 #define ED_NUM_COUNTERBUTTONS           9
 377
 378 #define ED_COUNTER_ID_LEVEL_FIRST       ED_COUNTER_ID_LEVEL_XSIZE
 379 #define ED_COUNTER_ID_LEVEL_LAST        ED_COUNTER_ID_LEVEL_RANDOM
 380
 381 /* values for scrollbutton gadgets */
 382 #define ED_SCROLLBUTTON_ID_AREA_UP      0
 383 #define ED_SCROLLBUTTON_ID_AREA_DOWN    1
 384 #define ED_SCROLLBUTTON_ID_AREA_LEFT    2
 385 #define ED_SCROLLBUTTON_ID_AREA_RIGHT   3
 386 #define ED_SCROLLBUTTON_ID_LIST_UP      4
 387 #define ED_SCROLLBUTTON_ID_LIST_DOWN    5
 388
 389 #define ED_NUM_SCROLLBUTTONS            6
 390
 391 #define ED_SCROLLBUTTON_ID_AREA_FIRST   ED_SCROLLBUTTON_ID_AREA_UP
 392 #define ED_SCROLLBUTTON_ID_AREA_LAST    ED_SCROLLBUTTON_ID_AREA_RIGHT
 393
 394 /* values for scrollbar gadgets */
 395 #define ED_SCROLLBAR_ID_AREA_HORIZONTAL 0
 396 #define ED_SCROLLBAR_ID_AREA_VERTICAL   1
 397 #define ED_SCROLLBAR_ID_LIST_VERTICAL   2
 398
 399 #define ED_NUM_SCROLLBARS               3
 400
 401 #define ED_SCROLLBAR_ID_AREA_FIRST      ED_SCROLLBAR_ID_AREA_HORIZONTAL
 402 #define ED_SCROLLBAR_ID_AREA_LAST       ED_SCROLLBAR_ID_AREA_VERTICAL
 403
 404 /* values for text input gadgets */
 405 #define ED_TEXTINPUT_ID_LEVEL_NAME      0
 406 #define ED_TEXTINPUT_ID_LEVEL_AUTHOR    1
 407
 408 #define ED_NUM_TEXTINPUT                2
 409
 410 #define ED_TEXTINPUT_ID_LEVEL_FIRST     ED_TEXTINPUT_ID_LEVEL_NAME
 411 #define ED_TEXTINPUT_ID_LEVEL_LAST      ED_TEXTINPUT_ID_LEVEL_AUTHOR
 412
 413 /* values for selectbox gadgets */
 414 #define ED_SELECTBOX_ID_CUSTOM_CHANGE_CAUSE     0
 415
 416 #define ED_NUM_SELECTBOX                        1
 417
 418 /* values for textbutton gadgets */
 419 #define ED_TEXTBUTTON_ID_PROPERTIES_INFO        0
 420 #define ED_TEXTBUTTON_ID_PROPERTIES_CONFIG      1
 421 #define ED_TEXTBUTTON_ID_PROPERTIES_ADVANCED    2
 422
 423 #define ED_NUM_TEXTBUTTON                       3
 424
 425 /* values for checkbutton gadgets */
 426 #define ED_CHECKBUTTON_ID_DOUBLE_SPEED          0
 427 #define ED_CHECKBUTTON_ID_GRAVITY               1
 428 #define ED_CHECKBUTTON_ID_RANDOM_RESTRICTED     2
 429 #define ED_CHECKBUTTON_ID_STICK_ELEMENT         3
 430 #define ED_CHECKBUTTON_ID_EM_SLIPPERY_GEMS      4
 431 #define ED_CHECKBUTTON_ID_CUSTOM_INDESTRUCTIBLE 5
 432 #define ED_CHECKBUTTON_ID_CUSTOM_DIGGABLE       6
 433 #define ED_CHECKBUTTON_ID_CUSTOM_COLLECTIBLE    7
 434 #define ED_CHECKBUTTON_ID_CUSTOM_PUSHABLE       8
 435 #define ED_CHECKBUTTON_ID_CUSTOM_CAN_FALL       9
 436 #define ED_CHECKBUTTON_ID_CUSTOM_CAN_SMASH      10
 437 #define ED_CHECKBUTTON_ID_CUSTOM_CAN_MOVE       11
 438 #define ED_CHECKBUTTON_ID_CUSTOM_SLIPPERY       12
 439 #define ED_CHECKBUTTON_ID_CUSTOM_WALKABLE_OVER  13
 440 #define ED_CHECKBUTTON_ID_CUSTOM_WALKABLE_INSIDE 14
 441 #define ED_CHECKBUTTON_ID_CUSTOM_WALKABLE_UNDER 15
 442
 443 #define ED_NUM_CHECKBUTTONS                     16
 444
 445 #define ED_CHECKBUTTON_ID_LEVEL_FIRST   ED_CHECKBUTTON_ID_DOUBLE_SPEED
 446 #define ED_CHECKBUTTON_ID_LEVEL_LAST    ED_CHECKBUTTON_ID_RANDOM_RESTRICTED
 447
 448 #define ED_CHECKBUTTON_ID_CUSTOM_FIRST  ED_CHECKBUTTON_ID_CUSTOM_INDESTRUCTIBLE
 449 #define ED_CHECKBUTTON_ID_CUSTOM_LAST   ED_CHECKBUTTON_ID_CUSTOM_WALKABLE_UNDER
 450
 451 /* values for radiobutton gadgets */
 452 #define ED_RADIOBUTTON_ID_PERCENTAGE    0
 453 #define ED_RADIOBUTTON_ID_QUANTITY      1
 454
 455 #define ED_NUM_RADIOBUTTONS             2
 456
 457 #define ED_RADIOBUTTON_ID_LEVEL_FIRST   ED_RADIOBUTTON_ID_PERCENTAGE
 458 #define ED_RADIOBUTTON_ID_LEVEL_LAST    ED_RADIOBUTTON_ID_QUANTITY
 459
 460
 461 /*
 462   -----------------------------------------------------------------------------
 463   some internally used definitions
 464   -----------------------------------------------------------------------------
 465 */
 466
 467 /* values for CopyLevelToUndoBuffer() */
 468 #define UNDO_IMMEDIATE                  0
 469 #define UNDO_ACCUMULATE                 1
 470
 471 /* values for scrollbars */
 472 #define ED_SCROLL_NO                    0
 473 #define ED_SCROLL_LEFT                  1
 474 #define ED_SCROLL_RIGHT                 2
 475 #define ED_SCROLL_UP                    4
 476 #define ED_SCROLL_DOWN                  8
 477
 478 /* screens in the level editor */
 479 #define ED_MODE_DRAWING                 0
 480 #define ED_MODE_INFO                    1
 481 #define ED_MODE_PROPERTIES              2
 482
 483 /* sub-screens in the element properties section */
 484 #define ED_MODE_PROPERTIES_INFO         ED_TEXTBUTTON_ID_PROPERTIES_INFO
 485 #define ED_MODE_PROPERTIES_CONFIG       ED_TEXTBUTTON_ID_PROPERTIES_CONFIG
 486 #define ED_MODE_PROPERTIES_ADVANCED     ED_TEXTBUTTON_ID_PROPERTIES_ADVANCED
 487
 488 /* how many steps can be cancelled */
 489 #define NUM_UNDO_STEPS                  (10 + 1)
 490
 491 /* values for elements with score */
 492 #define MIN_SCORE                       0
 493 #define MAX_SCORE                       255
 494
 495 /* values for random placement */
 496 #define RANDOM_USE_PERCENTAGE           0
 497 #define RANDOM_USE_QUANTITY             1
 498
 499 /* maximal size of level editor drawing area */
 500 #define MAX_ED_FIELDX           (2 * SCR_FIELDX)
 501 #define MAX_ED_FIELDY           (2 * SCR_FIELDY - 1)
 502
 503
 504 /*
 505   -----------------------------------------------------------------------------
 506   some internally used data structure definitions
 507   -----------------------------------------------------------------------------
 508 */
 509
 510 static struct
 511 {
 512   char shortcut;
 513   char *text;
 514 } control_info[ED_NUM_CTRL_BUTTONS] =
 515 {
 516   { 's',        "draw single items"             },
 517   { 'd',        "draw connected items"          },
 518   { 'l',        "draw lines"                    },
 519   { 'a',        "draw arcs"                     },
 520   { 'r',        "draw outline rectangles"       },
 521   { 'R',        "draw filled rectangles"        },
 522   { '\0',       "wrap (rotate) level up"        },
 523   { 't',        "enter text elements"           },
 524   { 'f',        "flood fill"                    },
 525   { '\0',       "wrap (rotate) level left"      },
 526   { '?',        "properties of drawing element" },
 527   { '\0',       "wrap (rotate) level right"     },
 528   { '\0',       "random element placement"      },
 529   { 'b',        "grab brush"                    },
 530   { '\0',       "wrap (rotate) level down"      },
 531   { ',',        "pick drawing element"          },
 532   { 'U',        "undo last operation"           },
 533   { 'I',        "level properties"              },
 534   { 'S',        "save level"                    },
 535   { 'C',        "clear level"                   },
 536   { 'T',        "test level"                    },
 537   { 'E',        "exit level editor"             }
 538 };
 539
 540 static int random_placement_value = 10;
 541 static int random_placement_method = RANDOM_USE_QUANTITY;
 542 static int random_placement_background_element = EL_SAND;
 543 static boolean random_placement_background_restricted = FALSE;
 544 static boolean stick_element_properties_window = FALSE;
 545 static boolean custom_element_properties[NUM_ELEMENT_PROPERTIES];
 546
 547 static struct
 548 {
 549   int x, y;
 550   int min_value, max_value;
 551   int gadget_id_down, gadget_id_up;
 552   int gadget_id_text;
 553   int *value;
 554   char *infotext_above, *infotext_right;
 555 } counterbutton_info[ED_NUM_COUNTERBUTTONS] =
 556 {
 557   {
 558     ED_COUNT_ELEM_SCORE_XPOS,           ED_COUNT_ELEM_SCORE_YPOS,
 559     MIN_SCORE,                          MAX_SCORE,
 560     GADGET_ID_ELEM_SCORE_DOWN,          GADGET_ID_ELEM_SCORE_UP,
 561     GADGET_ID_ELEM_SCORE_TEXT,
 562     NULL,                               /* will be set when used */
 563     "element score",                    NULL
 564   },
 565   {
 566     ED_COUNT_ELEM_CONTENT_XPOS,         ED_COUNT_ELEM_CONTENT_YPOS,
 567     MIN_ELEMENT_CONTENTS,               MAX_ELEMENT_CONTENTS,
 568     GADGET_ID_ELEM_CONTENT_DOWN,        GADGET_ID_ELEM_CONTENT_UP,
 569     GADGET_ID_ELEM_CONTENT_TEXT,
 570     &level.num_yam_contents,
 571     "element content",                  NULL
 572   },
 573   {
 574     ED_SETTINGS_XPOS,                   ED_COUNTER_YPOS(2),
 575     MIN_LEV_FIELDX,                     MAX_LEV_FIELDX,
 576     GADGET_ID_LEVEL_XSIZE_DOWN,         GADGET_ID_LEVEL_XSIZE_UP,
 577     GADGET_ID_LEVEL_XSIZE_TEXT,
 578     &level.fieldx,
 579     "playfield size",                   "width",
 580   },
 581   {
 582     ED_SETTINGS_XPOS + 2 * DXSIZE,      ED_COUNTER_YPOS(2),
 583     MIN_LEV_FIELDY,                     MAX_LEV_FIELDY,
 584     GADGET_ID_LEVEL_YSIZE_DOWN,         GADGET_ID_LEVEL_YSIZE_UP,
 585     GADGET_ID_LEVEL_YSIZE_TEXT,
 586     &level.fieldy,
 587     NULL,                               "height",
 588   },
 589   {
 590     ED_SETTINGS_XPOS,                   ED_COUNTER_YPOS(3),
 591     0,                                  999,
 592     GADGET_ID_LEVEL_COLLECT_DOWN,       GADGET_ID_LEVEL_COLLECT_UP,
 593     GADGET_ID_LEVEL_COLLECT_TEXT,
 594     &level.gems_needed,
 595     "number of emeralds to collect",    NULL
 596   },
 597   {
 598     ED_SETTINGS_XPOS,                   ED_COUNTER_YPOS(4),
 599     0,                                  999,
 600     GADGET_ID_LEVEL_TIMELIMIT_DOWN,     GADGET_ID_LEVEL_TIMELIMIT_UP,
 601     GADGET_ID_LEVEL_TIMELIMIT_TEXT,
 602     &level.time,
 603     "time available to solve level",    "(0 => no time limit)"
 604   },
 605   {
 606     ED_SETTINGS_XPOS,                   ED_COUNTER_YPOS(5),
 607     0,                                  255,
 608     GADGET_ID_LEVEL_TIMESCORE_DOWN,     GADGET_ID_LEVEL_TIMESCORE_UP,
 609     GADGET_ID_LEVEL_TIMESCORE_TEXT,
 610     &level.score[SC_TIME_BONUS],
 611     "score for each 10 seconds left",   NULL
 612   },
 613   {
 614     ED_SETTINGS_XPOS,                   ED_COUNTER2_YPOS(8),
 615     1,                                  100,
 616     GADGET_ID_LEVEL_RANDOM_DOWN,        GADGET_ID_LEVEL_RANDOM_UP,
 617     GADGET_ID_LEVEL_RANDOM_TEXT,
 618     &random_placement_value,
 619     "random element placement",         "in"
 620   },
 621   {
 622     DX + 5 - SX,                        DY + 3 - SY,
 623     1,                                  100,
 624     GADGET_ID_SELECT_LEVEL_DOWN,        GADGET_ID_SELECT_LEVEL_UP,
 625     GADGET_ID_SELECT_LEVEL_TEXT,
 626     &level_nr,
 627     NULL,                               NULL
 628   }
 629 };
 630
 631 static struct
 632 {
 633   int x, y;
 634   int gadget_id;
 635   int size;
 636   char *value;
 637   char *infotext;
 638 } textinput_info[ED_NUM_TEXTINPUT] =
 639 {
 640   {
 641     ED_SETTINGS_XPOS,                   ED_COUNTER_YPOS(0),
 642     GADGET_ID_LEVEL_NAME,
 643     MAX_LEVEL_NAME_LEN,
 644     level.name,
 645     "Title"
 646   },
 647   {
 648     ED_SETTINGS_XPOS,                   ED_COUNTER_YPOS(1),
 649     GADGET_ID_LEVEL_AUTHOR,
 650     MAX_LEVEL_AUTHOR_LEN,
 651     level.author,
 652     "Author"
 653   }
 654 };
 655
 656 static struct ValueTextInfo options_change_cause[] =
 657 {
 658   { 1,  "specified delay"       },
 659   { 2,  "impact (active)"       },
 660   { 3,  "impact (passive)"      },
 661   { 4,  "touched by player"     },
 662   { 5,  "pressed by player"     },
 663   { -1, NULL                    }
 664 };
 665 static int index_change_cause = 0;
 666
 667 static struct
 668 {
 669   int x, y;
 670   int gadget_id;
 671   int size;
 672   struct ValueTextInfo *options;
 673   int *index;
 674   char *text, *infotext;
 675 } selectbox_info[ED_NUM_SELECTBOX] =
 676 {
 677   {
 678     ED_SETTINGS_XPOS,                   ED_COUNTER_YPOS(3),
 679     GADGET_ID_CUSTOM_CHANGE_CAUSE,
 680     17,
 681     options_change_cause, &index_change_cause,
 682     "test:", "test-selectbox entry"
 683   },
 684 };
 685
 686 static struct
 687 {
 688   int x, y;
 689   int gadget_id;
 690   int size;
 691   char *value;
 692   char *infotext;
 693 } textbutton_info[ED_NUM_TEXTBUTTON] =
 694 {
 695   {
 696     ED_SETTINGS_XPOS,                   ED_COUNTER_YPOS(1),
 697     GADGET_ID_PROPERTIES_INFO,
 698     11, "Information",
 699     "Show information about element"
 700   },
 701   {
 702     ED_SETTINGS_XPOS + 166,             ED_COUNTER_YPOS(1),
 703     GADGET_ID_PROPERTIES_CONFIG,
 704     11, "Configure",
 705     "Configure element properties"
 706   },
 707   {
 708     ED_SETTINGS_XPOS + 332,             ED_COUNTER_YPOS(1),
 709     GADGET_ID_PROPERTIES_ADVANCED,
 710     11, "Advanced",
 711     "Advanced element configuration"
 712   },
 713 };
 714
 715 static struct
 716 {
 717   int xpos, ypos;
 718   int x, y;
 719   int gadget_id;
 720   char *infotext;
 721 } scrollbutton_info[ED_NUM_SCROLLBUTTONS] =
 722 {
 723   {
 724     ED_SCROLLBUTTON_XPOS,   ED_SCROLLBUTTON_YPOS + 0 * ED_SCROLLBUTTON_YSIZE,
 725     ED_SCROLL_UP_XPOS,      ED_SCROLL_UP_YPOS,
 726     GADGET_ID_SCROLL_UP,
 727     "scroll level editing area up"
 728   },
 729   {
 730     ED_SCROLLBUTTON_XPOS,   ED_SCROLLBUTTON_YPOS + 1 * ED_SCROLLBUTTON_YSIZE,
 731     ED_SCROLL_DOWN_XPOS,    ED_SCROLL_DOWN_YPOS,
 732     GADGET_ID_SCROLL_DOWN,
 733     "scroll level editing area down"
 734   },
 735   {
 736     ED_SCROLLBUTTON_XPOS,   ED_SCROLLBUTTON_YPOS + 2 * ED_SCROLLBUTTON_YSIZE,
 737     ED_SCROLL_LEFT_XPOS,    ED_SCROLL_LEFT_YPOS,
 738     GADGET_ID_SCROLL_LEFT,
 739     "scroll level editing area left"
 740   },
 741   {
 742     ED_SCROLLBUTTON_XPOS,   ED_SCROLLBUTTON_YPOS + 3 * ED_SCROLLBUTTON_YSIZE,
 743     ED_SCROLL_RIGHT_XPOS,   ED_SCROLL_RIGHT_YPOS,
 744     GADGET_ID_SCROLL_RIGHT,
 745     "scroll level editing area right"
 746   },
 747   {
 748     ED_SCROLLBUTTON2_XPOS,  ED_SCROLLBUTTON2_YPOS + 0 * ED_SCROLLBUTTON2_YSIZE,
 749     ED_SCROLL2_UP_XPOS,     ED_SCROLL2_UP_YPOS,
 750     GADGET_ID_SCROLL_LIST_UP,
 751     "scroll element list up ('Page Up')"
 752   },
 753   {
 754     ED_SCROLLBUTTON2_XPOS,  ED_SCROLLBUTTON2_YPOS + 1 * ED_SCROLLBUTTON2_YSIZE,
 755     ED_SCROLL2_DOWN_XPOS,    ED_SCROLL2_DOWN_YPOS,
 756     GADGET_ID_SCROLL_LIST_DOWN,
 757     "scroll element list down ('Page Down')"
 758   }
 759 };
 760
 761 static struct
 762 {
 763   int xpos, ypos;
 764   int x, y;
 765   int width, height;
 766   int type;
 767   int gadget_id;
 768   char *infotext;
 769 } scrollbar_info[ED_NUM_SCROLLBARS] =
 770 {
 771   {
 772     ED_SCROLLBAR_XPOS,                  ED_SCROLLBAR_YPOS,
 773     SX + ED_SCROLL_HORIZONTAL_XPOS,     SY + ED_SCROLL_HORIZONTAL_YPOS,
 774     ED_SCROLL_HORIZONTAL_XSIZE,         ED_SCROLL_HORIZONTAL_YSIZE,
 775     GD_TYPE_SCROLLBAR_HORIZONTAL,
 776     GADGET_ID_SCROLL_HORIZONTAL,
 777     "scroll level editing area horizontally"
 778   },
 779   {
 780     ED_SCROLLBAR_XPOS,                  ED_SCROLLBAR_YPOS,
 781     SX + ED_SCROLL_VERTICAL_XPOS,       SY + ED_SCROLL_VERTICAL_YPOS,
 782     ED_SCROLL_VERTICAL_XSIZE,           ED_SCROLL_VERTICAL_YSIZE,
 783     GD_TYPE_SCROLLBAR_VERTICAL,
 784     GADGET_ID_SCROLL_VERTICAL,
 785     "scroll level editing area vertically"
 786   },
 787   {
 788     ED_SCROLLBAR2_XPOS,                 ED_SCROLLBAR2_YPOS,
 789     DX + ED_SCROLL2_VERTICAL_XPOS,      DY + ED_SCROLL2_VERTICAL_YPOS,
 790     ED_SCROLL2_VERTICAL_XSIZE,          ED_SCROLL2_VERTICAL_YSIZE,
 791     GD_TYPE_SCROLLBAR_VERTICAL,
 792     GADGET_ID_SCROLL_LIST_VERTICAL,
 793     "scroll element list vertically"
 794   }
 795 };
 796
 797 static struct
 798 {
 799   int x, y;
 800   int gadget_id;
 801   int radio_button_nr;
 802   int *value;
 803   int checked_value;
 804   char *text, *infotext;
 805 } radiobutton_info[ED_NUM_RADIOBUTTONS] =
 806 {
 807   {
 808     ED_SETTINGS_XPOS + 160,             ED_COUNTER2_YPOS(8),
 809     GADGET_ID_RANDOM_PERCENTAGE,
 810     RADIO_NR_RANDOM_ELEMENTS,
 811     &random_placement_method,           RANDOM_USE_PERCENTAGE,
 812     "percentage",                       "use percentage for random elements"
 813   },
 814   {
 815     ED_SETTINGS_XPOS + 340,             ED_COUNTER2_YPOS(8),
 816     GADGET_ID_RANDOM_QUANTITY,
 817     RADIO_NR_RANDOM_ELEMENTS,
 818     &random_placement_method,           RANDOM_USE_QUANTITY,
 819     "quantity",                         "use quantity for random elements"
 820   }
 821 };
 822
 823 static struct
 824 {
 825   int x, y;
 826   int gadget_id;
 827   boolean *value;
 828   char *text, *infotext;
 829 } checkbutton_info[ED_NUM_CHECKBUTTONS] =
 830 {
 831   {
 832     ED_SETTINGS_XPOS,                   ED_COUNTER_YPOS(6) - MINI_TILEY,
 833     GADGET_ID_DOUBLE_SPEED,
 834     &level.double_speed,
 835     "double speed movement",            "set movement speed of player"
 836   },
 837   {
 838     ED_SETTINGS_XPOS + 340,             ED_COUNTER_YPOS(6) - MINI_TILEY,
 839     GADGET_ID_GRAVITY,
 840     &level.gravity,
 841     "gravity",                          "set level gravity"
 842   },
 843   {
 844     ED_SETTINGS_XPOS,                   ED_COUNTER2_YPOS(9) - MINI_TILEY,
 845     GADGET_ID_RANDOM_RESTRICTED,
 846     &random_placement_background_restricted,
 847     "restrict random placement to",     "set random placement restriction"
 848   },
 849   {
 850     ED_SETTINGS_XPOS,                   ED_COUNTER_YPOS(4),
 851     GADGET_ID_STICK_ELEMENT,
 852     &stick_element_properties_window,
 853     "stick window to edit content",     "stick window to edit content"
 854   },
 855   {
 856     ED_SETTINGS_XPOS,                   ED_COUNTER_YPOS(4),
 857     GADGET_ID_EM_SLIPPERY_GEMS,
 858     &level.em_slippery_gems,
 859     "slip down from certain flat walls","use EM style slipping behaviour"
 860   },
 861   {
 862     ED_SETTINGS_XPOS,                   ED_COUNTER_YPOS2(5),
 863     GADGET_ID_CUSTOM_INDESTRUCTIBLE,
 864     &custom_element_properties[EP_INDESTRUCTIBLE],
 865     "indestructible",                   "element cannot be destroyed"
 866   },
 867   {
 868     ED_SETTINGS_XPOS,                   ED_COUNTER_YPOS2(6),
 869     GADGET_ID_CUSTOM_DIGGABLE,
 870     &custom_element_properties[EP_DIGGABLE],
 871     "diggable",                         "element can be digged away"
 872   },
 873   {
 874     ED_SETTINGS_XPOS,                   ED_COUNTER_YPOS2(7),
 875     GADGET_ID_CUSTOM_COLLECTIBLE,
 876     &custom_element_properties[EP_COLLECTIBLE],
 877     "collectible",                      "element can be collected"
 878   },
 879   {
 880     ED_SETTINGS_XPOS,                   ED_COUNTER_YPOS2(8),
 881     GADGET_ID_CUSTOM_PUSHABLE,
 882     &custom_element_properties[EP_PUSHABLE],
 883     "pushable",                         "element can be pushed"
 884   },
 885   {
 886     ED_SETTINGS_XPOS,                   ED_COUNTER_YPOS2(9),
 887     GADGET_ID_CUSTOM_CAN_FALL,
 888     &custom_element_properties[EP_CAN_FALL],
 889     "can fall",                         "element can fall down"
 890   },
 891   {
 892     ED_SETTINGS_XPOS,                   ED_COUNTER_YPOS2(10),
 893     GADGET_ID_CUSTOM_CAN_SMASH,
 894     &custom_element_properties[EP_CAN_SMASH],
 895     "can smash",                        "element can smash other elements"
 896   },
 897   {
 898     ED_SETTINGS_XPOS,                   ED_COUNTER_YPOS2(11),
 899     GADGET_ID_CUSTOM_CAN_MOVE,
 900     &custom_element_properties[EP_CAN_MOVE],
 901     "can move",                         "element can move in some direction"
 902   },
 903   {
 904     ED_SETTINGS_XPOS,                   ED_COUNTER_YPOS2(12),
 905     GADGET_ID_CUSTOM_SLIPPERY,
 906     &custom_element_properties[EP_SLIPPERY],
 907     "slippery",                         "other elements can fall down from it"
 908   },
 909   {
 910     ED_SETTINGS_XPOS,                   ED_COUNTER_YPOS2(13),
 911     GADGET_ID_CUSTOM_WALKABLE_OVER,
 912     &custom_element_properties[EP_WALKABLE_OVER],
 913     "player can walk over",             "player can walk over this element"
 914   },
 915   {
 916     ED_SETTINGS_XPOS,                   ED_COUNTER_YPOS2(14),
 917     GADGET_ID_CUSTOM_WALKABLE_INSIDE,
 918     &custom_element_properties[EP_WALKABLE_INSIDE],
 919     "player can walk inside",           "player can walk inside this element"
 920   },
 921   {
 922     ED_SETTINGS_XPOS,                   ED_COUNTER_YPOS2(15),
 923     GADGET_ID_CUSTOM_WALKABLE_UNDER,
 924     &custom_element_properties[EP_WALKABLE_UNDER],
 925     "player can walk under",            "player can walk under this element"
 926   }
 927 };
 928
 929
 930 /*
 931   -----------------------------------------------------------------------------
 932   some internally used variables
 933   -----------------------------------------------------------------------------
 934 */
 935
 936 /* actual size of level editor drawing area */
 937 static int ed_fieldx = MAX_ED_FIELDX - 1, ed_fieldy = MAX_ED_FIELDY - 1;
 938
 939 /* actual position of level editor drawing area in level playfield */
 940 static int level_xpos = -1, level_ypos = -1;
 941
 942 #define IN_ED_FIELD(x,y)  ((x)>=0 && (x)<ed_fieldx && (y)>=0 &&(y)<ed_fieldy)
 943
 944 /* drawing elements on the three mouse buttons */
 945 static int new_element1 = EL_WALL;
 946 static int new_element2 = EL_EMPTY;
 947 static int new_element3 = EL_SAND;
 948
 949 #define BUTTON_ELEMENT(button) ((button) == 1 ? new_element1 : \
 950                                 (button) == 2 ? new_element2 : \
 951                                 (button) == 3 ? new_element3 : EL_EMPTY)
 952 #define BUTTON_STEPSIZE(button) ((button) == 1 ? 1 : (button) == 2 ? 5 : 10)
 953
 954 /* forward declaration for internal use */
 955 static void ModifyEditorCounter(int, int);
 956 static void ModifyEditorCounterLimits(int, int, int);
 957 static void DrawDrawingWindow();
 958 static void DrawLevelInfoWindow();
 959 static void DrawPropertiesWindow();
 960 static void CopyLevelToUndoBuffer(int);
 961 static void HandleDrawingAreas(struct GadgetInfo *);
 962 static void HandleCounterButtons(struct GadgetInfo *);
 963 static void HandleTextInputGadgets(struct GadgetInfo *);
 964 static void HandleSelectboxGadgets(struct GadgetInfo *);
 965 static void HandleTextbuttonGadgets(struct GadgetInfo *);
 966 static void HandleRadiobuttons(struct GadgetInfo *);
 967 static void HandleCheckbuttons(struct GadgetInfo *);
 968 static void HandleControlButtons(struct GadgetInfo *);
 969 static void HandleDrawingAreaInfo(struct GadgetInfo *);
 970
 971 static struct GadgetInfo *level_editor_gadget[NUM_EDITOR_GADGETS];
 972
 973 static int drawing_function = GADGET_ID_SINGLE_ITEMS;
 974 static int last_drawing_function = GADGET_ID_SINGLE_ITEMS;
 975 static boolean draw_with_brush = FALSE;
 976 static int properties_element = 0;
 977
 978 static short ElementContent[MAX_ELEMENT_CONTENTS][3][3];
 979 static short FieldBackup[MAX_LEV_FIELDX][MAX_LEV_FIELDY];
 980 static short UndoBuffer[NUM_UNDO_STEPS][MAX_LEV_FIELDX][MAX_LEV_FIELDY];
 981 static int undo_buffer_position = 0;
 982 static int undo_buffer_steps = 0;
 983
 984 static int edit_mode;
 985 static int edit_mode_properties;
 986
 987 static int element_shift = 0;
 988
 989 static int editor_el_boulderdash[] =
 990 {
 991   EL_CHAR('B'),
 992   EL_CHAR('O'),
 993   EL_CHAR('U'),
 994   EL_CHAR('L'),
 995
 996   EL_CHAR('-'),
 997   EL_CHAR('D'),
 998   EL_CHAR('E'),
 999   EL_CHAR('R'),
1000
1001   EL_CHAR('D'),
1002   EL_CHAR('A'),
1003   EL_CHAR('S'),
1004   EL_CHAR('H'),
1005
1006   EL_PLAYER_1,
1007   EL_EMPTY,
1008   EL_SAND,
1009   EL_STEELWALL,
1010
1011   EL_BD_WALL,
1012   EL_BD_MAGIC_WALL,
1013   EL_EXIT_CLOSED,
1014   EL_EXIT_OPEN,
1015
1016   EL_BD_DIAMOND,
1017   EL_BD_BUTTERFLY_UP,
1018   EL_BD_FIREFLY_UP,
1019   EL_BD_ROCK,
1020
1021   EL_BD_BUTTERFLY_LEFT,
1022   EL_BD_FIREFLY_LEFT,
1023   EL_BD_BUTTERFLY_RIGHT,
1024   EL_BD_FIREFLY_RIGHT,
1025
1026   EL_BD_AMOEBA,
1027   EL_BD_BUTTERFLY_DOWN,
1028   EL_BD_FIREFLY_DOWN,
1029   EL_EMPTY,
1030 };
1031 static int num_editor_el_boulderdash = SIZEOF_ARRAY_INT(editor_el_boulderdash);
1032
1033 static int editor_el_emerald_mine[] =
1034 {
1035   EL_CHAR('E'),
1036   EL_CHAR('M'),
1037   EL_CHAR('E'),
1038   EL_CHAR('-'),
1039
1040   EL_CHAR('R'),
1041   EL_CHAR('A'),
1042   EL_CHAR('L'),
1043   EL_CHAR('D'),
1044
1045   EL_CHAR('M'),
1046   EL_CHAR('I'),
1047   EL_CHAR('N'),
1048   EL_CHAR('E'),
1049
1050   EL_PLAYER_1,
1051   EL_PLAYER_2,
1052   EL_PLAYER_3,
1053   EL_PLAYER_4,
1054
1055   EL_PLAYER_1,
1056   EL_EMPTY,
1057   EL_SAND,
1058   EL_ROCK,
1059
1060   EL_STEELWALL,
1061   EL_WALL,
1062   EL_WALL_CRUMBLED,
1063   EL_MAGIC_WALL,
1064
1065   EL_EMERALD,
1066   EL_DIAMOND,
1067   EL_NUT,
1068   EL_BOMB,
1069
1070   EL_WALL_EMERALD,
1071   EL_WALL_DIAMOND,
1072   EL_QUICKSAND_EMPTY,
1073   EL_QUICKSAND_FULL,
1074
1075   EL_DYNAMITE,
1076   EL_DYNAMITE_ACTIVE,
1077   EL_EXIT_CLOSED,
1078   EL_EXIT_OPEN,
1079
1080   EL_YAMYAM,
1081   EL_BUG_UP,
1082   EL_SPACESHIP_UP,
1083   EL_ROBOT,
1084
1085   EL_BUG_LEFT,
1086   EL_SPACESHIP_LEFT,
1087   EL_BUG_RIGHT,
1088   EL_SPACESHIP_RIGHT,
1089
1090   EL_ROBOT_WHEEL,
1091   EL_BUG_DOWN,
1092   EL_SPACESHIP_DOWN,
1093   EL_INVISIBLE_WALL,
1094
1095   EL_ACID_POOL_TOPLEFT,
1096   EL_ACID,
1097   EL_ACID_POOL_TOPRIGHT,
1098   EL_EMPTY,
1099
1100   EL_ACID_POOL_BOTTOMLEFT,
1101   EL_ACID_POOL_BOTTOM,
1102   EL_ACID_POOL_BOTTOMRIGHT,
1103   EL_EMPTY,
1104
1105   EL_AMOEBA_DROP,
1106   EL_AMOEBA_DEAD,
1107   EL_AMOEBA_WET,
1108   EL_AMOEBA_DRY,
1109
1110   EL_EM_KEY_1_FILE,
1111   EL_EM_KEY_2_FILE,
1112   EL_EM_KEY_3_FILE,
1113   EL_EM_KEY_4_FILE,
1114
1115   EL_EM_GATE_1,
1116   EL_EM_GATE_2,
1117   EL_EM_GATE_3,
1118   EL_EM_GATE_4,
1119
1120   EL_EM_GATE_1_GRAY,
1121   EL_EM_GATE_2_GRAY,
1122   EL_EM_GATE_3_GRAY,
1123   EL_EM_GATE_4_GRAY,
1124 };
1125 static int num_editor_el_emerald_mine = SIZEOF_ARRAY_INT(editor_el_emerald_mine);
1126
1127 static int editor_el_more[] =
1128 {
1129   EL_CHAR('M'),
1130   EL_CHAR('O'),
1131   EL_CHAR('R'),
1132   EL_CHAR('E'),
1133
1134   EL_KEY_1,
1135   EL_KEY_2,
1136   EL_KEY_3,
1137   EL_KEY_4,
1138
1139   EL_GATE_1,
1140   EL_GATE_2,
1141   EL_GATE_3,
1142   EL_GATE_4,
1143
1144   EL_GATE_1_GRAY,
1145   EL_GATE_2_GRAY,
1146   EL_GATE_3_GRAY,
1147   EL_GATE_4_GRAY,
1148
1149   EL_ARROW_LEFT,
1150   EL_ARROW_RIGHT,
1151   EL_ARROW_UP,
1152   EL_ARROW_DOWN,
1153
1154   EL_AMOEBA_FULL,
1155   EL_EMERALD_YELLOW,
1156   EL_EMERALD_RED,
1157   EL_EMERALD_PURPLE,
1158
1159   EL_WALL_BD_DIAMOND,
1160   EL_WALL_EMERALD_YELLOW,
1161   EL_WALL_EMERALD_RED,
1162   EL_WALL_EMERALD_PURPLE,
1163
1164   EL_GAME_OF_LIFE,
1165   EL_PACMAN_UP,
1166   EL_TIME_ORB_FULL,
1167   EL_TIME_ORB_EMPTY,
1168
1169   EL_PACMAN_LEFT,
1170   EL_DARK_YAMYAM,
1171   EL_PACMAN_RIGHT,
1172   EL_EXPANDABLE_WALL,
1173
1174   EL_BIOMAZE,
1175   EL_PACMAN_DOWN,
1176   EL_LAMP,
1177   EL_LAMP_ACTIVE,
1178
1179   EL_DYNABOMB_INCREASE_NUMBER,
1180   EL_DYNABOMB_INCREASE_SIZE,
1181   EL_DYNABOMB_INCREASE_POWER,
1182   EL_STONEBLOCK,
1183
1184   EL_MOLE,
1185   EL_PENGUIN,
1186   EL_PIG,
1187   EL_DRAGON,
1188
1189   EL_EMPTY,
1190   EL_MOLE_UP,
1191   EL_EMPTY,
1192   EL_EMPTY,
1193
1194   EL_MOLE_LEFT,
1195   EL_EMPTY,
1196   EL_MOLE_RIGHT,
1197   EL_EMPTY,
1198
1199   EL_EMPTY,
1200   EL_MOLE_DOWN,
1201   EL_BALLOON,
1202   EL_BALLOON_SWITCH_ANY,
1203
1204   EL_BALLOON_SWITCH_LEFT,
1205   EL_BALLOON_SWITCH_RIGHT,
1206   EL_BALLOON_SWITCH_UP,
1207   EL_BALLOON_SWITCH_DOWN,
1208
1209   EL_SATELLITE,
1210   EL_EXPANDABLE_WALL_HORIZONTAL,
1211   EL_EXPANDABLE_WALL_VERTICAL,
1212   EL_EXPANDABLE_WALL_ANY,
1213
1214   EL_INVISIBLE_STEELWALL,
1215   EL_INVISIBLE_WALL,
1216   EL_SPEED_PILL,
1217   EL_BLACK_ORB,
1218
1219   EL_EMC_STEELWALL_1,
1220   EL_EMC_WALL_1,
1221   EL_EMC_WALL_2,
1222   EL_EMC_WALL_3,
1223
1224   EL_EMC_WALL_4,
1225   EL_EMC_WALL_5,
1226   EL_EMC_WALL_6,
1227   EL_EMC_WALL_7,
1228 };
1229 static int num_editor_el_more = SIZEOF_ARRAY_INT(editor_el_more);
1230
1231 static int editor_el_sokoban[] =
1232 {
1233   EL_CHAR('S'),
1234   EL_CHAR('O'),
1235   EL_CHAR('K'),
1236   EL_CHAR('O'),
1237
1238   EL_CHAR('-'),
1239   EL_CHAR('B'),
1240   EL_CHAR('A'),
1241   EL_CHAR('N'),
1242
1243   EL_SOKOBAN_OBJECT,
1244   EL_SOKOBAN_FIELD_EMPTY,
1245   EL_SOKOBAN_FIELD_FULL,
1246   EL_STEELWALL,
1247 };
1248 static int num_editor_el_sokoban = SIZEOF_ARRAY_INT(editor_el_sokoban);
1249
1250 static int editor_el_supaplex[] =
1251 {
1252   EL_CHAR('S'),
1253   EL_CHAR('U'),
1254   EL_CHAR('P'),
1255   EL_CHAR('A'),
1256
1257   EL_CHAR('P'),
1258   EL_CHAR('L'),
1259   EL_CHAR('E'),
1260   EL_CHAR('X'),
1261
1262   EL_SP_EMPTY,
1263   EL_SP_ZONK,
1264   EL_SP_BASE,
1265   EL_SP_MURPHY,
1266
1267   EL_SP_INFOTRON,
1268   EL_SP_CHIP_SINGLE,
1269   EL_SP_HARDWARE_GRAY,
1270   EL_SP_EXIT_CLOSED,
1271
1272   EL_SP_DISK_ORANGE,
1273   EL_SP_PORT_RIGHT,
1274   EL_SP_PORT_DOWN,
1275   EL_SP_PORT_LEFT,
1276
1277   EL_SP_PORT_UP,
1278   EL_SP_GRAVITY_PORT_RIGHT,
1279   EL_SP_GRAVITY_PORT_DOWN,
1280   EL_SP_GRAVITY_PORT_LEFT,
1281
1282   EL_SP_GRAVITY_PORT_UP,
1283   EL_SP_SNIKSNAK,
1284   EL_SP_DISK_YELLOW,
1285   EL_SP_TERMINAL,
1286
1287   EL_SP_DISK_RED,
1288   EL_SP_PORT_VERTICAL,
1289   EL_SP_PORT_HORIZONTAL,
1290   EL_SP_PORT_ANY,
1291
1292   EL_SP_ELECTRON,
1293   EL_SP_BUGGY_BASE,
1294   EL_SP_CHIP_LEFT,
1295   EL_SP_CHIP_RIGHT,
1296
1297   EL_SP_HARDWARE_BASE_1,
1298   EL_SP_HARDWARE_GREEN,
1299   EL_SP_HARDWARE_BLUE,
1300   EL_SP_HARDWARE_RED,
1301
1302   EL_SP_HARDWARE_YELLOW,
1303   EL_SP_HARDWARE_BASE_2,
1304   EL_SP_HARDWARE_BASE_3,
1305   EL_SP_HARDWARE_BASE_4,
1306
1307   EL_SP_HARDWARE_BASE_5,
1308   EL_SP_HARDWARE_BASE_6,
1309   EL_SP_CHIP_TOP,
1310   EL_SP_CHIP_BOTTOM,
1311 };
1312 static int num_editor_el_supaplex = SIZEOF_ARRAY_INT(editor_el_supaplex);
1313
1314 static int editor_el_diamond_caves[] =
1315 {
1316   EL_CHAR('D'),
1317   EL_CHAR('I'),
1318   EL_CHAR('A'),
1319   EL_CHAR('-'),
1320
1321   EL_CHAR('M'),
1322   EL_CHAR('O'),
1323   EL_CHAR('N'),
1324   EL_CHAR('D'),
1325
1326   EL_CHAR('C'),
1327   EL_CHAR('A'),
1328   EL_CHAR('V'),
1329   EL_CHAR('E'),
1330
1331   EL_CHAR('S'),
1332   EL_CHAR(' '),
1333   EL_CHAR('I'),
1334   EL_CHAR('I'),
1335
1336   EL_PEARL,
1337   EL_CRYSTAL,
1338   EL_WALL_PEARL,
1339   EL_WALL_CRYSTAL,
1340
1341   EL_CONVEYOR_BELT_1_LEFT,
1342   EL_CONVEYOR_BELT_1_MIDDLE,
1343   EL_CONVEYOR_BELT_1_RIGHT,
1344   EL_CONVEYOR_BELT_1_SWITCH_MIDDLE,
1345
1346   EL_CONVEYOR_BELT_2_LEFT,
1347   EL_CONVEYOR_BELT_2_MIDDLE,
1348   EL_CONVEYOR_BELT_2_RIGHT,
1349   EL_CONVEYOR_BELT_2_SWITCH_MIDDLE,
1350
1351   EL_CONVEYOR_BELT_3_LEFT,
1352   EL_CONVEYOR_BELT_3_MIDDLE,
1353   EL_CONVEYOR_BELT_3_RIGHT,
1354   EL_CONVEYOR_BELT_3_SWITCH_MIDDLE,
1355
1356   EL_CONVEYOR_BELT_4_LEFT,
1357   EL_CONVEYOR_BELT_4_MIDDLE,
1358   EL_CONVEYOR_BELT_4_RIGHT,
1359   EL_CONVEYOR_BELT_4_SWITCH_MIDDLE,
1360
1361   EL_CONVEYOR_BELT_1_SWITCH_LEFT,
1362   EL_CONVEYOR_BELT_2_SWITCH_LEFT,
1363   EL_CONVEYOR_BELT_3_SWITCH_LEFT,
1364   EL_CONVEYOR_BELT_4_SWITCH_LEFT,
1365
1366   EL_CONVEYOR_BELT_1_SWITCH_RIGHT,
1367   EL_CONVEYOR_BELT_2_SWITCH_RIGHT,
1368   EL_CONVEYOR_BELT_3_SWITCH_RIGHT,
1369   EL_CONVEYOR_BELT_4_SWITCH_RIGHT,
1370
1371   EL_SWITCHGATE_OPEN,
1372   EL_SWITCHGATE_CLOSED,
1373   EL_SWITCHGATE_SWITCH_UP,
1374   EL_ENVELOPE,
1375
1376   EL_TIMEGATE_CLOSED,
1377   EL_TIMEGATE_OPEN,
1378   EL_TIMEGATE_SWITCH,
1379   EL_EMPTY,
1380
1381   EL_LANDMINE,
1382   EL_INVISIBLE_SAND,
1383   EL_STEELWALL_SLANTED,
1384   EL_EMPTY,
1385
1386   EL_SIGN_EXCLAMATION,
1387   EL_SIGN_STOP,
1388   EL_LIGHT_SWITCH,
1389   EL_LIGHT_SWITCH_ACTIVE,
1390
1391   EL_SHIELD_NORMAL,
1392   EL_SHIELD_DEADLY,
1393   EL_EXTRA_TIME,
1394   EL_EMPTY,
1395 };
1396 static int num_editor_el_diamond_caves = SIZEOF_ARRAY_INT(editor_el_diamond_caves);
1397
1398 static int editor_el_dx_boulderdash[] =
1399 {
1400   EL_CHAR('D'),
1401   EL_CHAR('X'),
1402   EL_CHAR('-'),
1403   EL_CHAR(' '),
1404
1405   EL_CHAR('B'),
1406   EL_CHAR('O'),
1407   EL_CHAR('U'),
1408   EL_CHAR('L'),
1409
1410   EL_CHAR('-'),
1411   EL_CHAR('D'),
1412   EL_CHAR('E'),
1413   EL_CHAR('R'),
1414
1415   EL_CHAR('D'),
1416   EL_CHAR('A'),
1417   EL_CHAR('S'),
1418   EL_CHAR('H'),
1419
1420   EL_SPRING,
1421   EL_TUBE_RIGHT_DOWN,
1422   EL_TUBE_HORIZONTAL_DOWN,
1423   EL_TUBE_LEFT_DOWN,
1424
1425   EL_TUBE_HORIZONTAL,
1426   EL_TUBE_VERTICAL_RIGHT,
1427   EL_TUBE_ANY,
1428   EL_TUBE_VERTICAL_LEFT,
1429
1430   EL_TUBE_VERTICAL,
1431   EL_TUBE_RIGHT_UP,
1432   EL_TUBE_HORIZONTAL_UP,
1433   EL_TUBE_LEFT_UP,
1434
1435   EL_TRAP,
1436   EL_DX_SUPABOMB,
1437   EL_EMPTY,
1438   EL_EMPTY
1439 };
1440 static int num_editor_el_dx_boulderdash = SIZEOF_ARRAY_INT(editor_el_dx_boulderdash);
1441
1442 static int editor_el_chars[] =
1443 {
1444   EL_CHAR('T'),
1445   EL_CHAR('E'),
1446   EL_CHAR('X'),
1447   EL_CHAR('T'),
1448
1449   EL_CHAR(' '),
1450   EL_CHAR('!'),
1451   EL_CHAR('"'),
1452   EL_CHAR('#'),
1453
1454   EL_CHAR('$'),
1455   EL_CHAR('%'),
1456   EL_CHAR('&'),
1457   EL_CHAR('\''),
1458
1459   EL_CHAR('('),
1460   EL_CHAR(')'),
1461   EL_CHAR('*'),
1462   EL_CHAR('+'),
1463
1464   EL_CHAR(','),
1465   EL_CHAR('-'),
1466   EL_CHAR('.'),
1467   EL_CHAR('/'),
1468
1469   EL_CHAR('0'),
1470   EL_CHAR('1'),
1471   EL_CHAR('2'),
1472   EL_CHAR('3'),
1473
1474   EL_CHAR('4'),
1475   EL_CHAR('5'),
1476   EL_CHAR('6'),
1477   EL_CHAR('7'),
1478
1479   EL_CHAR('8'),
1480   EL_CHAR('9'),
1481   EL_CHAR(':'),
1482   EL_CHAR(';'),
1483
1484   EL_CHAR('<'),
1485   EL_CHAR('='),
1486   EL_CHAR('>'),
1487   EL_CHAR('?'),
1488
1489   EL_CHAR('@'),
1490   EL_CHAR('A'),
1491   EL_CHAR('B'),
1492   EL_CHAR('C'),
1493
1494   EL_CHAR('D'),
1495   EL_CHAR('E'),
1496   EL_CHAR('F'),
1497   EL_CHAR('G'),
1498
1499   EL_CHAR('H'),
1500   EL_CHAR('I'),
1501   EL_CHAR('J'),
1502   EL_CHAR('K'),
1503
1504   EL_CHAR('L'),
1505   EL_CHAR('M'),
1506   EL_CHAR('N'),
1507   EL_CHAR('O'),
1508
1509   EL_CHAR('P'),
1510   EL_CHAR('Q'),
1511   EL_CHAR('R'),
1512   EL_CHAR('S'),
1513
1514   EL_CHAR('T'),
1515   EL_CHAR('U'),
1516   EL_CHAR('V'),
1517   EL_CHAR('W'),
1518
1519   EL_CHAR('X'),
1520   EL_CHAR('Y'),
1521   EL_CHAR('Z'),
1522   EL_CHAR('['),
1523
1524   EL_CHAR('\\'),
1525   EL_CHAR(']'),
1526   EL_CHAR('^'),
1527   EL_CHAR('_'),
1528
1529   EL_CHAR('©'),
1530   EL_CHAR('Ä'),
1531   EL_CHAR('Ö'),
1532   EL_CHAR('Ü'),
1533
1534   EL_CHAR('°'),
1535   EL_CHAR('®'),
1536   EL_CHAR(FONT_ASCII_CURSOR),
1537   EL_CHAR(' ')
1538 };
1539 static int num_editor_el_chars = SIZEOF_ARRAY_INT(editor_el_chars);
1540
1541 static int editor_el_custom[] =
1542 {
1543   EL_CHAR('C'),
1544   EL_CHAR('U'),
1545   EL_CHAR('S'),
1546   EL_CHAR('-'),
1547
1548   EL_CHAR('T'),
1549   EL_CHAR('O'),
1550   EL_CHAR('M'),
1551   EL_CHAR(' '),
1552
1553   EL_CHAR('E'),
1554   EL_CHAR('L'),
1555   EL_CHAR('E'),
1556   EL_CHAR('M'),
1557
1558   EL_CHAR('E'),
1559   EL_CHAR('N'),
1560   EL_CHAR('T'),
1561   EL_CHAR('S'),
1562
1563   EL_CUSTOM_START + 0,
1564   EL_CUSTOM_START + 1,
1565   EL_CUSTOM_START + 2,
1566   EL_CUSTOM_START + 3,
1567
1568   EL_CUSTOM_START + 4,
1569   EL_CUSTOM_START + 5,
1570   EL_CUSTOM_START + 6,
1571   EL_CUSTOM_START + 7,
1572
1573   EL_CUSTOM_START + 8,
1574   EL_CUSTOM_START + 9,
1575   EL_CUSTOM_START + 10,
1576   EL_CUSTOM_START + 11,
1577
1578   EL_CUSTOM_START + 12,
1579   EL_CUSTOM_START + 13,
1580   EL_CUSTOM_START + 14,
1581   EL_CUSTOM_START + 15,
1582
1583   EL_CUSTOM_START + 16,
1584   EL_CUSTOM_START + 17,
1585   EL_CUSTOM_START + 18,
1586   EL_CUSTOM_START + 19,
1587
1588   EL_CUSTOM_START + 20,
1589   EL_CUSTOM_START + 21,
1590   EL_CUSTOM_START + 22,
1591   EL_CUSTOM_START + 23,
1592
1593   EL_CUSTOM_START + 24,
1594   EL_CUSTOM_START + 25,
1595   EL_CUSTOM_START + 26,
1596   EL_CUSTOM_START + 27,
1597
1598   EL_CUSTOM_START + 28,
1599   EL_CUSTOM_START + 29,
1600   EL_CUSTOM_START + 30,
1601   EL_CUSTOM_START + 31,
1602
1603   EL_CUSTOM_START + 32,
1604   EL_CUSTOM_START + 33,
1605   EL_CUSTOM_START + 34,
1606   EL_CUSTOM_START + 35,
1607
1608   EL_CUSTOM_START + 36,
1609   EL_CUSTOM_START + 37,
1610   EL_CUSTOM_START + 38,
1611   EL_CUSTOM_START + 39,
1612
1613   EL_CUSTOM_START + 40,
1614   EL_CUSTOM_START + 41,
1615   EL_CUSTOM_START + 42,
1616   EL_CUSTOM_START + 43,
1617
1618   EL_CUSTOM_START + 44,
1619   EL_CUSTOM_START + 45,
1620   EL_CUSTOM_START + 46,
1621   EL_CUSTOM_START + 47,
1622
1623   EL_CUSTOM_START + 48,
1624   EL_CUSTOM_START + 49,
1625   EL_CUSTOM_START + 50,
1626   EL_CUSTOM_START + 51,
1627
1628   EL_CUSTOM_START + 52,
1629   EL_CUSTOM_START + 53,
1630   EL_CUSTOM_START + 54,
1631   EL_CUSTOM_START + 55,
1632
1633   EL_CUSTOM_START + 56,
1634   EL_CUSTOM_START + 57,
1635   EL_CUSTOM_START + 58,
1636   EL_CUSTOM_START + 59,
1637
1638   EL_CUSTOM_START + 60,
1639   EL_CUSTOM_START + 61,
1640   EL_CUSTOM_START + 62,
1641   EL_CUSTOM_START + 63,
1642
1643   EL_CUSTOM_START + 64,
1644   EL_CUSTOM_START + 65,
1645   EL_CUSTOM_START + 66,
1646   EL_CUSTOM_START + 67,
1647
1648   EL_CUSTOM_START + 68,
1649   EL_CUSTOM_START + 69,
1650   EL_CUSTOM_START + 70,
1651   EL_CUSTOM_START + 71,
1652
1653   EL_CUSTOM_START + 72,
1654   EL_CUSTOM_START + 73,
1655   EL_CUSTOM_START + 74,
1656   EL_CUSTOM_START + 75,
1657
1658   EL_CUSTOM_START + 76,
1659   EL_CUSTOM_START + 77,
1660   EL_CUSTOM_START + 78,
1661   EL_CUSTOM_START + 79,
1662
1663   EL_CUSTOM_START + 80,
1664   EL_CUSTOM_START + 81,
1665   EL_CUSTOM_START + 82,
1666   EL_CUSTOM_START + 83,
1667
1668   EL_CUSTOM_START + 84,
1669   EL_CUSTOM_START + 85,
1670   EL_CUSTOM_START + 86,
1671   EL_CUSTOM_START + 87,
1672
1673   EL_CUSTOM_START + 88,
1674   EL_CUSTOM_START + 89,
1675   EL_CUSTOM_START + 90,
1676   EL_CUSTOM_START + 91,
1677
1678   EL_CUSTOM_START + 92,
1679   EL_CUSTOM_START + 93,
1680   EL_CUSTOM_START + 94,
1681   EL_CUSTOM_START + 95,
1682
1683   EL_CUSTOM_START + 96,
1684   EL_CUSTOM_START + 97,
1685   EL_CUSTOM_START + 98,
1686   EL_CUSTOM_START + 99,
1687
1688   EL_CUSTOM_START + 100,
1689   EL_CUSTOM_START + 101,
1690   EL_CUSTOM_START + 102,
1691   EL_CUSTOM_START + 103,
1692
1693   EL_CUSTOM_START + 104,
1694   EL_CUSTOM_START + 105,
1695   EL_CUSTOM_START + 106,
1696   EL_CUSTOM_START + 107,
1697
1698   EL_CUSTOM_START + 108,
1699   EL_CUSTOM_START + 109,
1700   EL_CUSTOM_START + 110,
1701   EL_CUSTOM_START + 111,
1702
1703   EL_CUSTOM_START + 112,
1704   EL_CUSTOM_START + 113,
1705   EL_CUSTOM_START + 114,
1706   EL_CUSTOM_START + 115,
1707
1708   EL_CUSTOM_START + 116,
1709   EL_CUSTOM_START + 117,
1710   EL_CUSTOM_START + 118,
1711   EL_CUSTOM_START + 119,
1712
1713   EL_CUSTOM_START + 120,
1714   EL_CUSTOM_START + 121,
1715   EL_CUSTOM_START + 122,
1716   EL_CUSTOM_START + 123,
1717
1718   EL_CUSTOM_START + 124,
1719   EL_CUSTOM_START + 125,
1720   EL_CUSTOM_START + 126,
1721   EL_CUSTOM_START + 127
1722 };
1723 static int num_editor_el_custom = SIZEOF_ARRAY_INT(editor_el_custom);
1724
1725 static int *editor_elements = NULL;     /* dynamically allocated */
1726 static int num_editor_elements = 0;     /* dynamically determined */
1727
1728 static struct
1729 {
1730   boolean *setup_value;
1731   int *element_list;
1732   int *element_list_size;
1733
1734   boolean last_setup_value;
1735 }
1736 editor_elements_info[] =
1737 {
1738   { &setup.editor.el_boulderdash,       editor_el_boulderdash,
1739     &num_editor_el_boulderdash                                          },
1740   { &setup.editor.el_emerald_mine,      editor_el_emerald_mine,
1741     &num_editor_el_emerald_mine                                         },
1742   { &setup.editor.el_more,              editor_el_more,
1743     &num_editor_el_more                                                 },
1744   { &setup.editor.el_sokoban,           editor_el_sokoban,
1745     &num_editor_el_sokoban                                              },
1746   { &setup.editor.el_supaplex,          editor_el_supaplex,
1747     &num_editor_el_supaplex                                             },
1748   { &setup.editor.el_diamond_caves,     editor_el_diamond_caves,
1749     &num_editor_el_diamond_caves                                        },
1750   { &setup.editor.el_dx_boulderdash,    editor_el_dx_boulderdash,
1751     &num_editor_el_dx_boulderdash                                       },
1752   { &setup.editor.el_chars,             editor_el_chars,
1753     &num_editor_el_chars                                                },
1754   { &setup.editor.el_custom,            editor_el_custom,
1755     &num_editor_el_custom                                               },
1756   { NULL,                               NULL,
1757     NULL                                                                }
1758 };
1759
1760
1761 /*
1762   -----------------------------------------------------------------------------
1763   functions
1764   -----------------------------------------------------------------------------
1765 */
1766
1767 static void ReinitializeElementList()
1768 {
1769   int pos = 0;
1770   int i, j;
1771
1772   if (editor_elements != NULL)
1773     free(editor_elements);
1774
1775   num_editor_elements = 0;
1776
1777   /* determine size of element list */
1778   for (i=0; editor_elements_info[i].setup_value != NULL; i++)
1779     if (*editor_elements_info[i].setup_value)
1780       num_editor_elements += *editor_elements_info[i].element_list_size;
1781
1782   if (num_editor_elements < ED_NUM_ELEMENTLIST_BUTTONS)
1783   {
1784     /* workaround: offer at least as many elements as element buttons exist */
1785     int list_nr = 1;    /* see above: editor_elements_info for Emerald Mine */
1786
1787     *editor_elements_info[list_nr].setup_value = TRUE;
1788     num_editor_elements += *editor_elements_info[list_nr].element_list_size;
1789   }
1790
1791   editor_elements = checked_malloc(num_editor_elements * sizeof(int));
1792
1793   /* fill element list */
1794   for (i=0; editor_elements_info[i].setup_value != NULL; i++)
1795     if (*editor_elements_info[i].setup_value)
1796       for (j=0; j<*editor_elements_info[i].element_list_size; j++)
1797         editor_elements[pos++] = editor_elements_info[i].element_list[j];
1798 }
1799
1800 static void ReinitializeElementListButtons()
1801 {
1802   static boolean initialization_needed = TRUE;
1803   int i;
1804
1805   if (!initialization_needed)   /* check if editor element setup has changed */
1806     for (i=0; editor_elements_info[i].setup_value != NULL; i++)
1807       if (editor_elements_info[i].last_setup_value !=
1808           *editor_elements_info[i].setup_value)
1809         initialization_needed = TRUE;
1810
1811   if (!initialization_needed)
1812     return;
1813
1814   FreeLevelEditorGadgets();
1815   CreateLevelEditorGadgets();
1816
1817   /* store current setup values for next invocation of this function */
1818   for (i=0; editor_elements_info[i].setup_value != NULL; i++)
1819     editor_elements_info[i].last_setup_value =
1820       *editor_elements_info[i].setup_value;
1821
1822   initialization_needed = FALSE;
1823 }
1824
1825 static int getCounterGadgetWidth()
1826 {
1827   return (DXSIZE + getFontWidth(FONT_INPUT_1) - 2 * ED_GADGET_DISTANCE);
1828 }
1829
1830 static int getMaxInfoTextLength()
1831 {
1832   return (SXSIZE / getFontWidth(FONT_TEXT_2));
1833 }
1834
1835 static char *getElementInfoText(int element)
1836 {
1837   char *info_text = NULL;
1838
1839   if (element < NUM_FILE_ELEMENTS)
1840   {
1841     if (element_info[element].custom_description != NULL)
1842       info_text = element_info[element].custom_description;
1843     else if (element_info[element].editor_description != NULL)
1844       info_text = element_info[element].editor_description;
1845   }
1846
1847   if (info_text == NULL)
1848   {
1849     info_text = "unknown";
1850
1851     Error(ERR_WARN, "no element description for element %d", element);
1852   }
1853
1854   return info_text;
1855 }
1856
1857 static void ScrollMiniLevel(int from_x, int from_y, int scroll)
1858 {
1859   int x,y;
1860   int dx = (scroll == ED_SCROLL_LEFT ? -1 : scroll == ED_SCROLL_RIGHT ? 1 : 0);
1861   int dy = (scroll == ED_SCROLL_UP   ? -1 : scroll == ED_SCROLL_DOWN  ? 1 : 0);
1862
1863   BlitBitmap(drawto, drawto,
1864              SX + (dx == -1 ? MINI_TILEX : 0),
1865              SY + (dy == -1 ? MINI_TILEY : 0),
1866              (ed_fieldx * MINI_TILEX) - (dx != 0 ? MINI_TILEX : 0),
1867              (ed_fieldy * MINI_TILEY) - (dy != 0 ? MINI_TILEY : 0),
1868              SX + (dx == +1 ? MINI_TILEX : 0),
1869              SY + (dy == +1 ? MINI_TILEY : 0));
1870   if (dx)
1871   {
1872     x = (dx == 1 ? 0 : ed_fieldx - 1);
1873     for(y=0; y<ed_fieldy; y++)
1874       DrawMiniElementOrWall(x, y, from_x, from_y);
1875   }
1876   else if (dy)
1877   {
1878     y = (dy == 1 ? 0 : ed_fieldy - 1);
1879     for(x=0; x<ed_fieldx; x++)
1880       DrawMiniElementOrWall(x, y, from_x, from_y);
1881   }
1882
1883   redraw_mask |= REDRAW_FIELD;
1884   BackToFront();
1885 }
1886
1887 static void CreateControlButtons()
1888 {
1889   Bitmap *gd_bitmap = graphic_info[IMG_GLOBAL_DOOR].bitmap;
1890   struct GadgetInfo *gi;
1891   unsigned long event_mask;
1892   int i;
1893
1894   /* create toolbox buttons */
1895   for (i=0; i<ED_NUM_CTRL_BUTTONS; i++)
1896   {
1897     int id = i;
1898     int width, height;
1899     int gd_xoffset, gd_yoffset;
1900     int gd_x1, gd_x2, gd_y1, gd_y2;
1901     int button_type;
1902     int radio_button_nr;
1903     boolean checked;
1904
1905     if (id == GADGET_ID_SINGLE_ITEMS ||
1906         id == GADGET_ID_CONNECTED_ITEMS ||
1907         id == GADGET_ID_LINE ||
1908         id == GADGET_ID_ARC ||
1909         id == GADGET_ID_TEXT ||
1910         id == GADGET_ID_RECTANGLE ||
1911         id == GADGET_ID_FILLED_BOX ||
1912         id == GADGET_ID_FLOOD_FILL ||
1913         id == GADGET_ID_GRAB_BRUSH ||
1914         id == GADGET_ID_PICK_ELEMENT)
1915     {
1916       button_type = GD_TYPE_RADIO_BUTTON;
1917       radio_button_nr = RADIO_NR_DRAWING_TOOLBOX;
1918       checked = (id == drawing_function ? TRUE : FALSE);
1919       event_mask = GD_EVENT_PRESSED;
1920     }
1921     else
1922     {
1923       button_type = GD_TYPE_NORMAL_BUTTON;
1924       radio_button_nr = RADIO_NR_NONE;
1925       checked = FALSE;
1926
1927       if (id == GADGET_ID_WRAP_LEFT ||
1928           id == GADGET_ID_WRAP_RIGHT ||
1929           id == GADGET_ID_WRAP_UP ||
1930           id == GADGET_ID_WRAP_DOWN)
1931         event_mask = GD_EVENT_PRESSED | GD_EVENT_REPEATED;
1932       else
1933         event_mask = GD_EVENT_RELEASED;
1934     }
1935
1936     if (id < ED_NUM_CTRL1_BUTTONS)
1937     {
1938       int x = i % ED_CTRL1_BUTTONS_HORIZ;
1939       int y = i / ED_CTRL1_BUTTONS_HORIZ;
1940
1941       gd_xoffset = ED_CTRL1_BUTTONS_XPOS + x * ED_CTRL1_BUTTON_XSIZE;
1942       gd_yoffset = ED_CTRL1_BUTTONS_YPOS + y * ED_CTRL1_BUTTON_YSIZE;
1943       width = ED_CTRL1_BUTTON_XSIZE;
1944       height = ED_CTRL1_BUTTON_YSIZE;
1945     }
1946     else
1947     {
1948       int x = (i - ED_NUM_CTRL1_BUTTONS) % ED_CTRL2_BUTTONS_HORIZ;
1949       int y = (i - ED_NUM_CTRL1_BUTTONS) / ED_CTRL2_BUTTONS_HORIZ;
1950
1951       gd_xoffset = ED_CTRL2_BUTTONS_XPOS + x * ED_CTRL2_BUTTON_XSIZE;
1952       gd_yoffset = ED_CTRL2_BUTTONS_YPOS + y * ED_CTRL2_BUTTON_YSIZE;
1953       width = ED_CTRL2_BUTTON_XSIZE;
1954       height = ED_CTRL2_BUTTON_YSIZE;
1955     }
1956
1957     gd_x1 = DOOR_GFX_PAGEX8 + gd_xoffset;
1958     gd_x2 = DOOR_GFX_PAGEX7 + gd_xoffset;
1959     gd_y1  = DOOR_GFX_PAGEY1 + ED_CTRL_BUTTONS_GFX_YPOS + gd_yoffset;
1960     gd_y2  = DOOR_GFX_PAGEY1 + ED_CTRL_BUTTONS_ALT_GFX_YPOS + gd_yoffset;
1961
1962     gi = CreateGadget(GDI_CUSTOM_ID, id,
1963                       GDI_CUSTOM_TYPE_ID, i,
1964                       GDI_INFO_TEXT, control_info[i].text,
1965                       GDI_X, EX + gd_xoffset,
1966                       GDI_Y, EY + gd_yoffset,
1967                       GDI_WIDTH, width,
1968                       GDI_HEIGHT, height,
1969                       GDI_TYPE, button_type,
1970                       GDI_STATE, GD_BUTTON_UNPRESSED,
1971                       GDI_RADIO_NR, radio_button_nr,
1972                       GDI_CHECKED, checked,
1973                       GDI_DESIGN_UNPRESSED, gd_bitmap, gd_x1, gd_y1,
1974                       GDI_DESIGN_PRESSED, gd_bitmap, gd_x2, gd_y1,
1975                       GDI_ALT_DESIGN_UNPRESSED, gd_bitmap, gd_x1, gd_y2,
1976                       GDI_ALT_DESIGN_PRESSED, gd_bitmap, gd_x2, gd_y2,
1977                       GDI_EVENT_MASK, event_mask,
1978                       GDI_CALLBACK_INFO, HandleEditorGadgetInfoText,
1979                       GDI_CALLBACK_ACTION, HandleControlButtons,
1980                       GDI_END);
1981
1982     if (gi == NULL)
1983       Error(ERR_EXIT, "cannot create gadget");
1984
1985     level_editor_gadget[id] = gi;
1986   }
1987
1988   /* create buttons for scrolling of drawing area and element list */
1989   for (i=0; i<ED_NUM_SCROLLBUTTONS; i++)
1990   {
1991     int id = scrollbutton_info[i].gadget_id;
1992     int x, y, width, height;
1993     int gd_x1, gd_x2, gd_y1, gd_y2;
1994
1995     x = scrollbutton_info[i].x;
1996     y = scrollbutton_info[i].y;
1997
1998     event_mask = GD_EVENT_PRESSED | GD_EVENT_REPEATED;
1999
2000     if (id == GADGET_ID_SCROLL_LIST_UP ||
2001         id == GADGET_ID_SCROLL_LIST_DOWN)
2002     {
2003       x += DX;
2004       y += DY;
2005       width = ED_SCROLLBUTTON2_XSIZE;
2006       height = ED_SCROLLBUTTON2_YSIZE;
2007       gd_x1 = DOOR_GFX_PAGEX8 + scrollbutton_info[i].xpos;
2008       gd_y1 = DOOR_GFX_PAGEY1 + scrollbutton_info[i].ypos;
2009       gd_x2 = gd_x1 - ED_SCROLLBUTTON2_XSIZE;
2010       gd_y2 = gd_y1;
2011     }
2012     else
2013     {
2014       x += SX;
2015       y += SY;
2016       width = ED_SCROLLBUTTON_XSIZE;
2017       height = ED_SCROLLBUTTON_YSIZE;
2018       gd_x1 = DOOR_GFX_PAGEX8 + scrollbutton_info[i].xpos;
2019       gd_y1 = DOOR_GFX_PAGEY1 + scrollbutton_info[i].ypos;
2020       gd_x2 = gd_x1 - ED_SCROLLBUTTON_XSIZE;
2021       gd_y2 = gd_y1;
2022     }
2023
2024     gi = CreateGadget(GDI_CUSTOM_ID, id,
2025                       GDI_CUSTOM_TYPE_ID, i,
2026                       GDI_INFO_TEXT, scrollbutton_info[i].infotext,
2027                       GDI_X, x,
2028                       GDI_Y, y,
2029                       GDI_WIDTH, width,
2030                       GDI_HEIGHT, height,
2031                       GDI_TYPE, GD_TYPE_NORMAL_BUTTON,
2032                       GDI_STATE, GD_BUTTON_UNPRESSED,
2033                       GDI_DESIGN_UNPRESSED, gd_bitmap, gd_x1, gd_y1,
2034                       GDI_DESIGN_PRESSED, gd_bitmap, gd_x2, gd_y2,
2035                       GDI_EVENT_MASK, event_mask,
2036                       GDI_CALLBACK_INFO, HandleEditorGadgetInfoText,
2037                       GDI_CALLBACK_ACTION, HandleControlButtons,
2038                       GDI_END);
2039
2040     if (gi == NULL)
2041       Error(ERR_EXIT, "cannot create gadget");
2042
2043     level_editor_gadget[id] = gi;
2044   }
2045
2046   /* create buttons for element list */
2047   for (i=0; i<ED_NUM_ELEMENTLIST_BUTTONS; i++)
2048   {
2049     Bitmap *deco_bitmap;
2050     int deco_x, deco_y, deco_xpos, deco_ypos;
2051     int gd_xoffset, gd_yoffset;
2052     int gd_x1, gd_x2, gd_y;
2053     int x = i % ED_ELEMENTLIST_BUTTONS_HORIZ;
2054     int y = i / ED_ELEMENTLIST_BUTTONS_HORIZ;
2055     int id = GADGET_ID_ELEMENTLIST_FIRST + i;
2056     int element = editor_elements[i];
2057
2058     event_mask = GD_EVENT_RELEASED;
2059
2060     gd_xoffset = ED_ELEMENTLIST_XPOS + x * ED_ELEMENTLIST_XSIZE;
2061     gd_yoffset = ED_ELEMENTLIST_YPOS + y * ED_ELEMENTLIST_YSIZE;
2062
2063     gd_x1 = DOOR_GFX_PAGEX6 + ED_ELEMENTLIST_XPOS + ED_ELEMENTLIST_XSIZE;
2064     gd_x2 = DOOR_GFX_PAGEX6 + ED_ELEMENTLIST_XPOS;
2065     gd_y  = DOOR_GFX_PAGEY1 + ED_ELEMENTLIST_YPOS;
2066
2067     getMiniGraphicSource(el2edimg(element), &deco_bitmap, &deco_x, &deco_y);
2068     deco_xpos = (ED_ELEMENTLIST_XSIZE - MINI_TILEX) / 2;
2069     deco_ypos = (ED_ELEMENTLIST_YSIZE - MINI_TILEY) / 2;
2070
2071     gi = CreateGadget(GDI_CUSTOM_ID, id,
2072                       GDI_CUSTOM_TYPE_ID, i,
2073                       GDI_INFO_TEXT, getElementInfoText(element),
2074                       GDI_X, DX + gd_xoffset,
2075                       GDI_Y, DY + gd_yoffset,
2076                       GDI_WIDTH, ED_ELEMENTLIST_XSIZE,
2077                       GDI_HEIGHT, ED_ELEMENTLIST_YSIZE,
2078                       GDI_TYPE, GD_TYPE_NORMAL_BUTTON,
2079                       GDI_STATE, GD_BUTTON_UNPRESSED,
2080                       GDI_DESIGN_UNPRESSED, gd_bitmap, gd_x1, gd_y,
2081                       GDI_DESIGN_PRESSED, gd_bitmap, gd_x2, gd_y,
2082                       GDI_DECORATION_DESIGN, deco_bitmap, deco_x, deco_y,
2083                       GDI_DECORATION_POSITION, deco_xpos, deco_ypos,
2084                       GDI_DECORATION_SIZE, MINI_TILEX, MINI_TILEY,
2085                       GDI_DECORATION_SHIFTING, 1, 1,
2086                       GDI_EVENT_MASK, event_mask,
2087                       GDI_CALLBACK_INFO, HandleEditorGadgetInfoText,
2088                       GDI_CALLBACK_ACTION, HandleControlButtons,
2089                       GDI_END);
2090
2091     if (gi == NULL)
2092       Error(ERR_EXIT, "cannot create gadget");
2093
2094     level_editor_gadget[id] = gi;
2095   }
2096 }
2097
2098 static void CreateCounterButtons()
2099 {
2100   int max_infotext_len = getMaxInfoTextLength();
2101   int i;
2102
2103   for (i=0; i<ED_NUM_COUNTERBUTTONS; i++)
2104   {
2105     int j;
2106     int xpos = SX + counterbutton_info[i].x;    /* xpos of down count button */
2107     int ypos = SY + counterbutton_info[i].y;
2108
2109     for (j=0; j<2; j++)
2110     {
2111       Bitmap *gd_bitmap = graphic_info[IMG_GLOBAL_DOOR].bitmap;
2112       struct GadgetInfo *gi;
2113       int id = (j == 0 ?
2114                 counterbutton_info[i].gadget_id_down :
2115                 counterbutton_info[i].gadget_id_up);
2116       int gd_xoffset;
2117       int gd_x, gd_x1, gd_x2, gd_y;
2118       int x_size, y_size;
2119       unsigned long event_mask;
2120       char infotext[max_infotext_len + 1];
2121
2122       event_mask = GD_EVENT_PRESSED | GD_EVENT_REPEATED;
2123
2124       if (i == ED_COUNTER_ID_SELECT_LEVEL)
2125       {
2126         int sid = (j == 0 ?
2127                    ED_SCROLLBUTTON_ID_AREA_LEFT :
2128                    ED_SCROLLBUTTON_ID_AREA_RIGHT);
2129
2130         event_mask |= GD_EVENT_RELEASED;
2131
2132         if (j == 1)
2133           xpos += 2 * ED_GADGET_DISTANCE;
2134         ypos += ED_GADGET_DISTANCE;
2135
2136         gd_x1 = DOOR_GFX_PAGEX8 + scrollbutton_info[sid].xpos;
2137         gd_x2 = gd_x1 - ED_SCROLLBUTTON_XSIZE;
2138         gd_y  = DOOR_GFX_PAGEY1 + scrollbutton_info[sid].ypos;
2139         x_size = ED_SCROLLBUTTON_XSIZE;
2140         y_size = ED_SCROLLBUTTON_YSIZE;
2141       }
2142       else
2143       {
2144         gd_xoffset = (j == 0 ? ED_BUTTON_MINUS_XPOS : ED_BUTTON_PLUS_XPOS);
2145         gd_x1 = DOOR_GFX_PAGEX4 + gd_xoffset;
2146         gd_x2 = DOOR_GFX_PAGEX3 + gd_xoffset;
2147         gd_y  = DOOR_GFX_PAGEY1 + ED_BUTTON_COUNT_YPOS;
2148         x_size = ED_BUTTON_COUNT_XSIZE;
2149         y_size = ED_BUTTON_COUNT_YSIZE;
2150       }
2151
2152       sprintf(infotext, "%s counter value by 1, 5 or 10",
2153               (j == 0 ? "decrease" : "increase"));
2154
2155       gi = CreateGadget(GDI_CUSTOM_ID, id,
2156                         GDI_CUSTOM_TYPE_ID, i,
2157                         GDI_INFO_TEXT, infotext,
2158                         GDI_X, xpos,
2159                         GDI_Y, ypos,
2160                         GDI_WIDTH, x_size,
2161                         GDI_HEIGHT, y_size,
2162                         GDI_TYPE, GD_TYPE_NORMAL_BUTTON,
2163                         GDI_STATE, GD_BUTTON_UNPRESSED,
2164                         GDI_DESIGN_UNPRESSED, gd_bitmap, gd_x1, gd_y,
2165                         GDI_DESIGN_PRESSED, gd_bitmap, gd_x2, gd_y,
2166                         GDI_EVENT_MASK, event_mask,
2167                         GDI_CALLBACK_INFO, HandleEditorGadgetInfoText,
2168                         GDI_CALLBACK_ACTION, HandleCounterButtons,
2169                         GDI_END);
2170
2171       if (gi == NULL)
2172         Error(ERR_EXIT, "cannot create gadget");
2173
2174       level_editor_gadget[id] = gi;
2175       xpos += gi->width + ED_GADGET_DISTANCE;   /* xpos of text count button */
2176
2177       if (j == 0)
2178       {
2179         int font_type = FONT_INPUT_1;
2180         int font_type_active = FONT_INPUT_1_ACTIVE;
2181         int gd_width = ED_WIN_COUNT_XSIZE;
2182
2183         id = counterbutton_info[i].gadget_id_text;
2184         event_mask = GD_EVENT_TEXT_RETURN | GD_EVENT_TEXT_LEAVING;
2185
2186         if (i == ED_COUNTER_ID_SELECT_LEVEL)
2187         {
2188           font_type = FONT_LEVEL_NUMBER;
2189           font_type_active = FONT_LEVEL_NUMBER;
2190
2191           xpos += 2 * ED_GADGET_DISTANCE;
2192           ypos -= ED_GADGET_DISTANCE;
2193
2194           gd_x = DOOR_GFX_PAGEX6 + ED_WIN_COUNT2_XPOS;
2195           gd_y = DOOR_GFX_PAGEY1 + ED_WIN_COUNT2_YPOS;
2196           gd_width = ED_WIN_COUNT2_XSIZE;
2197         }
2198         else
2199         {
2200           gd_x = DOOR_GFX_PAGEX4 + ED_WIN_COUNT_XPOS;
2201           gd_y = DOOR_GFX_PAGEY1 + ED_WIN_COUNT_YPOS;
2202         }
2203
2204         gi = CreateGadget(GDI_CUSTOM_ID, id,
2205                           GDI_CUSTOM_TYPE_ID, i,
2206                           GDI_INFO_TEXT, "enter counter value",
2207                           GDI_X, xpos,
2208                           GDI_Y, ypos,
2209                           GDI_TYPE, GD_TYPE_TEXTINPUT_NUMERIC,
2210                           GDI_NUMBER_VALUE, 0,
2211                           GDI_NUMBER_MIN, counterbutton_info[i].min_value,
2212                           GDI_NUMBER_MAX, counterbutton_info[i].max_value,
2213                           GDI_TEXT_SIZE, 3,
2214                           GDI_TEXT_FONT, font_type,
2215                           GDI_TEXT_FONT_ACTIVE, font_type_active,
2216                           GDI_DESIGN_UNPRESSED, gd_bitmap, gd_x, gd_y,
2217                           GDI_DESIGN_PRESSED, gd_bitmap, gd_x, gd_y,
2218                           GDI_BORDER_SIZE, ED_BORDER_SIZE, ED_BORDER_SIZE,
2219                           GDI_DESIGN_WIDTH, gd_width,
2220                           GDI_EVENT_MASK, event_mask,
2221                           GDI_CALLBACK_INFO, HandleEditorGadgetInfoText,
2222                           GDI_CALLBACK_ACTION, HandleCounterButtons,
2223                           GDI_END);
2224
2225         if (gi == NULL)
2226           Error(ERR_EXIT, "cannot create gadget");
2227
2228         level_editor_gadget[id] = gi;
2229         xpos += gi->width + ED_GADGET_DISTANCE; /* xpos of up count button */
2230       }
2231     }
2232   }
2233 }
2234
2235 static void CreateDrawingAreas()
2236 {
2237   struct GadgetInfo *gi;
2238   unsigned long event_mask;
2239   int id;
2240   int i;
2241
2242   event_mask =
2243     GD_EVENT_PRESSED | GD_EVENT_RELEASED | GD_EVENT_MOVING |
2244     GD_EVENT_OFF_BORDERS;
2245
2246   /* one for the level drawing area ... */
2247   id = GADGET_ID_DRAWING_LEVEL;
2248   gi = CreateGadget(GDI_CUSTOM_ID, id,
2249                     GDI_X, SX,
2250                     GDI_Y, SY,
2251                     GDI_TYPE, GD_TYPE_DRAWING_AREA,
2252                     GDI_AREA_SIZE, ed_fieldx, ed_fieldy,
2253                     GDI_ITEM_SIZE, MINI_TILEX, MINI_TILEY,
2254                     GDI_EVENT_MASK, event_mask,
2255                     GDI_CALLBACK_INFO, HandleDrawingAreaInfo,
2256                     GDI_CALLBACK_ACTION, HandleDrawingAreas,
2257                     GDI_END);
2258
2259   if (gi == NULL)
2260     Error(ERR_EXIT, "cannot create gadget");
2261
2262   level_editor_gadget[id] = gi;
2263
2264   /* ... up to eight areas for element content ... */
2265   for (i=0; i<MAX_ELEMENT_CONTENTS; i++)
2266   {
2267     int gx = SX + ED_AREA_ELEM_CONTENT_XPOS + 5 * (i % 4) * MINI_TILEX;
2268     int gy = SX + ED_AREA_ELEM_CONTENT_YPOS + 6 * (i / 4) * MINI_TILEY;
2269
2270     id = GADGET_ID_ELEM_CONTENT_0 + i;
2271     gi = CreateGadget(GDI_CUSTOM_ID, id,
2272                       GDI_CUSTOM_TYPE_ID, i,
2273                       GDI_X, gx,
2274                       GDI_Y, gy,
2275                       GDI_WIDTH, 3 * MINI_TILEX,
2276                       GDI_HEIGHT, 3 * MINI_TILEY,
2277                       GDI_TYPE, GD_TYPE_DRAWING_AREA,
2278                       GDI_ITEM_SIZE, MINI_TILEX, MINI_TILEY,
2279                       GDI_EVENT_MASK, event_mask,
2280                       GDI_CALLBACK_INFO, HandleDrawingAreaInfo,
2281                       GDI_CALLBACK_ACTION, HandleDrawingAreas,
2282                       GDI_END);
2283
2284     if (gi == NULL)
2285       Error(ERR_EXIT, "cannot create gadget");
2286
2287     level_editor_gadget[id] = gi;
2288   }
2289
2290   /* ... one for the amoeba content ... */
2291   id = GADGET_ID_AMOEBA_CONTENT;
2292   gi = CreateGadget(GDI_CUSTOM_ID, id,
2293                     GDI_X, SX + ED_AREA_ELEM_CONTENT_XPOS,
2294                     GDI_Y, SY + ED_AREA_ELEM_CONTENT_YPOS,
2295                     GDI_WIDTH, MINI_TILEX,
2296                     GDI_HEIGHT, MINI_TILEY,
2297                     GDI_TYPE, GD_TYPE_DRAWING_AREA,
2298                     GDI_ITEM_SIZE, MINI_TILEX, MINI_TILEY,
2299                     GDI_EVENT_MASK, event_mask,
2300                     GDI_CALLBACK_INFO, HandleDrawingAreaInfo,
2301                     GDI_CALLBACK_ACTION, HandleDrawingAreas,
2302                     GDI_END);
2303
2304   if (gi == NULL)
2305     Error(ERR_EXIT, "cannot create gadget");
2306
2307   level_editor_gadget[id] = gi;
2308
2309   /* ... one for each custom element change target element ... */
2310   id = GADGET_ID_CUSTOM_CHANGED;
2311   gi = CreateGadget(GDI_CUSTOM_ID, id,
2312                     GDI_X, SX + ED_AREA_ELEM_CONTENT2_XPOS,
2313                     GDI_Y, SY + ED_AREA_ELEM_CONTENT2_YPOS,
2314                     GDI_WIDTH, MINI_TILEX,
2315                     GDI_HEIGHT, MINI_TILEY,
2316                     GDI_TYPE, GD_TYPE_DRAWING_AREA,
2317                     GDI_ITEM_SIZE, MINI_TILEX, MINI_TILEY,
2318                     GDI_EVENT_MASK, event_mask,
2319                     GDI_CALLBACK_INFO, HandleDrawingAreaInfo,
2320                     GDI_CALLBACK_ACTION, HandleDrawingAreas,
2321                     GDI_END);
2322
2323   if (gi == NULL)
2324     Error(ERR_EXIT, "cannot create gadget");
2325
2326   level_editor_gadget[id] = gi;
2327
2328   /* ... and one for random placement background restrictions */
2329
2330   id = GADGET_ID_RANDOM_BACKGROUND;
2331   gi = CreateGadget(GDI_CUSTOM_ID, id,
2332                     GDI_X, SX + ED_AREA_RANDOM_BACKGROUND_XPOS,
2333                     GDI_Y, SY + ED_AREA_RANDOM_BACKGROUND_YPOS,
2334                     GDI_WIDTH, MINI_TILEX,
2335                     GDI_HEIGHT, MINI_TILEY,
2336                     GDI_TYPE, GD_TYPE_DRAWING_AREA,
2337                     GDI_ITEM_SIZE, MINI_TILEX, MINI_TILEY,
2338                     GDI_EVENT_MASK, event_mask,
2339                     GDI_CALLBACK_INFO, HandleDrawingAreaInfo,
2340                     GDI_CALLBACK_ACTION, HandleDrawingAreas,
2341                     GDI_END);
2342
2343   if (gi == NULL)
2344     Error(ERR_EXIT, "cannot create gadget");
2345
2346   level_editor_gadget[id] = gi;
2347 }
2348
2349 static void CreateTextInputGadgets()
2350 {
2351   int max_infotext_len = getMaxInfoTextLength();
2352   int i;
2353
2354   for (i=0; i<ED_NUM_TEXTINPUT; i++)
2355   {
2356     Bitmap *gd_bitmap = graphic_info[IMG_GLOBAL_DOOR].bitmap;
2357     int gd_x, gd_y;
2358     struct GadgetInfo *gi;
2359     unsigned long event_mask;
2360     char infotext[MAX_OUTPUT_LINESIZE + 1];
2361     int id = textinput_info[i].gadget_id;
2362
2363     event_mask = GD_EVENT_TEXT_RETURN | GD_EVENT_TEXT_LEAVING;
2364
2365     gd_x = DOOR_GFX_PAGEX4 + ED_WIN_COUNT_XPOS;
2366     gd_y = DOOR_GFX_PAGEY1 + ED_WIN_COUNT_YPOS;
2367
2368     sprintf(infotext, "Enter %s", textinput_info[i].infotext);
2369     infotext[max_infotext_len] = '\0';
2370
2371     gi = CreateGadget(GDI_CUSTOM_ID, id,
2372                       GDI_CUSTOM_TYPE_ID, i,
2373                       GDI_INFO_TEXT, infotext,
2374                       GDI_X, SX + textinput_info[i].x,
2375                       GDI_Y, SY + textinput_info[i].y,
2376                       GDI_TYPE, GD_TYPE_TEXTINPUT_ALPHANUMERIC,
2377                       GDI_TEXT_VALUE, textinput_info[i].value,
2378                       GDI_TEXT_SIZE, textinput_info[i].size,
2379                       GDI_TEXT_FONT, FONT_INPUT_1,
2380                       GDI_TEXT_FONT_ACTIVE, FONT_INPUT_1_ACTIVE,
2381                       GDI_DESIGN_UNPRESSED, gd_bitmap, gd_x, gd_y,
2382                       GDI_DESIGN_PRESSED, gd_bitmap, gd_x, gd_y,
2383                       GDI_BORDER_SIZE, ED_BORDER_SIZE, ED_BORDER_SIZE,
2384                       GDI_DESIGN_WIDTH, ED_WIN_COUNT_XSIZE,
2385                       GDI_EVENT_MASK, event_mask,
2386                       GDI_CALLBACK_INFO, HandleEditorGadgetInfoText,
2387                       GDI_CALLBACK_ACTION, HandleTextInputGadgets,
2388                       GDI_END);
2389
2390     if (gi == NULL)
2391       Error(ERR_EXIT, "cannot create gadget");
2392
2393     level_editor_gadget[id] = gi;
2394   }
2395 }
2396
2397 static void CreateSelectboxGadgets()
2398 {
2399   int max_infotext_len = getMaxInfoTextLength();
2400   int i;
2401
2402   for (i=0; i<ED_NUM_SELECTBOX; i++)
2403   {
2404     Bitmap *gd_bitmap = graphic_info[IMG_GLOBAL_DOOR].bitmap;
2405     int gd_x, gd_y;
2406     struct GadgetInfo *gi;
2407     unsigned long event_mask;
2408     char infotext[MAX_OUTPUT_LINESIZE + 1];
2409     int id = selectbox_info[i].gadget_id;
2410
2411     event_mask = GD_EVENT_RELEASED |
2412       GD_EVENT_TEXT_RETURN | GD_EVENT_TEXT_LEAVING;
2413
2414     gd_x = DOOR_GFX_PAGEX4 + ED_SELECTBOX_XPOS;
2415     gd_y = DOOR_GFX_PAGEY1 + ED_SELECTBOX_YPOS;
2416
2417     sprintf(infotext, "Select %s", selectbox_info[i].infotext);
2418     infotext[max_infotext_len] = '\0';
2419
2420     gi = CreateGadget(GDI_CUSTOM_ID, id,
2421                       GDI_CUSTOM_TYPE_ID, i,
2422                       GDI_INFO_TEXT, infotext,
2423                       GDI_X, SX + selectbox_info[i].x,
2424                       GDI_Y, SY + selectbox_info[i].y,
2425                       GDI_TYPE, GD_TYPE_SELECTBOX,
2426                       GDI_SELECTBOX_OPTIONS, selectbox_info[i].options,
2427                       GDI_SELECTBOX_INDEX, selectbox_info[i].index,
2428                       GDI_TEXT_SIZE, selectbox_info[i].size,
2429                       GDI_TEXT_FONT, FONT_INPUT_1,
2430                       GDI_TEXT_FONT_ACTIVE, FONT_INPUT_1_ACTIVE,
2431                       GDI_DESIGN_UNPRESSED, gd_bitmap, gd_x, gd_y,
2432                       GDI_DESIGN_PRESSED, gd_bitmap, gd_x, gd_y,
2433                       GDI_BORDER_SIZE, ED_BORDER_SIZE, ED_BORDER_SIZE,
2434                       GDI_BORDER_SIZE_SELECTBUTTON, getFontWidth(FONT_INPUT_1),
2435                       GDI_DESIGN_WIDTH, ED_WIN_COUNT_XSIZE,
2436                       GDI_EVENT_MASK, event_mask,
2437                       GDI_CALLBACK_INFO, HandleEditorGadgetInfoText,
2438                       GDI_CALLBACK_ACTION, HandleSelectboxGadgets,
2439                       GDI_END);
2440
2441     if (gi == NULL)
2442       Error(ERR_EXIT, "cannot create gadget");
2443
2444     level_editor_gadget[id] = gi;
2445   }
2446 }
2447
2448 static void CreateTextbuttonGadgets()
2449 {
2450   int max_infotext_len = getMaxInfoTextLength();
2451   int i;
2452
2453   for (i=0; i<ED_NUM_TEXTBUTTON; i++)
2454   {
2455     Bitmap *gd_bitmap = graphic_info[IMG_GLOBAL_DOOR].bitmap;
2456     int gd_x1, gd_x2, gd_y1, gd_y2;
2457     struct GadgetInfo *gi;
2458     unsigned long event_mask;
2459     char infotext[MAX_OUTPUT_LINESIZE + 1];
2460     int id = textbutton_info[i].gadget_id;
2461
2462     event_mask = GD_EVENT_RELEASED;
2463
2464     gd_x1 = DOOR_GFX_PAGEX4 + ED_TEXTBUTTON_XPOS;
2465     gd_x2 = DOOR_GFX_PAGEX3 + ED_TEXTBUTTON_XPOS;
2466     gd_y1 = DOOR_GFX_PAGEY1 + ED_TEXTBUTTON_YPOS;
2467     gd_y2 = DOOR_GFX_PAGEY1 + ED_TEXTBUTTON_INACTIVE_YPOS;
2468
2469     sprintf(infotext, "%s", textbutton_info[i].infotext);
2470     infotext[max_infotext_len] = '\0';
2471
2472     gi = CreateGadget(GDI_CUSTOM_ID, id,
2473                       GDI_CUSTOM_TYPE_ID, i,
2474                       GDI_INFO_TEXT, infotext,
2475                       GDI_X, SX + textbutton_info[i].x,
2476                       GDI_Y, SY + textbutton_info[i].y,
2477                       GDI_TYPE, GD_TYPE_TEXT_BUTTON,
2478                       GDI_TEXT_VALUE, textbutton_info[i].value,
2479                       GDI_TEXT_SIZE, textbutton_info[i].size,
2480                       GDI_TEXT_FONT, FONT_INPUT_2_ACTIVE,
2481                       GDI_TEXT_FONT_ACTIVE, FONT_INPUT_2,
2482                       GDI_DESIGN_UNPRESSED, gd_bitmap, gd_x1, gd_y1,
2483                       GDI_DESIGN_PRESSED, gd_bitmap, gd_x2, gd_y1,
2484                       GDI_ALT_DESIGN_UNPRESSED, gd_bitmap, gd_x1, gd_y2,
2485                       GDI_BORDER_SIZE, ED_BORDER2_SIZE, ED_BORDER_SIZE,
2486                       GDI_DESIGN_WIDTH, ED_WIN_COUNT_XSIZE,
2487                       GDI_DECORATION_SHIFTING, 1, 1,
2488                       GDI_EVENT_MASK, event_mask,
2489                       GDI_CALLBACK_INFO, HandleEditorGadgetInfoText,
2490                       GDI_CALLBACK_ACTION, HandleTextbuttonGadgets,
2491                       GDI_END);
2492
2493     if (gi == NULL)
2494       Error(ERR_EXIT, "cannot create gadget");
2495
2496     level_editor_gadget[id] = gi;
2497   }
2498 }
2499
2500 static void CreateScrollbarGadgets()
2501 {
2502   int i;
2503
2504   for (i=0; i<ED_NUM_SCROLLBARS; i++)
2505   {
2506     int id = scrollbar_info[i].gadget_id;
2507     Bitmap *gd_bitmap = graphic_info[IMG_GLOBAL_DOOR].bitmap;
2508     int gd_x1, gd_x2, gd_y1, gd_y2;
2509     struct GadgetInfo *gi;
2510     int items_max, items_visible, item_position;
2511     unsigned long event_mask;
2512
2513     if (i == ED_SCROLLBAR_ID_LIST_VERTICAL)
2514     {
2515       items_max = num_editor_elements / ED_ELEMENTLIST_BUTTONS_HORIZ;
2516       items_visible = ED_ELEMENTLIST_BUTTONS_VERT;
2517       item_position = 0;
2518     }
2519     else        /* drawing area scrollbars */
2520     {
2521       if (scrollbar_info[i].type == GD_TYPE_SCROLLBAR_HORIZONTAL)
2522       {
2523         items_max = MAX(lev_fieldx + 2, ed_fieldx);
2524         items_visible = ed_fieldx;
2525         item_position = 0;
2526       }
2527       else
2528       {
2529         items_max = MAX(lev_fieldy + 2, ed_fieldy);
2530         items_visible = ed_fieldy;
2531         item_position = 0;
2532       }
2533     }
2534
2535     event_mask = GD_EVENT_MOVING | GD_EVENT_OFF_BORDERS;
2536
2537     gd_x1 = DOOR_GFX_PAGEX8 + scrollbar_info[i].xpos;
2538     gd_x2 = (gd_x1 - (scrollbar_info[i].type == GD_TYPE_SCROLLBAR_HORIZONTAL ?
2539                       scrollbar_info[i].height : scrollbar_info[i].width));
2540     gd_y1 = DOOR_GFX_PAGEY1 + scrollbar_info[i].ypos;
2541     gd_y2 = DOOR_GFX_PAGEY1 + scrollbar_info[i].ypos;
2542
2543     gi = CreateGadget(GDI_CUSTOM_ID, id,
2544                       GDI_CUSTOM_TYPE_ID, i,
2545                       GDI_INFO_TEXT, scrollbar_info[i].infotext,
2546                       GDI_X, scrollbar_info[i].x,
2547                       GDI_Y, scrollbar_info[i].y,
2548                       GDI_WIDTH, scrollbar_info[i].width,
2549                       GDI_HEIGHT, scrollbar_info[i].height,
2550                       GDI_TYPE, scrollbar_info[i].type,
2551                       GDI_SCROLLBAR_ITEMS_MAX, items_max,
2552                       GDI_SCROLLBAR_ITEMS_VISIBLE, items_visible,
2553                       GDI_SCROLLBAR_ITEM_POSITION, item_position,
2554                       GDI_STATE, GD_BUTTON_UNPRESSED,
2555                       GDI_DESIGN_UNPRESSED, gd_bitmap, gd_x1, gd_y1,
2556                       GDI_DESIGN_PRESSED, gd_bitmap, gd_x2, gd_y2,
2557                       GDI_BORDER_SIZE, ED_BORDER_SIZE, ED_BORDER_SIZE,
2558                       GDI_EVENT_MASK, event_mask,
2559                       GDI_CALLBACK_INFO, HandleEditorGadgetInfoText,
2560                       GDI_CALLBACK_ACTION, HandleControlButtons,
2561                       GDI_END);
2562
2563     if (gi == NULL)
2564       Error(ERR_EXIT, "cannot create gadget");
2565
2566     level_editor_gadget[id] = gi;
2567   }
2568 }
2569
2570 static void CreateCheckbuttonGadgets()
2571 {
2572   Bitmap *gd_bitmap = graphic_info[IMG_GLOBAL_DOOR].bitmap;
2573   struct GadgetInfo *gi;
2574   unsigned long event_mask;
2575   int gd_x1, gd_x2, gd_x3, gd_x4, gd_y;
2576   boolean checked;
2577   int i;
2578
2579   event_mask = GD_EVENT_PRESSED;
2580
2581   gd_x1 = DOOR_GFX_PAGEX4 + ED_CHECKBUTTON_UNCHECKED_XPOS;
2582   gd_x2 = DOOR_GFX_PAGEX3 + ED_CHECKBUTTON_UNCHECKED_XPOS;
2583   gd_x3 = DOOR_GFX_PAGEX4 + ED_CHECKBUTTON_CHECKED_XPOS;
2584   gd_x4 = DOOR_GFX_PAGEX3 + ED_CHECKBUTTON_CHECKED_XPOS;
2585   gd_y  = DOOR_GFX_PAGEY1 + ED_RADIOBUTTON_YPOS;
2586
2587   for (i=0; i<ED_NUM_RADIOBUTTONS; i++)
2588   {
2589     int id = radiobutton_info[i].gadget_id;
2590
2591     checked =
2592       (*radiobutton_info[i].value == radiobutton_info[i].checked_value);
2593
2594     gi = CreateGadget(GDI_CUSTOM_ID, id,
2595                       GDI_CUSTOM_TYPE_ID, i,
2596                       GDI_INFO_TEXT, radiobutton_info[i].infotext,
2597                       GDI_X, SX + radiobutton_info[i].x,
2598                       GDI_Y, SY + radiobutton_info[i].y,
2599                       GDI_WIDTH, ED_CHECKBUTTON_XSIZE,
2600                       GDI_HEIGHT, ED_CHECKBUTTON_YSIZE,
2601                       GDI_TYPE, GD_TYPE_RADIO_BUTTON,
2602                       GDI_RADIO_NR, radiobutton_info[i].radio_button_nr,
2603                       GDI_CHECKED, checked,
2604                       GDI_DESIGN_UNPRESSED, gd_bitmap, gd_x1, gd_y,
2605                       GDI_DESIGN_PRESSED, gd_bitmap, gd_x2, gd_y,
2606                       GDI_ALT_DESIGN_UNPRESSED, gd_bitmap, gd_x3, gd_y,
2607                       GDI_ALT_DESIGN_PRESSED, gd_bitmap, gd_x4, gd_y,
2608                       GDI_EVENT_MASK, event_mask,
2609                       GDI_CALLBACK_INFO, HandleEditorGadgetInfoText,
2610                       GDI_CALLBACK_ACTION, HandleRadiobuttons,
2611                       GDI_END);
2612
2613     if (gi == NULL)
2614       Error(ERR_EXIT, "cannot create gadget");
2615
2616     level_editor_gadget[id] = gi;
2617   }
2618
2619   for (i=0; i<ED_NUM_CHECKBUTTONS; i++)
2620   {
2621     int id = checkbutton_info[i].gadget_id;
2622
2623     if (id == GADGET_ID_STICK_ELEMENT)
2624       gd_y  = DOOR_GFX_PAGEY1 + ED_STICKYBUTTON_YPOS;
2625     else
2626       gd_y  = DOOR_GFX_PAGEY1 + ED_CHECKBUTTON_YPOS;
2627
2628     gi = CreateGadget(GDI_CUSTOM_ID, id,
2629                       GDI_CUSTOM_TYPE_ID, i,
2630                       GDI_INFO_TEXT, checkbutton_info[i].infotext,
2631                       GDI_X, SX + checkbutton_info[i].x,
2632                       GDI_Y, SY + checkbutton_info[i].y,
2633                       GDI_WIDTH, ED_CHECKBUTTON_XSIZE,
2634                       GDI_HEIGHT, ED_CHECKBUTTON_YSIZE,
2635                       GDI_TYPE, GD_TYPE_CHECK_BUTTON,
2636                       GDI_CHECKED, *checkbutton_info[i].value,
2637                       GDI_DESIGN_UNPRESSED, gd_bitmap, gd_x1, gd_y,
2638                       GDI_DESIGN_PRESSED, gd_bitmap, gd_x2, gd_y,
2639                       GDI_ALT_DESIGN_UNPRESSED, gd_bitmap, gd_x3, gd_y,
2640                       GDI_ALT_DESIGN_PRESSED, gd_bitmap, gd_x4, gd_y,
2641                       GDI_EVENT_MASK, event_mask,
2642                       GDI_CALLBACK_INFO, HandleEditorGadgetInfoText,
2643                       GDI_CALLBACK_ACTION, HandleCheckbuttons,
2644                       GDI_END);
2645
2646     if (gi == NULL)
2647       Error(ERR_EXIT, "cannot create gadget");
2648
2649     level_editor_gadget[id] = gi;
2650   }
2651 }
2652
2653 void CreateLevelEditorGadgets()
2654 {
2655   int old_game_status = game_status;
2656
2657   /* setting 'game_status' is needed to get the right fonts for the editor */
2658   game_status = GAME_MODE_EDITOR;
2659
2660   ReinitializeElementList();
2661
2662   CreateControlButtons();
2663   CreateCounterButtons();
2664   CreateDrawingAreas();
2665   CreateTextInputGadgets();
2666   CreateSelectboxGadgets();
2667   CreateTextbuttonGadgets();
2668   CreateScrollbarGadgets();
2669   CreateCheckbuttonGadgets();
2670
2671   game_status = old_game_status;
2672 }
2673
2674 void FreeLevelEditorGadgets()
2675 {
2676   int i;
2677
2678   for (i=0; i<NUM_EDITOR_GADGETS; i++)
2679     FreeGadget(level_editor_gadget[i]);
2680 }
2681
2682 static void MapCounterButtons(int id)
2683 {
2684   MapGadget(level_editor_gadget[counterbutton_info[id].gadget_id_down]);
2685   MapGadget(level_editor_gadget[counterbutton_info[id].gadget_id_text]);
2686   MapGadget(level_editor_gadget[counterbutton_info[id].gadget_id_up]);
2687 }
2688
2689 static void MapControlButtons()
2690 {
2691   int counter_id;
2692   int i;
2693
2694   /* map toolbox buttons */
2695   for (i=0; i<ED_NUM_CTRL_BUTTONS; i++)
2696     MapGadget(level_editor_gadget[i]);
2697
2698   /* map buttons to select elements */
2699   for (i=0; i<ED_NUM_ELEMENTLIST_BUTTONS; i++)
2700     MapGadget(level_editor_gadget[GADGET_ID_ELEMENTLIST_FIRST + i]);
2701   MapGadget(level_editor_gadget[GADGET_ID_SCROLL_LIST_VERTICAL]);
2702   MapGadget(level_editor_gadget[GADGET_ID_SCROLL_LIST_UP]);
2703   MapGadget(level_editor_gadget[GADGET_ID_SCROLL_LIST_DOWN]);
2704
2705   /* map buttons to select level */
2706   counter_id = ED_COUNTER_ID_SELECT_LEVEL;
2707   ModifyEditorCounterLimits(counter_id,
2708                             leveldir_current->first_level,
2709                             leveldir_current->last_level);
2710   ModifyEditorCounter(counter_id, *counterbutton_info[counter_id].value);
2711   MapCounterButtons(counter_id);
2712 }
2713
2714 static void MapDrawingArea(int id)
2715 {
2716   MapGadget(level_editor_gadget[id]);
2717 }
2718
2719 static void MapTextInputGadget(int id)
2720 {
2721   MapGadget(level_editor_gadget[textinput_info[id].gadget_id]);
2722 }
2723
2724 static void MapSelectboxGadget(int id)
2725 {
2726   MapGadget(level_editor_gadget[selectbox_info[id].gadget_id]);
2727 }
2728
2729 static void MapTextbuttonGadget(int id)
2730 {
2731   MapGadget(level_editor_gadget[textbutton_info[id].gadget_id]);
2732 }
2733
2734 static void MapRadiobuttonGadget(int id)
2735 {
2736   MapGadget(level_editor_gadget[radiobutton_info[id].gadget_id]);
2737 }
2738
2739 static void MapCheckbuttonGadget(int id)
2740 {
2741   MapGadget(level_editor_gadget[checkbutton_info[id].gadget_id]);
2742 }
2743
2744 static void MapMainDrawingArea()
2745 {
2746   boolean no_horizontal_scrollbar = (lev_fieldx + 2 <= ed_fieldx);
2747   boolean no_vertical_scrollbar = (lev_fieldy + 2 <= ed_fieldy);
2748   int i;
2749
2750   for (i=ED_SCROLLBUTTON_ID_AREA_FIRST; i<=ED_SCROLLBUTTON_ID_AREA_LAST; i++)
2751   {
2752     if (((i == ED_SCROLLBUTTON_ID_AREA_LEFT ||
2753           i == ED_SCROLLBUTTON_ID_AREA_RIGHT) &&
2754          no_horizontal_scrollbar) ||
2755         ((i == ED_SCROLLBUTTON_ID_AREA_UP ||
2756           i == ED_SCROLLBUTTON_ID_AREA_DOWN) &&
2757          no_vertical_scrollbar))
2758       continue;
2759
2760     MapGadget(level_editor_gadget[scrollbutton_info[i].gadget_id]);
2761   }
2762
2763   for (i=ED_SCROLLBAR_ID_AREA_FIRST; i<=ED_SCROLLBAR_ID_AREA_LAST; i++)
2764   {
2765     if ((i == ED_SCROLLBAR_ID_AREA_HORIZONTAL && no_horizontal_scrollbar) ||
2766         (i == ED_SCROLLBAR_ID_AREA_VERTICAL && no_vertical_scrollbar))
2767       continue;
2768
2769     MapGadget(level_editor_gadget[scrollbar_info[i].gadget_id]);
2770   }
2771
2772   MapDrawingArea(GADGET_ID_DRAWING_LEVEL);
2773 }
2774
2775 static void UnmapDrawingArea(int id)
2776 {
2777   UnmapGadget(level_editor_gadget[id]);
2778 }
2779
2780 void UnmapLevelEditorWindowGadgets()
2781 {
2782   int i;
2783
2784   for (i=0; i<NUM_EDITOR_GADGETS; i++)
2785     if (level_editor_gadget[i]->x < SX + SXSIZE)
2786       UnmapGadget(level_editor_gadget[i]);
2787 }
2788
2789 void UnmapLevelEditorGadgets()
2790 {
2791   int i;
2792
2793   for (i=0; i<NUM_EDITOR_GADGETS; i++)
2794     UnmapGadget(level_editor_gadget[i]);
2795 }
2796
2797 static void ResetUndoBuffer()
2798 {
2799   undo_buffer_position = -1;
2800   undo_buffer_steps = -1;
2801   CopyLevelToUndoBuffer(UNDO_IMMEDIATE);
2802 }
2803
2804 static void DrawEditModeWindow()
2805 {
2806   if (edit_mode == ED_MODE_INFO)
2807     DrawLevelInfoWindow();
2808   else if (edit_mode == ED_MODE_PROPERTIES)
2809     DrawPropertiesWindow();
2810   else  /* edit_mode == ED_MODE_DRAWING */
2811     DrawDrawingWindow();
2812 }
2813
2814 static boolean LevelChanged()
2815 {
2816   boolean level_changed = FALSE;
2817   int x, y;
2818
2819   for(y=0; y<lev_fieldy; y++)
2820     for(x=0; x<lev_fieldx; x++)
2821       if (Feld[x][y] != Ur[x][y])
2822         level_changed = TRUE;
2823
2824   return level_changed;
2825 }
2826
2827 static boolean LevelContainsPlayer()
2828 {
2829   boolean player_found = FALSE;
2830   int x, y;
2831
2832   for(y=0; y<lev_fieldy; y++)
2833     for(x=0; x<lev_fieldx; x++)
2834       if (Feld[x][y] == EL_PLAYER_1 ||
2835           Feld[x][y] == EL_SP_MURPHY)
2836         player_found = TRUE;
2837
2838   return player_found;
2839 }
2840
2841 static void CopyPlayfield(short src[MAX_LEV_FIELDX][MAX_LEV_FIELDY],
2842                           short dst[MAX_LEV_FIELDX][MAX_LEV_FIELDY])
2843 {
2844   int x, y;
2845
2846   for(x=0; x<lev_fieldx; x++)
2847     for(y=0; y<lev_fieldy; y++)
2848       dst[x][y] = src[x][y];
2849 }
2850
2851 static void CopyCustomElementPropertiesToEditor(int element)
2852 {
2853   int i;
2854
2855   for (i=0; i < NUM_ELEMENT_PROPERTIES; i++)
2856     custom_element_properties[i] = HAS_PROPERTY(element, i);
2857 }
2858
2859 static void CopyCustomElementPropertiesToGame(int element)
2860 {
2861   int i;
2862
2863   for (i=0; i < NUM_ELEMENT_PROPERTIES; i++)
2864     SET_PROPERTY(element, i, custom_element_properties[i]);
2865 }
2866
2867 void DrawLevelEd()
2868 {
2869   CloseDoor(DOOR_CLOSE_ALL);
2870   OpenDoor(DOOR_OPEN_2 | DOOR_NO_DELAY);
2871
2872   if (level_editor_test_game)
2873   {
2874     CopyPlayfield(Ur, Feld);
2875     CopyPlayfield(FieldBackup, Ur);
2876
2877     level_editor_test_game = FALSE;
2878   }
2879   else
2880   {
2881     edit_mode = ED_MODE_DRAWING;
2882     edit_mode_properties = ED_MODE_PROPERTIES_INFO;
2883
2884     ResetUndoBuffer();
2885
2886     level_xpos = -1;
2887     level_ypos = -1;
2888   }
2889
2890   /* copy default editor door content to main double buffer */
2891   BlitBitmap(graphic_info[IMG_GLOBAL_DOOR].bitmap, drawto,
2892              DOOR_GFX_PAGEX6, DOOR_GFX_PAGEY1, DXSIZE, DYSIZE, DX, DY);
2893
2894   /* draw mouse button brush elements */
2895   DrawMiniGraphicExt(drawto,
2896                      DX + ED_WIN_MB_LEFT_XPOS, DY + ED_WIN_MB_LEFT_YPOS,
2897                      el2edimg(new_element1));
2898   DrawMiniGraphicExt(drawto,
2899                      DX + ED_WIN_MB_MIDDLE_XPOS, DY + ED_WIN_MB_MIDDLE_YPOS,
2900                      el2edimg(new_element2));
2901   DrawMiniGraphicExt(drawto,
2902                      DX + ED_WIN_MB_RIGHT_XPOS, DY + ED_WIN_MB_RIGHT_YPOS,
2903                      el2edimg(new_element3));
2904
2905   /* draw bigger door */
2906   DrawSpecialEditorDoor();
2907
2908   /* draw new control window */
2909   BlitBitmap(graphic_info[IMG_GLOBAL_DOOR].bitmap, drawto,
2910              DOOR_GFX_PAGEX8, 236, EXSIZE, EYSIZE, EX, EY);
2911
2912   redraw_mask |= REDRAW_ALL;
2913
2914   ReinitializeElementListButtons();     /* only needed after setup changes */
2915
2916   UnmapTapeButtons();
2917   MapControlButtons();
2918
2919   /* copy actual editor door content to door double buffer for OpenDoor() */
2920   BlitBitmap(drawto, bitmap_db_door,
2921              DX, DY, DXSIZE, DYSIZE, DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1);
2922
2923   DrawEditModeWindow();
2924
2925   OpenDoor(DOOR_OPEN_1);
2926 }
2927
2928 static void AdjustDrawingAreaGadgets()
2929 {
2930   int ed_xsize = lev_fieldx + 2;
2931   int ed_ysize = lev_fieldy + 2;
2932   int max_ed_fieldx = MAX_ED_FIELDX;
2933   int max_ed_fieldy = MAX_ED_FIELDY;
2934   boolean horizontal_scrollbar_needed;
2935   boolean vertical_scrollbar_needed;
2936   int x, y, width, height;
2937   int xoffset, yoffset;
2938
2939   /* check if we need any scrollbars */
2940   horizontal_scrollbar_needed = (ed_xsize > max_ed_fieldx);
2941   vertical_scrollbar_needed = (ed_ysize > max_ed_fieldy);
2942
2943   /* check if we have a smaller editor field because of scrollbars */
2944   if (horizontal_scrollbar_needed)
2945     max_ed_fieldy = MAX_ED_FIELDY - 1;
2946   if (vertical_scrollbar_needed)
2947     max_ed_fieldx = MAX_ED_FIELDX - 1;
2948
2949   /* check again if we now need more scrollbars because of less space */
2950   horizontal_scrollbar_needed = (ed_xsize > max_ed_fieldx);
2951   vertical_scrollbar_needed = (ed_ysize > max_ed_fieldy);
2952
2953   /* check if editor field gets even smaller after adding new scrollbars */
2954   if (horizontal_scrollbar_needed)
2955     max_ed_fieldy = MAX_ED_FIELDY - 1;
2956   if (vertical_scrollbar_needed)
2957     max_ed_fieldx = MAX_ED_FIELDX - 1;
2958
2959   ed_fieldx = (ed_xsize < MAX_ED_FIELDX ? ed_xsize : max_ed_fieldx);
2960   ed_fieldy = (ed_ysize < MAX_ED_FIELDY ? ed_ysize : max_ed_fieldy);
2961
2962   ModifyGadget(level_editor_gadget[GADGET_ID_DRAWING_LEVEL],
2963                GDI_WIDTH, ed_fieldx * MINI_TILEX,
2964                GDI_HEIGHT, ed_fieldy * MINI_TILEY,
2965                GDI_AREA_SIZE, ed_fieldx, ed_fieldy,
2966                GDI_END);
2967
2968   xoffset = (ed_fieldx == MAX_ED_FIELDX ? ED_SCROLLBUTTON_XSIZE : 0);
2969   yoffset = (ed_fieldy == MAX_ED_FIELDY ? ED_SCROLLBUTTON_YSIZE : 0);
2970
2971   x = SX + scrollbutton_info[ED_SCROLLBUTTON_ID_AREA_RIGHT].x + xoffset;
2972   y = SX + scrollbutton_info[ED_SCROLLBUTTON_ID_AREA_DOWN].y + yoffset;
2973
2974   ModifyGadget(level_editor_gadget[GADGET_ID_SCROLL_RIGHT], GDI_X, x, GDI_END);
2975   ModifyGadget(level_editor_gadget[GADGET_ID_SCROLL_DOWN], GDI_Y, y, GDI_END);
2976
2977   width = scrollbar_info[ED_SCROLLBAR_ID_AREA_HORIZONTAL].width + xoffset;
2978   height = scrollbar_info[ED_SCROLLBAR_ID_AREA_VERTICAL].height + yoffset;
2979
2980   ModifyGadget(level_editor_gadget[GADGET_ID_SCROLL_HORIZONTAL],
2981                GDI_WIDTH, width,
2982                GDI_SCROLLBAR_ITEMS_VISIBLE, ed_fieldx,
2983                GDI_END);
2984   ModifyGadget(level_editor_gadget[GADGET_ID_SCROLL_VERTICAL],
2985                GDI_HEIGHT, height,
2986                GDI_SCROLLBAR_ITEMS_VISIBLE, ed_fieldy,
2987                GDI_END);
2988 }
2989
2990 static void AdjustLevelScrollPosition()
2991 {
2992   if (level_xpos < -1)
2993     level_xpos = -1;
2994   if (level_xpos > lev_fieldx - ed_fieldx + 1)
2995     level_xpos = lev_fieldx - ed_fieldx + 1;
2996   if (lev_fieldx < ed_fieldx - 2)
2997     level_xpos = -1;
2998
2999   if (level_ypos < -1)
3000     level_ypos = -1;
3001   if (level_ypos > lev_fieldy - ed_fieldy + 1)
3002     level_ypos = lev_fieldy - ed_fieldy + 1;
3003   if (lev_fieldy < ed_fieldy - 2)
3004     level_ypos = -1;
3005 }
3006
3007 static void AdjustEditorScrollbar(int id)
3008 {
3009   struct GadgetInfo *gi = level_editor_gadget[id];
3010   int items_max, items_visible, item_position;
3011
3012   if (id == GADGET_ID_SCROLL_HORIZONTAL)
3013   {
3014     items_max = MAX(lev_fieldx + 2, ed_fieldx);
3015     items_visible = ed_fieldx;
3016     item_position = level_xpos + 1;
3017   }
3018   else
3019   {
3020     items_max = MAX(lev_fieldy + 2, ed_fieldy);
3021     items_visible = ed_fieldy;
3022     item_position = level_ypos + 1;
3023   }
3024
3025   if (item_position > items_max - items_visible)
3026     item_position = items_max - items_visible;
3027
3028   ModifyGadget(gi, GDI_SCROLLBAR_ITEMS_MAX, items_max,
3029                GDI_SCROLLBAR_ITEM_POSITION, item_position, GDI_END);
3030 }
3031
3032 static void ModifyEditorTextInput(int textinput_id, char *new_text)
3033 {
3034   int gadget_id = textinput_info[textinput_id].gadget_id;
3035   struct GadgetInfo *gi = level_editor_gadget[gadget_id];
3036
3037   ModifyGadget(gi, GDI_TEXT_VALUE, new_text, GDI_END);
3038 }
3039
3040 static void ModifyEditorCounter(int counter_id, int new_value)
3041 {
3042   int *counter_value = counterbutton_info[counter_id].value;
3043   int gadget_id = counterbutton_info[counter_id].gadget_id_text;
3044   struct GadgetInfo *gi = level_editor_gadget[gadget_id];
3045
3046   ModifyGadget(gi, GDI_NUMBER_VALUE, new_value, GDI_END);
3047
3048   if (counter_value != NULL)
3049     *counter_value = gi->text.number_value;
3050 }
3051
3052 static void ModifyEditorCounterLimits(int counter_id, int min, int max)
3053 {
3054   int gadget_id = counterbutton_info[counter_id].gadget_id_text;
3055   struct GadgetInfo *gi = level_editor_gadget[gadget_id];
3056
3057   ModifyGadget(gi, GDI_NUMBER_MIN, min, GDI_NUMBER_MAX, max, GDI_END);
3058 }
3059
3060 static void PickDrawingElement(int button, int element)
3061 {
3062   if (button < 1 || button > 3)
3063     return;
3064
3065   if (button == 1)
3066   {
3067     new_element1 = element;
3068     DrawMiniGraphicExt(drawto,
3069                        DX + ED_WIN_MB_LEFT_XPOS, DY + ED_WIN_MB_LEFT_YPOS,
3070                        el2edimg(new_element1));
3071   }
3072   else if (button == 2)
3073   {
3074     new_element2 = element;
3075     DrawMiniGraphicExt(drawto,
3076                        DX + ED_WIN_MB_MIDDLE_XPOS, DY + ED_WIN_MB_MIDDLE_YPOS,
3077                        el2edimg(new_element2));
3078   }
3079   else
3080   {
3081     new_element3 = element;
3082     DrawMiniGraphicExt(drawto,
3083                        DX + ED_WIN_MB_RIGHT_XPOS, DY + ED_WIN_MB_RIGHT_YPOS,
3084                        el2edimg(new_element3));
3085   }
3086
3087   redraw_mask |= REDRAW_DOOR_1;
3088 }
3089
3090 static void DrawDrawingWindow()
3091 {
3092   SetMainBackgroundImage(IMG_UNDEFINED);
3093   ClearWindow();
3094   UnmapLevelEditorWindowGadgets();
3095
3096   AdjustDrawingAreaGadgets();
3097   AdjustLevelScrollPosition();
3098   AdjustEditorScrollbar(GADGET_ID_SCROLL_HORIZONTAL);
3099   AdjustEditorScrollbar(GADGET_ID_SCROLL_VERTICAL);
3100
3101   DrawMiniLevel(ed_fieldx, ed_fieldy, level_xpos, level_ypos);
3102   MapMainDrawingArea();
3103 }
3104
3105 static void DrawElementBorder(int dest_x, int dest_y, int width, int height)
3106 {
3107   int border_graphic = IMG_EDITOR_ELEMENT_BORDER;
3108   Bitmap *src_bitmap;
3109   int src_x, src_y;
3110   int num_mini_tilex = width / MINI_TILEX + 1;
3111   int num_mini_tiley = width / MINI_TILEY + 1;
3112   int x, y;
3113
3114   getMiniGraphicSource(border_graphic, &src_bitmap, &src_x, &src_y);
3115
3116   for (y=0; y < num_mini_tiley; y++)
3117     for (x=0; x < num_mini_tilex; x++)
3118       BlitBitmap(src_bitmap, drawto, src_x, src_y, MINI_TILEX, MINI_TILEY,
3119                  dest_x - MINI_TILEX / 2 + x * MINI_TILEX,
3120                  dest_y - MINI_TILEY / 2 + y * MINI_TILEY);
3121
3122   ClearRectangle(drawto, dest_x - 1, dest_y - 1, width + 2, height + 2);
3123 }
3124
3125 static void DrawRandomPlacementBackgroundArea()
3126 {
3127   int area_x = ED_AREA_RANDOM_BACKGROUND_XPOS / MINI_TILEX;
3128   int area_y = ED_AREA_RANDOM_BACKGROUND_YPOS / MINI_TILEY;
3129   int area_sx = SX + ED_AREA_RANDOM_BACKGROUND_XPOS;
3130   int area_sy = SY + ED_AREA_RANDOM_BACKGROUND_YPOS;
3131
3132   ElementContent[0][0][0] = random_placement_background_element;
3133
3134   DrawElementBorder(area_sx, area_sy, MINI_TILEX, MINI_TILEY);
3135   DrawMiniElement(area_x, area_y, ElementContent[0][0][0]);
3136
3137   MapDrawingArea(GADGET_ID_RANDOM_BACKGROUND);
3138 }
3139
3140 static void DrawLevelInfoWindow()
3141 {
3142   char infotext[MAX_OUTPUT_LINESIZE + 1];
3143   int max_infotext_len = getMaxInfoTextLength();
3144   int xoffset_above = 0;
3145   int yoffset_above = -(MINI_TILEX + ED_GADGET_DISTANCE);
3146   int xoffset_right = getCounterGadgetWidth();
3147   int yoffset_right = ED_BORDER_SIZE;
3148   int xoffset_right2 = ED_CHECKBUTTON_XSIZE + 2 * ED_GADGET_DISTANCE;
3149   int yoffset_right2 = ED_BORDER_SIZE;
3150   int i, x, y;
3151
3152   SetMainBackgroundImage(IMG_BACKGROUND_EDITOR);
3153   ClearWindow();
3154   UnmapLevelEditorWindowGadgets();
3155
3156   DrawText(SX + ED_SETTINGS2_XPOS, SY + ED_SETTINGS_YPOS,
3157            "Level Settings", FONT_TITLE_1);
3158   DrawText(SX + ED_SETTINGS2_XPOS, SY + ED_SETTINGS2_YPOS,
3159            "Editor Settings", FONT_TITLE_1);
3160
3161   /* draw counter gadgets */
3162   for (i=ED_COUNTER_ID_LEVEL_FIRST; i<=ED_COUNTER_ID_LEVEL_LAST; i++)
3163   {
3164     if (counterbutton_info[i].infotext_above)
3165     {
3166       x = counterbutton_info[i].x + xoffset_above;
3167       y = counterbutton_info[i].y + yoffset_above;
3168
3169       sprintf(infotext, "%s:", counterbutton_info[i].infotext_above);
3170       infotext[max_infotext_len] = '\0';
3171       DrawTextF(x, y, FONT_TEXT_1, infotext);
3172     }
3173
3174     if (counterbutton_info[i].infotext_right)
3175     {
3176       x = counterbutton_info[i].x + xoffset_right;
3177       y = counterbutton_info[i].y + yoffset_right;
3178
3179       sprintf(infotext, "%s", counterbutton_info[i].infotext_right);
3180       infotext[max_infotext_len] = '\0';
3181       DrawTextF(x, y, FONT_TEXT_1, infotext);
3182     }
3183
3184     ModifyEditorCounter(i, *counterbutton_info[i].value);
3185     MapCounterButtons(i);
3186   }
3187
3188   /* draw text input gadgets */
3189   for (i=ED_TEXTINPUT_ID_LEVEL_FIRST; i<=ED_TEXTINPUT_ID_LEVEL_LAST; i++)
3190   {
3191     x = textinput_info[i].x + xoffset_above;
3192     y = textinput_info[i].y + yoffset_above;
3193
3194     sprintf(infotext, "%s:", textinput_info[i].infotext);
3195     infotext[max_infotext_len] = '\0';
3196
3197     DrawTextF(x, y, FONT_TEXT_1, infotext);
3198     ModifyEditorTextInput(i, textinput_info[i].value);
3199     MapTextInputGadget(i);
3200   }
3201
3202   /* draw radiobutton gadgets */
3203   for (i=ED_RADIOBUTTON_ID_LEVEL_FIRST; i<=ED_RADIOBUTTON_ID_LEVEL_LAST; i++)
3204   {
3205     boolean checked =
3206       (*radiobutton_info[i].value == radiobutton_info[i].checked_value);
3207
3208     x = radiobutton_info[i].x + xoffset_right2;
3209     y = radiobutton_info[i].y + yoffset_right2;
3210
3211     DrawTextF(x, y, FONT_TEXT_1, radiobutton_info[i].text);
3212     ModifyGadget(level_editor_gadget[radiobutton_info[i].gadget_id],
3213                  GDI_CHECKED, checked, GDI_END);
3214     MapRadiobuttonGadget(i);
3215   }
3216
3217   /* draw checkbutton gadgets */
3218   for (i=ED_CHECKBUTTON_ID_LEVEL_FIRST; i<=ED_CHECKBUTTON_ID_LEVEL_LAST; i++)
3219   {
3220     x = checkbutton_info[i].x + xoffset_right2;
3221     y = checkbutton_info[i].y + yoffset_right2;
3222
3223     DrawTextF(x, y, FONT_TEXT_1, checkbutton_info[i].text);
3224     ModifyGadget(level_editor_gadget[checkbutton_info[i].gadget_id],
3225                  GDI_CHECKED, *checkbutton_info[i].value, GDI_END);
3226     MapCheckbuttonGadget(i);
3227   }
3228
3229   /* draw drawing area */
3230   DrawRandomPlacementBackgroundArea();
3231 }
3232
3233 static void DrawAmoebaContentArea()
3234 {
3235   int area_x = ED_AREA_ELEM_CONTENT_XPOS / MINI_TILEX;
3236   int area_y = ED_AREA_ELEM_CONTENT_YPOS / MINI_TILEY;
3237   int area_sx = SX + ED_AREA_ELEM_CONTENT_XPOS;
3238   int area_sy = SY + ED_AREA_ELEM_CONTENT_YPOS;
3239
3240   ElementContent[0][0][0] = level.amoeba_content;
3241
3242   DrawElementBorder(area_sx, area_sy, MINI_TILEX, MINI_TILEY);
3243   DrawMiniElement(area_x, area_y, ElementContent[0][0][0]);
3244
3245   DrawText(area_sx + TILEX, area_sy + 1, "Content of amoeba", FONT_TEXT_1);
3246
3247   MapDrawingArea(GADGET_ID_AMOEBA_CONTENT);
3248 }
3249
3250 static void DrawCustomChangedArea()
3251 {
3252   int area_x = ED_AREA_ELEM_CONTENT2_XPOS / MINI_TILEX;
3253   int area_y = ED_AREA_ELEM_CONTENT2_YPOS / MINI_TILEY;
3254   int area_sx = SX + ED_AREA_ELEM_CONTENT2_XPOS;
3255   int area_sy = SY + ED_AREA_ELEM_CONTENT2_YPOS;
3256   int i = properties_element - EL_CUSTOM_START;
3257
3258   if (!IS_CUSTOM_ELEMENT(properties_element))
3259   {
3260     /* this should never happen */
3261     Error(ERR_WARN, "element %d is no custom element", properties_element);
3262
3263     return;
3264   }
3265
3266   ElementContent[0][0][0] = level.custom_element_successor[i];
3267
3268   DrawElementBorder(area_sx, area_sy, MINI_TILEX, MINI_TILEY);
3269   DrawMiniElement(area_x, area_y, ElementContent[0][0][0]);
3270
3271   DrawText(area_sx + TILEX, area_sy + 1, "Element after change", FONT_TEXT_1);
3272
3273   MapDrawingArea(GADGET_ID_CUSTOM_CHANGED);
3274 }
3275
3276 static void DrawElementContentAreas()
3277 {
3278   int counter_id = ED_COUNTER_ID_ELEM_CONTENT;
3279   int area_x = ED_AREA_ELEM_CONTENT_XPOS / MINI_TILEX;
3280   int area_y = ED_AREA_ELEM_CONTENT_YPOS / MINI_TILEY;
3281   int area_sx = SX + ED_AREA_ELEM_CONTENT_XPOS;
3282   int area_sy = SY + ED_AREA_ELEM_CONTENT_YPOS;
3283   int xoffset_right = getCounterGadgetWidth();
3284   int yoffset_right = ED_BORDER_SIZE;
3285   int i, x, y;
3286
3287   for (i=0; i<MAX_ELEMENT_CONTENTS; i++)
3288     for (y=0; y<3; y++)
3289       for (x=0; x<3; x++)
3290         ElementContent[i][x][y] = level.yam_content[i][x][y];
3291
3292   for (i=0; i<MAX_ELEMENT_CONTENTS; i++)
3293     UnmapDrawingArea(GADGET_ID_ELEM_CONTENT_0 + i);
3294
3295   /* display counter to choose number of element content areas */
3296   x = counterbutton_info[counter_id].x + xoffset_right;
3297   y = counterbutton_info[counter_id].y + yoffset_right;
3298   DrawTextF(x, y, FONT_TEXT_1, "number of content areas");
3299
3300   ModifyEditorCounter(counter_id, *counterbutton_info[counter_id].value);
3301   MapCounterButtons(counter_id);
3302
3303   /* delete content areas in case of reducing number of them */
3304   DrawBackground(SX, area_sy - MINI_TILEX, SXSIZE, 12 * MINI_TILEY);
3305
3306   for (i=0; i<level.num_yam_contents; i++)
3307     DrawElementBorder(area_sx + 5 * (i % 4) * MINI_TILEX,
3308                       area_sy + 6 * (i / 4) * MINI_TILEY,
3309                       3 * MINI_TILEX, 3 * MINI_TILEY);
3310
3311   DrawText(area_sx + (5 * 4 - 1) * MINI_TILEX, area_sy + 0 * MINI_TILEY + 1,
3312            "Content", FONT_TEXT_1);
3313   DrawText(area_sx + (5 * 4 - 1) * MINI_TILEX, area_sy + 1 * MINI_TILEY + 1,
3314            "when",    FONT_TEXT_1);
3315   DrawText(area_sx + (5 * 4 - 1) * MINI_TILEX, area_sy + 2 * MINI_TILEY + 1,
3316            "smashed", FONT_TEXT_1);
3317
3318   for (i=0; i<level.num_yam_contents; i++)
3319   {
3320     for (y=0; y<3; y++)
3321       for (x=0; x<3; x++)
3322         DrawMiniElement(area_x + 5 * (i % 4) + x, area_y + 6 * (i / 4) + y,
3323                         ElementContent[i][x][y]);
3324
3325     DrawTextF(area_sx - SX + 5 * (i % 4) * MINI_TILEX + MINI_TILEX + 1,
3326               area_sy - SY + 6 * (i / 4) * MINI_TILEY + 4 * MINI_TILEY - 4,
3327               FONT_TEXT_1, "%d", i + 1);
3328   }
3329
3330   for (i=0; i<level.num_yam_contents; i++)
3331     MapDrawingArea(GADGET_ID_ELEM_CONTENT_0 + i);
3332 }
3333
3334 #define TEXT_COLLECTING         "Score for collecting"
3335 #define TEXT_SMASHING           "Score for smashing"
3336 #define TEXT_CRACKING           "Score for cracking"
3337 #define TEXT_SPEED              "Speed of amoeba growth"
3338 #define TEXT_DURATION           "Duration when activated"
3339
3340 static struct
3341 {
3342   int element;
3343   int *value;
3344   char *text;
3345 } elements_with_counter[] =
3346 {
3347   { EL_EMERALD,         &level.score[SC_EMERALD],       TEXT_COLLECTING },
3348   { EL_BD_DIAMOND,      &level.score[SC_EMERALD],       TEXT_COLLECTING },
3349   { EL_EMERALD_YELLOW,  &level.score[SC_EMERALD],       TEXT_COLLECTING },
3350   { EL_EMERALD_RED,     &level.score[SC_EMERALD],       TEXT_COLLECTING },
3351   { EL_EMERALD_PURPLE,  &level.score[SC_EMERALD],       TEXT_COLLECTING },
3352   { EL_DIAMOND,         &level.score[SC_DIAMOND],       TEXT_COLLECTING },
3353   { EL_BUG_RIGHT,       &level.score[SC_BUG],           TEXT_SMASHING   },
3354   { EL_BUG_UP,          &level.score[SC_BUG],           TEXT_SMASHING   },
3355   { EL_BUG_LEFT,        &level.score[SC_BUG],           TEXT_SMASHING   },
3356   { EL_BUG_DOWN,        &level.score[SC_BUG],           TEXT_SMASHING   },
3357   { EL_BD_BUTTERFLY_RIGHT,&level.score[SC_BUG],         TEXT_SMASHING   },
3358   { EL_BD_BUTTERFLY_UP,   &level.score[SC_BUG],         TEXT_SMASHING   },
3359   { EL_BD_BUTTERFLY_LEFT, &level.score[SC_BUG],         TEXT_SMASHING   },
3360   { EL_BD_BUTTERFLY_DOWN, &level.score[SC_BUG],         TEXT_SMASHING   },
3361   { EL_SPACESHIP_RIGHT, &level.score[SC_SPACESHIP],     TEXT_SMASHING   },
3362   { EL_SPACESHIP_UP,    &level.score[SC_SPACESHIP],     TEXT_SMASHING   },
3363   { EL_SPACESHIP_LEFT,  &level.score[SC_SPACESHIP],     TEXT_SMASHING   },
3364   { EL_SPACESHIP_DOWN,  &level.score[SC_SPACESHIP],     TEXT_SMASHING   },
3365   { EL_BD_FIREFLY_RIGHT,&level.score[SC_SPACESHIP],     TEXT_SMASHING   },
3366   { EL_BD_FIREFLY_UP,   &level.score[SC_SPACESHIP],     TEXT_SMASHING   },
3367   { EL_BD_FIREFLY_LEFT, &level.score[SC_SPACESHIP],     TEXT_SMASHING   },
3368   { EL_BD_FIREFLY_DOWN, &level.score[SC_SPACESHIP],     TEXT_SMASHING   },
3369   { EL_YAMYAM,          &level.score[SC_YAMYAM],        TEXT_SMASHING   },
3370   { EL_DARK_YAMYAM,     &level.score[SC_YAMYAM],        TEXT_SMASHING   },
3371   { EL_ROBOT,           &level.score[SC_ROBOT],         TEXT_SMASHING   },
3372   { EL_PACMAN_RIGHT,    &level.score[SC_PACMAN],        TEXT_SMASHING   },
3373   { EL_PACMAN_UP,       &level.score[SC_PACMAN],        TEXT_SMASHING   },
3374   { EL_PACMAN_LEFT,     &level.score[SC_PACMAN],        TEXT_SMASHING   },
3375   { EL_PACMAN_DOWN,     &level.score[SC_PACMAN],        TEXT_SMASHING   },
3376   { EL_NUT,             &level.score[SC_NUT],           TEXT_CRACKING   },
3377   { EL_DYNAMITE,        &level.score[SC_DYNAMITE],      TEXT_COLLECTING },
3378   { EL_KEY_1,           &level.score[SC_KEY],           TEXT_COLLECTING },
3379   { EL_KEY_2,           &level.score[SC_KEY],           TEXT_COLLECTING },
3380   { EL_KEY_3,           &level.score[SC_KEY],           TEXT_COLLECTING },
3381   { EL_KEY_4,           &level.score[SC_KEY],           TEXT_COLLECTING },
3382   { EL_EM_KEY_1_FILE,   &level.score[SC_KEY],           TEXT_COLLECTING },
3383   { EL_EM_KEY_2_FILE,   &level.score[SC_KEY],           TEXT_COLLECTING },
3384   { EL_EM_KEY_3_FILE,   &level.score[SC_KEY],           TEXT_COLLECTING },
3385   { EL_EM_KEY_4_FILE,   &level.score[SC_KEY],           TEXT_COLLECTING },
3386   { EL_AMOEBA_WET,      &level.amoeba_speed,            TEXT_SPEED      },
3387   { EL_AMOEBA_DRY,      &level.amoeba_speed,            TEXT_SPEED      },
3388   { EL_AMOEBA_FULL,     &level.amoeba_speed,            TEXT_SPEED      },
3389   { EL_BD_AMOEBA,       &level.amoeba_speed,            TEXT_SPEED      },
3390   { EL_MAGIC_WALL,      &level.time_magic_wall,         TEXT_DURATION   },
3391   { EL_ROBOT_WHEEL,     &level.time_wheel,              TEXT_DURATION   },
3392   { -1,                 NULL,                           NULL            }
3393 };
3394
3395 static boolean checkPropertiesConfig()
3396 {
3397   int i;
3398
3399   if (IS_GEM(properties_element) ||
3400       IS_CUSTOM_ELEMENT(properties_element) ||
3401       HAS_CONTENT(properties_element))
3402     return TRUE;
3403   else
3404     for (i=0; elements_with_counter[i].element != -1; i++)
3405       if (elements_with_counter[i].element == properties_element)
3406         return TRUE;
3407
3408   return FALSE;
3409 }
3410
3411 static void DrawPropertiesConfig()
3412 {
3413   boolean element_has_score = FALSE;
3414   char *element_score_text = NULL;
3415   int temporary_dummy_score = 0;
3416   int counter_id = ED_COUNTER_ID_ELEM_SCORE;
3417   int xoffset_right = getCounterGadgetWidth();
3418   int yoffset_right = ED_BORDER_SIZE;
3419   int xoffset_right2 = ED_CHECKBUTTON_XSIZE + 2 * ED_GADGET_DISTANCE;
3420   int yoffset_right2 = ED_BORDER_SIZE;
3421   int i, x, y;
3422
3423   /* check if there are elements where a score can be chosen for */
3424   for (i=0; elements_with_counter[i].element != -1; i++)
3425   {
3426     if (elements_with_counter[i].element == properties_element)
3427     {
3428 #if 1
3429       counterbutton_info[counter_id].value = elements_with_counter[i].value;
3430       element_score_text = elements_with_counter[i].text;
3431       element_has_score = TRUE;
3432 #else
3433       int x = counterbutton_info[counter_id].x + xoffset_right;
3434       int y = counterbutton_info[counter_id].y + yoffset_right;
3435
3436       counterbutton_info[counter_id].value = elements_with_counter[i].value;
3437       DrawTextF(x, y, FONT_TEXT_1, elements_with_counter[i].text);
3438
3439       ModifyEditorCounter(counter_id,  *counterbutton_info[counter_id].value);
3440       MapCounterButtons(counter_id);
3441 #endif
3442       break;
3443     }
3444   }
3445
3446   if (IS_CUSTOM_ELEMENT(properties_element))
3447   {
3448     counterbutton_info[counter_id].value = &temporary_dummy_score;
3449     element_score_text = "Score for certain actions";
3450     element_has_score = TRUE;
3451   }
3452
3453   if (element_has_score)
3454   {
3455     int x = counterbutton_info[counter_id].x + xoffset_right;
3456     int y = counterbutton_info[counter_id].y + yoffset_right;
3457
3458     DrawTextF(x, y, FONT_TEXT_1, element_score_text);
3459
3460     ModifyEditorCounter(counter_id,  *counterbutton_info[counter_id].value);
3461     MapCounterButtons(counter_id);
3462   }
3463
3464   if (HAS_CONTENT(properties_element))
3465   {
3466     /* draw stickybutton gadget */
3467     i = ED_CHECKBUTTON_ID_STICK_ELEMENT;
3468     x = checkbutton_info[i].x + xoffset_right2;
3469     y = checkbutton_info[i].y + yoffset_right2;
3470
3471     DrawTextF(x, y, FONT_TEXT_1, checkbutton_info[i].text);
3472     ModifyGadget(level_editor_gadget[checkbutton_info[i].gadget_id],
3473                  GDI_CHECKED, *checkbutton_info[i].value, GDI_END);
3474     MapCheckbuttonGadget(i);
3475
3476     if (HAS_CONTENT(properties_element))
3477     {
3478       if (IS_AMOEBOID(properties_element))
3479         DrawAmoebaContentArea();
3480       else
3481         DrawElementContentAreas();
3482     }
3483   }
3484
3485   if (IS_GEM(properties_element))
3486   {
3487     /* draw checkbutton gadget */
3488     i = ED_CHECKBUTTON_ID_EM_SLIPPERY_GEMS;
3489     x = checkbutton_info[i].x + xoffset_right2;
3490     y = checkbutton_info[i].y + yoffset_right2;
3491
3492     DrawTextF(x, y, FONT_TEXT_1, checkbutton_info[i].text);
3493     ModifyGadget(level_editor_gadget[checkbutton_info[i].gadget_id],
3494                  GDI_CHECKED, *checkbutton_info[i].value, GDI_END);
3495     MapCheckbuttonGadget(i);
3496   }
3497
3498   if (IS_CUSTOM_ELEMENT(properties_element))
3499   {
3500     CopyCustomElementPropertiesToEditor(properties_element);
3501
3502     for (i =  ED_CHECKBUTTON_ID_CUSTOM_FIRST;
3503          i <= ED_CHECKBUTTON_ID_CUSTOM_LAST; i++)
3504     {
3505       /* draw checkbutton gadget */
3506       x = checkbutton_info[i].x + xoffset_right2;
3507       y = checkbutton_info[i].y + yoffset_right2;
3508
3509       DrawTextF(x, y, FONT_TEXT_1, checkbutton_info[i].text);
3510       ModifyGadget(level_editor_gadget[checkbutton_info[i].gadget_id],
3511                    GDI_CHECKED, *checkbutton_info[i].value, GDI_END);
3512       MapCheckbuttonGadget(i);
3513     }
3514   }
3515 }
3516
3517 char *getElementDescriptionFilename(int element)
3518 {
3519   char *docs_dir = options.docs_directory;
3520   char *elements_subdir = "elements";
3521   static char *filename = NULL;
3522   char basename[MAX_FILENAME_LEN];
3523
3524   if (filename != NULL)
3525     free(filename);
3526
3527   /* 1st try: look for element description file for exactly this element */
3528   sprintf(basename, "%s.txt", element_info[element].token_name);
3529   filename = getPath3(docs_dir, elements_subdir, basename);
3530   if (fileExists(filename))
3531     return filename;
3532
3533   free(filename);
3534
3535   /* 2nd try: look for element description file for this element's class */
3536   sprintf(basename, "%s.txt", element_info[element].class_name);
3537   filename = getPath3(docs_dir, elements_subdir, basename);
3538   if (fileExists(filename))
3539     return filename;
3540
3541   return NULL;
3542 }
3543
3544 static boolean PrintInfoText(char *text, int font_nr, int screen_line)
3545 {
3546   int font_height = getFontHeight(font_nr);
3547   int pad_x = ED_SETTINGS_XPOS;
3548   int pad_y = 5 * TILEY;
3549   int sx = SX + pad_x;
3550   int sy = SY + pad_y;
3551   int max_lines_per_screen = (SYSIZE - pad_y) / font_height - 1;
3552
3553   if (screen_line >= max_lines_per_screen)
3554     return FALSE;
3555
3556   DrawText(sx, sy + screen_line * font_height, text, font_nr);
3557
3558   return TRUE;
3559 }
3560
3561 static int PrintElementDescriptionFromFile(char *filename, int screen_line)
3562 {
3563   int font_nr = FONT_TEXT_2;
3564   int font_width = getFontWidth(font_nr);
3565   int pad_x = ED_SETTINGS_XPOS;
3566   int max_chars_per_line = (SXSIZE - 2 * pad_x) / font_width;
3567   char line[MAX_LINE_LEN];
3568   char buffer[max_chars_per_line + 1];
3569   int buffer_len;
3570   int lines_printed = 0;
3571   FILE *file;
3572
3573   if (filename == NULL)
3574     return 0;
3575
3576   if (!(file = fopen(filename, MODE_READ)))
3577     return 0;
3578
3579   buffer[0] = '\0';
3580   buffer_len = 0;
3581
3582   while(!feof(file))
3583   {
3584     char *line_ptr, *word_ptr;
3585     boolean last_line_was_empty = TRUE;
3586
3587     /* read next line of input file */
3588     if (!fgets(line, MAX_LINE_LEN, file))
3589       break;
3590
3591     /* skip comments (lines directly beginning with '#') */
3592     if (line[0] == '#')
3593       continue;
3594
3595     /* cut trailing newline from input line */
3596     for (line_ptr = line; *line_ptr; line_ptr++)
3597     {
3598       if (*line_ptr == '\n' || *line_ptr == '\r')
3599       {
3600         *line_ptr = '\0';
3601         break;
3602       }
3603     }
3604
3605     if (strlen(line) == 0)              /* special case: force empty line */
3606       strcpy(line, "\n");
3607
3608     word_ptr = line;
3609
3610     while (*word_ptr)
3611     {
3612       boolean print_buffer = FALSE;
3613       int word_len;
3614
3615       /* skip leading whitespaces */
3616       while (*word_ptr == ' ' || *word_ptr == '\t')
3617         word_ptr++;
3618
3619       line_ptr = word_ptr;
3620       word_len = 0;
3621
3622       /* look for end of next word */
3623       while (*line_ptr != ' ' && *line_ptr != '\t' && *line_ptr != '\0')
3624       {
3625         line_ptr++;
3626         word_len++;
3627       }
3628
3629       if (word_len == 0)
3630       {
3631         continue;
3632       }
3633       else if (*word_ptr == '\n')       /* special case: force empty line */
3634       {
3635         if (buffer_len == 0)
3636           word_ptr++;
3637
3638         /* prevent printing of multiple empty lines */
3639         if (buffer_len > 0 || !last_line_was_empty)
3640           print_buffer = TRUE;
3641       }
3642       else if (word_len < max_chars_per_line - buffer_len)
3643       {
3644         /* word fits into text buffer -- add word */
3645
3646         if (buffer_len > 0)
3647           buffer[buffer_len++] = ' ';
3648
3649         strncpy(&buffer[buffer_len], word_ptr, word_len);
3650         buffer_len += word_len;
3651         buffer[buffer_len] = '\0';
3652         word_ptr += word_len;
3653       }
3654       else if (buffer_len > 0)
3655       {
3656         /* not enough space left for word in text buffer -- print buffer */
3657
3658         print_buffer = TRUE;
3659       }
3660       else
3661       {
3662         /* word does not fit at all into empty text buffer -- cut word */
3663
3664         strncpy(buffer, word_ptr, max_chars_per_line);
3665         buffer[max_chars_per_line] = '\0';
3666         word_ptr += max_chars_per_line;
3667         print_buffer = TRUE;
3668       }
3669
3670       if (print_buffer)
3671       {
3672         if (!PrintInfoText(buffer, font_nr, screen_line + lines_printed))
3673           return lines_printed;
3674
3675         last_line_was_empty = (buffer_len == 0);
3676         lines_printed++;
3677
3678         buffer[0] = '\0';
3679         buffer_len = 0;
3680         print_buffer = FALSE;
3681       }
3682     }
3683   }
3684
3685   fclose(file);
3686
3687   if (buffer_len > 0)
3688     if (PrintInfoText(buffer, font_nr, screen_line + lines_printed))
3689       lines_printed++;
3690
3691   return lines_printed;
3692 }
3693
3694 static void DrawPropertiesTabulatorGadgets()
3695 {
3696   struct GadgetInfo *gd_gi = level_editor_gadget[GADGET_ID_PROPERTIES_INFO];
3697   struct GadgetDesign *gd = &gd_gi->alt_design[GD_BUTTON_UNPRESSED];
3698   int gd_x = gd->x + gd_gi->border.width / 2;
3699   int gd_y = gd->y + gd_gi->height - 1;
3700   Pixel tab_color = GetPixel(gd->bitmap, gd_x, gd_y);
3701   int id_first = ED_TEXTBUTTON_ID_PROPERTIES_INFO;
3702   int id_last  = ED_TEXTBUTTON_ID_PROPERTIES_INFO;
3703   int i;
3704
3705   /* draw additional "configure" tabulator for configurable elements */
3706   if (checkPropertiesConfig())
3707     id_last = ED_TEXTBUTTON_ID_PROPERTIES_CONFIG;
3708
3709   /* draw additional "advanced" tabulator for custom elements */
3710   if (IS_CUSTOM_ELEMENT(properties_element))
3711     id_last = ED_TEXTBUTTON_ID_PROPERTIES_ADVANCED;
3712
3713   for (i=id_first; i <= id_last; i++)
3714   {
3715     int gadget_id = textbutton_info[i].gadget_id;
3716     struct GadgetInfo *gi = level_editor_gadget[gadget_id];
3717     boolean active = (i != edit_mode_properties);
3718
3719     /* draw background line below tabulator button */
3720     ClearRectangleOnBackground(drawto, gi->x, gi->y + gi->height, gi->width,1);
3721
3722     /* draw solid line below inactive tabulator buttons */
3723     if (!active && tab_color != BLACK_PIXEL)    /* black => transparent */
3724       FillRectangle(drawto, gi->x, gi->y + gi->height, gi->width,1, tab_color);
3725
3726     ModifyGadget(gi, GDI_ACTIVE, active, GDI_END);
3727     MapTextbuttonGadget(i);
3728   }
3729
3730   /* draw little border line below tabulator buttons */
3731   if (tab_color != BLACK_PIXEL)                 /* black => transparent */
3732     FillRectangle(drawto, gd_gi->x, gd_gi->y + gd_gi->height + 1,
3733                   3 * gd_gi->width + 2 * ED_GADGET_DISTANCE,
3734                   ED_GADGET_DISTANCE, tab_color);
3735 }
3736
3737 static void DrawPropertiesInfo()
3738 {
3739   static struct
3740   {
3741     int value;
3742     char *text;
3743   }
3744   properties[] =
3745   {
3746     /* configurable properties */
3747     { EP_INDESTRUCTIBLE,        "- undestructible"                      },
3748     { EP_DIGGABLE,              "- diggable"                            },
3749     { EP_COLLECTIBLE,           "- collectible"                         },
3750     { EP_PUSHABLE,              "- pushable"                            },
3751     { EP_CAN_FALL,              "- can fall"                            },
3752     { EP_CAN_SMASH,             "- can smash other objects"             },
3753     { EP_CAN_MOVE,              "- can move"                            },
3754     { EP_SLIPPERY,              "- slippery for falling objects"        },
3755     { EP_EM_SLIPPERY_WALL,      "- slippery for some gems (EM style)"   },
3756     { EP_WALKABLE_OVER,         "- player can walk over it"             },
3757     { EP_WALKABLE_INSIDE,       "- player can walk inside it"           },
3758     { EP_WALKABLE_UNDER,        "- player can walk under it"            },
3759     { EP_PASSABLE_OVER,         "- player can pass over it"             },
3760     { EP_PASSABLE_INSIDE,       "- player can pass through it"          },
3761     { EP_PASSABLE_UNDER,        "- player can pass under it"            },
3762
3763     /* pre-defined properties */
3764     { EP_CAN_PASS_MAGIC_WALL,   "- can pass magic walls"                },
3765     { EP_DONT_TOUCH,            "- deadly when touched"                 },
3766     { EP_ENEMY,                 "- can kill the player"                 },
3767     { EP_DONT_GO_TO,            "- deadly when walked to"               },
3768     { EP_CAN_EXPLODE,           "- can explode"                         },
3769     { EP_HAS_CONTENT,           "- can contain other elements"          },
3770
3771     { -1,                       NULL                                    }
3772   };
3773   char *filename = getElementDescriptionFilename(properties_element);
3774   char *percentage_text = "In this level:";
3775   char *properties_text = "Standard properties:";
3776   float percentage;
3777   int num_elements_in_level;
3778   int num_standard_properties = 0;
3779   int font1_nr = FONT_TEXT_1;
3780   int font2_nr = FONT_TEXT_2;
3781   int font1_width = getFontWidth(font1_nr);
3782   int font2_height = getFontHeight(font2_nr);
3783   int pad_x = ED_SETTINGS_XPOS;
3784   int pad_y = 5 * TILEY;
3785   int screen_line = 2;
3786   int i, x, y;
3787
3788   num_elements_in_level = 0;
3789   for (y=0; y<lev_fieldy; y++)
3790     for (x=0; x<lev_fieldx; x++)
3791       if (Feld[x][y] == properties_element)
3792         num_elements_in_level++;
3793   percentage = num_elements_in_level * 100.0 / (lev_fieldx * lev_fieldy);
3794
3795   DrawTextF(pad_x, pad_y, font1_nr, percentage_text);
3796   DrawTextF(pad_x + strlen(percentage_text) * font1_width, pad_y,
3797             font2_nr, "%d (%.2f%%)", num_elements_in_level, percentage);
3798
3799   for (i=0; properties[i].value != -1; i++)
3800     if (HAS_PROPERTY(properties_element, properties[i].value))
3801       num_standard_properties++;
3802
3803 #if 1
3804   if (num_standard_properties > 0)
3805   {
3806     DrawTextF(pad_x, pad_y + screen_line * font2_height, font1_nr,
3807               properties_text);
3808     screen_line++;
3809
3810     for (i=0; properties[i].value != -1; i++)
3811     {
3812       if (!HAS_PROPERTY(properties_element, properties[i].value))
3813         continue;
3814
3815       DrawTextF(pad_x, pad_y + screen_line * font2_height, font2_nr,
3816                 properties[i].text);
3817       screen_line++;
3818     }
3819
3820     screen_line++;
3821   }
3822 #endif
3823
3824   PrintInfoText("Description:", FONT_TEXT_1, screen_line);
3825   if (PrintElementDescriptionFromFile(filename, screen_line + 1) == 0)
3826     PrintInfoText("No description available.", FONT_TEXT_1, screen_line);
3827 }
3828
3829 static void DrawPropertiesAdvanced()
3830 {
3831   int xoffset_right2 = ED_CHECKBUTTON_XSIZE + 2 * ED_GADGET_DISTANCE;
3832   int yoffset_right2 = ED_BORDER_SIZE;
3833   int i, x, y;
3834
3835   DrawText(SX + ED_SETTINGS_XPOS, SY + 5 * TILEY,
3836            "Under construction! :-)", FONT_TEXT_1);
3837
3838   /* draw stickybutton gadget */
3839   i = ED_CHECKBUTTON_ID_STICK_ELEMENT;
3840   x = checkbutton_info[i].x + xoffset_right2;
3841   y = checkbutton_info[i].y + yoffset_right2;
3842
3843   DrawTextF(x, y, FONT_TEXT_1, checkbutton_info[i].text);
3844   ModifyGadget(level_editor_gadget[checkbutton_info[i].gadget_id],
3845                GDI_CHECKED, *checkbutton_info[i].value, GDI_END);
3846   MapCheckbuttonGadget(i);
3847
3848   DrawCustomChangedArea();
3849
3850   /* draw selectbox gadget */
3851   i = ED_SELECTBOX_ID_CUSTOM_CHANGE_CAUSE;
3852   x = selectbox_info[i].x + xoffset_right2;
3853   y = selectbox_info[i].y + yoffset_right2;
3854
3855   selectbox_info[i].index = &index_change_cause;
3856
3857   DrawTextF(x, y, FONT_TEXT_1, selectbox_info[i].text);
3858   ModifyGadget(level_editor_gadget[selectbox_info[i].gadget_id],
3859                GDI_SELECTBOX_INDEX, *selectbox_info[i].index, GDI_END);
3860   MapSelectboxGadget(i);
3861 }
3862
3863 static void DrawPropertiesWindow()
3864 {
3865   int xstart = 2;
3866   int ystart = 4;
3867
3868   /* make sure that previous properties edit mode exists for this element */
3869   if (edit_mode_properties == ED_MODE_PROPERTIES_ADVANCED &&
3870       !IS_CUSTOM_ELEMENT(properties_element))
3871     edit_mode_properties = ED_MODE_PROPERTIES_CONFIG;
3872
3873   if (edit_mode_properties == ED_MODE_PROPERTIES_CONFIG &&
3874       !checkPropertiesConfig())
3875     edit_mode_properties = ED_MODE_PROPERTIES_INFO;
3876
3877   UnmapLevelEditorWindowGadgets();
3878
3879   SetMainBackgroundImage(IMG_BACKGROUND_EDITOR);
3880   ClearWindow();
3881
3882   DrawText(SX + ED_SETTINGS2_XPOS, SY + ED_SETTINGS_YPOS,
3883            "Element Settings", FONT_TITLE_1);
3884
3885   DrawElementBorder(SX + xstart * MINI_TILEX,
3886                     SY + ystart * MINI_TILEY + MINI_TILEY / 2,
3887                     TILEX, TILEY);
3888   DrawGraphicAnimationExt(drawto,
3889                           SX + xstart * MINI_TILEX,
3890                           SY + ystart * MINI_TILEY + MINI_TILEY / 2,
3891                           el2img(properties_element), -1, NO_MASKING);
3892
3893   FrameCounter = 0;     /* restart animation frame counter */
3894
3895   DrawTextF((xstart + 3) * MINI_TILEX, (ystart + 1) * MINI_TILEY,
3896             FONT_TEXT_1, getElementInfoText(properties_element));
3897
3898   DrawPropertiesTabulatorGadgets();
3899
3900   if (edit_mode_properties == ED_MODE_PROPERTIES_INFO)
3901     DrawPropertiesInfo();
3902   else if (edit_mode_properties == ED_MODE_PROPERTIES_CONFIG)
3903     DrawPropertiesConfig();
3904   else  /* edit_mode_properties == ED_MODE_PROPERTIES_ADVANCED */
3905     DrawPropertiesAdvanced();
3906 }
3907
3908 static void DrawLineElement(int sx, int sy, int element, boolean change_level)
3909 {
3910   int lx = sx + level_xpos;
3911   int ly = sy + level_ypos;
3912
3913   DrawMiniElement(sx, sy, (element < 0 ? Feld[lx][ly] : element));
3914
3915   if (change_level)
3916     Feld[lx][ly] = element;
3917 }
3918
3919 static void DrawLine(int from_x, int from_y, int to_x, int to_y,
3920                      int element, boolean change_level)
3921 {
3922   if (from_y == to_y)                   /* horizontal line */
3923   {
3924     int x;
3925     int y = from_y;
3926
3927     if (from_x > to_x)
3928       swap_numbers(&from_x, &to_x);
3929
3930     for (x=from_x; x<=to_x; x++)
3931       DrawLineElement(x, y, element, change_level);
3932   }
3933   else if (from_x == to_x)              /* vertical line */
3934   {
3935     int x = from_x;
3936     int y;
3937
3938     if (from_y > to_y)
3939       swap_numbers(&from_y, &to_y);
3940
3941     for (y=from_y; y<=to_y; y++)
3942       DrawLineElement(x, y, element, change_level);
3943   }
3944   else                                  /* diagonal line */
3945   {
3946     int len_x = ABS(to_x - from_x);
3947     int len_y = ABS(to_y - from_y);
3948     int x, y;
3949
3950     if (len_y < len_x)                  /* a < 1 */
3951     {
3952       float a = (float)len_y / (float)len_x;
3953
3954       if (from_x > to_x)
3955         swap_number_pairs(&from_x, &from_y, &to_x, &to_y);
3956
3957       for (x=0; x<=len_x; x++)
3958       {
3959         y = (int)(a * x + 0.5) * (to_y < from_y ? -1 : +1);
3960         DrawLineElement(from_x + x, from_y + y, element, change_level);
3961       }
3962     }
3963     else                                /* a >= 1 */
3964     {
3965       float a = (float)len_x / (float)len_y;
3966
3967       if (from_y > to_y)
3968         swap_number_pairs(&from_x, &from_y, &to_x, &to_y);
3969
3970       for (y=0; y<=len_y; y++)
3971       {
3972         x = (int)(a * y + 0.5) * (to_x < from_x ? -1 : +1);
3973         DrawLineElement(from_x + x, from_y + y, element, change_level);
3974       }
3975     }
3976   }
3977 }
3978
3979 static void DrawBox(int from_x, int from_y, int to_x, int to_y,
3980                     int element, boolean change_level)
3981 {
3982   DrawLine(from_x, from_y, from_x, to_y, element, change_level);
3983   DrawLine(from_x, to_y, to_x, to_y, element, change_level);
3984   DrawLine(to_x, to_y, to_x, from_y, element, change_level);
3985   DrawLine(to_x, from_y, from_x, from_y, element, change_level);
3986 }
3987
3988 static void DrawFilledBox(int from_x, int from_y, int to_x, int to_y,
3989                           int element, boolean change_level)
3990 {
3991   int y;
3992
3993   if (from_y > to_y)
3994     swap_number_pairs(&from_x, &from_y, &to_x, &to_y);
3995
3996   for (y=from_y; y<=to_y; y++)
3997     DrawLine(from_x, y, to_x, y, element, change_level);
3998 }
3999
4000 static void DrawArcExt(int from_x, int from_y, int to_x2, int to_y2,
4001                        int element, boolean change_level)
4002 {
4003   int to_x = to_x2 - (to_x2 > from_x ? +1 : -1);
4004   int to_y = to_y2 - (to_y2 > from_y ? +1 : -1);
4005   int len_x = ABS(to_x - from_x);
4006   int len_y = ABS(to_y - from_y);
4007   int radius, x, y;
4008
4009   radius = (int)(sqrt((float)(len_x * len_x + len_y * len_y)) + 0.5);
4010
4011   /* not optimal (some points get drawn twice) but simple,
4012      and fast enough for the few points we are drawing */
4013
4014   for (x=0; x<=radius; x++)
4015   {
4016     int sx, sy, lx, ly;
4017
4018     y = (int)(sqrt((float)(radius * radius - x * x)) + 0.5);
4019
4020     sx = from_x + x * (from_x < to_x2 ? +1 : -1);
4021     sy = from_y + y * (from_y < to_y2 ? +1 : -1);
4022     lx = sx + level_xpos;
4023     ly = sy + level_ypos;
4024
4025     if (IN_ED_FIELD(sx, sy) && IN_LEV_FIELD(lx, ly))
4026       DrawLineElement(sx, sy, element, change_level);
4027   }
4028
4029   for (y=0; y<=radius; y++)
4030   {
4031     int sx, sy, lx, ly;
4032
4033     x = (int)(sqrt((float)(radius * radius - y * y)) + 0.5);
4034
4035     sx = from_x + x * (from_x < to_x2 ? +1 : -1);
4036     sy = from_y + y * (from_y < to_y2 ? +1 : -1);
4037     lx = sx + level_xpos;
4038     ly = sy + level_ypos;
4039
4040     if (IN_ED_FIELD(sx, sy) && IN_LEV_FIELD(lx, ly))
4041       DrawLineElement(sx, sy, element, change_level);
4042   }
4043 }
4044
4045 static void DrawArc(int from_x, int from_y, int to_x, int to_y,
4046                     int element, boolean change_level)
4047 {
4048   int to_x2 = to_x + (to_x < from_x ? -1 : +1);
4049   int to_y2 = to_y + (to_y > from_y ? +1 : -1);
4050
4051   DrawArcExt(from_x, from_y, to_x2, to_y2, element, change_level);
4052 }
4053
4054 #define DRAW_CIRCLES_BUTTON_AVAILABLE   0
4055 #if DRAW_CIRCLES_BUTTON_AVAILABLE
4056 static void DrawCircle(int from_x, int from_y, int to_x, int to_y,
4057                        int element, boolean change_level)
4058 {
4059   int to_x2 = to_x + (to_x < from_x ? -1 : +1);
4060   int to_y2 = to_y + (to_y > from_y ? +1 : -1);
4061   int mirror_to_x2 = from_x - (to_x2 - from_x);
4062   int mirror_to_y2 = from_y - (to_y2 - from_y);
4063
4064   DrawArcExt(from_x, from_y, to_x2, to_y2, element, change_level);
4065   DrawArcExt(from_x, from_y, mirror_to_x2, to_y2, element, change_level);
4066   DrawArcExt(from_x, from_y, to_x2, mirror_to_y2, element, change_level);
4067   DrawArcExt(from_x, from_y, mirror_to_x2, mirror_to_y2, element,change_level);
4068 }
4069 #endif
4070
4071 static void DrawAreaBorder(int from_x, int from_y, int to_x, int to_y)
4072 {
4073   int from_sx, from_sy;
4074   int to_sx, to_sy;
4075
4076   if (from_x > to_x)
4077     swap_numbers(&from_x, &to_x);
4078
4079   if (from_y > to_y)
4080     swap_numbers(&from_y, &to_y);
4081
4082   from_sx = SX + from_x * MINI_TILEX;
4083   from_sy = SY + from_y * MINI_TILEY;
4084   to_sx = SX + to_x * MINI_TILEX + MINI_TILEX - 1;
4085   to_sy = SY + to_y * MINI_TILEY + MINI_TILEY - 1;
4086
4087   DrawSimpleWhiteLine(drawto, from_sx, from_sy, to_sx, from_sy);
4088   DrawSimpleWhiteLine(drawto, to_sx, from_sy, to_sx, to_sy);
4089   DrawSimpleWhiteLine(drawto, to_sx, to_sy, from_sx, to_sy);
4090   DrawSimpleWhiteLine(drawto, from_sx, to_sy, from_sx, from_sy);
4091
4092   if (from_x == to_x && from_y == to_y)
4093     MarkTileDirty(from_x/2, from_y/2);
4094   else
4095     redraw_mask |= REDRAW_FIELD;
4096 }
4097
4098 static void SelectArea(int from_x, int from_y, int to_x, int to_y,
4099                        int element, boolean change_level)
4100 {
4101   if (element == -1 || change_level)
4102     DrawBox(from_x, from_y, to_x, to_y, -1, FALSE);
4103   else
4104     DrawAreaBorder(from_x, from_y, to_x, to_y);
4105 }
4106
4107 /* values for CopyBrushExt() */
4108 #define CB_AREA_TO_BRUSH        0
4109 #define CB_BRUSH_TO_CURSOR      1
4110 #define CB_BRUSH_TO_LEVEL       2
4111 #define CB_DELETE_OLD_CURSOR    3
4112
4113 static void CopyBrushExt(int from_x, int from_y, int to_x, int to_y,
4114                          int button, int mode)
4115 {
4116   static short brush_buffer[MAX_ED_FIELDX][MAX_ED_FIELDY];
4117   static int brush_width, brush_height;
4118   static int last_cursor_x = -1, last_cursor_y = -1;
4119   static boolean delete_old_brush;
4120   int new_element = BUTTON_ELEMENT(button);
4121   int x, y;
4122
4123   if (mode == CB_DELETE_OLD_CURSOR && !delete_old_brush)
4124     return;
4125
4126   if (mode == CB_AREA_TO_BRUSH)
4127   {
4128     int from_lx, from_ly;
4129
4130     if (from_x > to_x)
4131       swap_numbers(&from_x, &to_x);
4132
4133     if (from_y > to_y)
4134       swap_numbers(&from_y, &to_y);
4135
4136     brush_width = to_x - from_x + 1;
4137     brush_height = to_y - from_y + 1;
4138
4139     from_lx = from_x + level_xpos;
4140     from_ly = from_y + level_ypos;
4141
4142     for (y=0; y<brush_height; y++)
4143     {
4144       for (x=0; x<brush_width; x++)
4145       {
4146         brush_buffer[x][y] = Feld[from_lx + x][from_ly + y];
4147
4148         if (button != 1)
4149           DrawLineElement(from_x + x, from_y + y, new_element, TRUE);
4150       }
4151     }
4152
4153     if (button != 1)
4154       CopyLevelToUndoBuffer(UNDO_IMMEDIATE);
4155
4156     delete_old_brush = FALSE;
4157   }
4158   else if (mode == CB_BRUSH_TO_CURSOR || mode == CB_DELETE_OLD_CURSOR ||
4159            mode == CB_BRUSH_TO_LEVEL)
4160   {
4161     int cursor_x = (mode == CB_DELETE_OLD_CURSOR ? last_cursor_x : from_x);
4162     int cursor_y = (mode == CB_DELETE_OLD_CURSOR ? last_cursor_y : from_y);
4163     int cursor_from_x = cursor_x - brush_width / 2;
4164     int cursor_from_y = cursor_y - brush_height / 2;
4165     int border_from_x = cursor_x, border_from_y = cursor_y;
4166     int border_to_x = cursor_x, border_to_y = cursor_y;
4167
4168     if (mode != CB_DELETE_OLD_CURSOR && delete_old_brush)
4169       CopyBrushExt(0, 0, 0, 0, 0, CB_DELETE_OLD_CURSOR);
4170
4171     if (!IN_ED_FIELD(cursor_x, cursor_y) ||
4172         !IN_LEV_FIELD(cursor_x + level_xpos, cursor_y + level_ypos))
4173     {
4174       delete_old_brush = FALSE;
4175       return;
4176     }
4177
4178     for (y=0; y<brush_height; y++)
4179     {
4180       for (x=0; x<brush_width; x++)
4181       {
4182         int sx = cursor_from_x + x;
4183         int sy = cursor_from_y + y;
4184         int lx = sx + level_xpos;
4185         int ly = sy + level_ypos;
4186         boolean change_level = (mode == CB_BRUSH_TO_LEVEL);
4187         int element = (mode == CB_DELETE_OLD_CURSOR ? -1 :
4188                        mode == CB_BRUSH_TO_CURSOR || button == 1 ?
4189                        brush_buffer[x][y] : new_element);
4190
4191         if (IN_ED_FIELD(sx, sy) && IN_LEV_FIELD(lx, ly))
4192         {
4193           if (sx < border_from_x)
4194             border_from_x = sx;
4195           else if (sx > border_to_x)
4196             border_to_x = sx;
4197           if (sy < border_from_y)
4198             border_from_y = sy;
4199           else if (sy > border_to_y)
4200             border_to_y = sy;
4201
4202           DrawLineElement(sx, sy, element, change_level);
4203         }
4204       }
4205     }
4206
4207     if (mode != CB_DELETE_OLD_CURSOR)
4208       DrawAreaBorder(border_from_x, border_from_y, border_to_x, border_to_y);
4209
4210     last_cursor_x = cursor_x;
4211     last_cursor_y = cursor_y;
4212     delete_old_brush = TRUE;
4213   }
4214 }
4215
4216 static void CopyAreaToBrush(int from_x, int from_y, int to_x, int to_y,
4217                             int button)
4218 {
4219   CopyBrushExt(from_x, from_y, to_x, to_y, button, CB_AREA_TO_BRUSH);
4220 }
4221
4222 static void CopyBrushToLevel(int x, int y, int button)
4223 {
4224   CopyBrushExt(x, y, 0, 0, button, CB_BRUSH_TO_LEVEL);
4225 }
4226
4227 static void CopyBrushToCursor(int x, int y)
4228 {
4229   CopyBrushExt(x, y, 0, 0, 0, CB_BRUSH_TO_CURSOR);
4230 }
4231
4232 static void DeleteBrushFromCursor()
4233 {
4234   CopyBrushExt(0, 0, 0, 0, 0, CB_DELETE_OLD_CURSOR);
4235 }
4236
4237 static void FloodFill(int from_x, int from_y, int fill_element)
4238 {
4239   int i,x,y;
4240   int old_element;
4241   static int check[4][2] = { {-1,0}, {0,-1}, {1,0}, {0,1} };
4242   static int safety = 0;
4243
4244   /* check if starting field still has the desired content */
4245   if (Feld[from_x][from_y] == fill_element)
4246     return;
4247
4248   safety++;
4249
4250   if (safety > lev_fieldx*lev_fieldy)
4251     Error(ERR_EXIT, "Something went wrong in 'FloodFill()'. Please debug.");
4252
4253   old_element = Feld[from_x][from_y];
4254   Feld[from_x][from_y] = fill_element;
4255
4256   for(i=0;i<4;i++)
4257   {
4258     x = from_x + check[i][0];
4259     y = from_y + check[i][1];
4260
4261     if (IN_LEV_FIELD(x,y) && Feld[x][y] == old_element)
4262       FloodFill(x, y, fill_element);
4263   }
4264
4265   safety--;
4266 }
4267
4268 /* values for DrawLevelText() modes */
4269 #define TEXT_INIT               0
4270 #define TEXT_SETCURSOR          1
4271 #define TEXT_WRITECHAR          2
4272 #define TEXT_BACKSPACE          3
4273 #define TEXT_NEWLINE            4
4274 #define TEXT_END                5
4275 #define TEXT_QUERY_TYPING       6
4276
4277 static int DrawLevelText(int sx, int sy, char letter, int mode)
4278 {
4279   static short delete_buffer[MAX_LEV_FIELDX];
4280   static int start_sx, start_sy;
4281   static int last_sx, last_sy;
4282   static boolean typing = FALSE;
4283   int letter_element = EL_CHAR_ASCII0 + letter;
4284   int lx = 0, ly = 0;
4285
4286   /* map lower case letters to upper case and convert special characters */
4287   if (letter >= 'a' && letter <= 'z')
4288     letter_element = EL_CHAR_ASCII0 + letter + (int)('A' - 'a');
4289   else if (letter == 'ä' || letter == 'Ä')
4290     letter_element = EL_CHAR_AUMLAUT;
4291   else if (letter == 'ö' || letter == 'Ö')
4292     letter_element = EL_CHAR_OUMLAUT;
4293   else if (letter == 'ü' || letter == 'Ü')
4294     letter_element = EL_CHAR_UUMLAUT;
4295   else if (letter == '^')
4296     letter_element = EL_CHAR_COPYRIGHT;
4297   else
4298     letter_element = EL_CHAR_ASCII0 + letter;
4299
4300   if (mode != TEXT_INIT)
4301   {
4302     if (!typing)
4303       return FALSE;
4304
4305     if (mode != TEXT_SETCURSOR)
4306     {
4307       sx = last_sx;
4308       sy = last_sy;
4309     }
4310
4311     lx = last_sx + level_xpos;
4312     ly = last_sy + level_ypos;
4313   }
4314
4315   switch (mode)
4316   {
4317     case TEXT_INIT:
4318       if (typing)
4319         DrawLevelText(0, 0, 0, TEXT_END);
4320
4321       typing = TRUE;
4322       start_sx = last_sx = sx;
4323       start_sy = last_sy = sy;
4324       DrawLevelText(sx, sy, 0, TEXT_SETCURSOR);
4325       break;
4326
4327     case TEXT_SETCURSOR:
4328       DrawMiniElement(last_sx, last_sy, Feld[lx][ly]);
4329       DrawAreaBorder(sx, sy, sx, sy);
4330       last_sx = sx;
4331       last_sy = sy;
4332       break;
4333
4334     case TEXT_WRITECHAR:
4335       if (letter_element >= EL_CHAR_START && letter_element <= EL_CHAR_END)
4336       {
4337         delete_buffer[sx - start_sx] = Feld[lx][ly];
4338         Feld[lx][ly] = letter_element;
4339
4340         if (sx + 1 < ed_fieldx && lx + 1 < lev_fieldx)
4341           DrawLevelText(sx + 1, sy, 0, TEXT_SETCURSOR);
4342         else if (sy + 1 < ed_fieldy && ly + 1 < lev_fieldy)
4343           DrawLevelText(start_sx, sy + 1, 0, TEXT_SETCURSOR);
4344         else
4345           DrawLevelText(0, 0, 0, TEXT_END);
4346       }
4347       break;
4348
4349     case TEXT_BACKSPACE:
4350       if (sx > start_sx)
4351       {
4352         Feld[lx - 1][ly] = delete_buffer[sx - start_sx - 1];
4353         DrawMiniElement(sx - 1, sy, Feld[lx - 1][ly]);
4354         DrawLevelText(sx - 1, sy, 0, TEXT_SETCURSOR);
4355       }
4356       break;
4357
4358     case TEXT_NEWLINE:
4359       if (sy + 1 < ed_fieldy - 1 && ly + 1 < lev_fieldy - 1)
4360         DrawLevelText(start_sx, sy + 1, 0, TEXT_SETCURSOR);
4361       else
4362         DrawLevelText(0, 0, 0, TEXT_END);
4363       break;
4364
4365     case TEXT_END:
4366       CopyLevelToUndoBuffer(UNDO_IMMEDIATE);
4367       DrawMiniElement(sx, sy, Feld[lx][ly]);
4368       typing = FALSE;
4369       break;
4370
4371     case TEXT_QUERY_TYPING:
4372       break;
4373
4374     default:
4375       break;
4376   }
4377
4378   return typing;
4379 }
4380
4381 static void SetTextCursor(int unused_sx, int unused_sy, int sx, int sy,
4382                           int element, boolean change_level)
4383 {
4384   int lx = sx + level_xpos;
4385   int ly = sy + level_ypos;
4386
4387   if (element == -1)
4388     DrawMiniElement(sx, sy, Feld[lx][ly]);
4389   else
4390     DrawAreaBorder(sx, sy, sx, sy);
4391 }
4392
4393 static void CopyLevelToUndoBuffer(int mode)
4394 {
4395   static boolean accumulated_undo = FALSE;
4396   boolean new_undo_buffer_position = TRUE;
4397   int last_border_element;
4398   int x, y;
4399
4400   switch (mode)
4401   {
4402     case UNDO_IMMEDIATE:
4403       accumulated_undo = FALSE;
4404       break;
4405
4406     case UNDO_ACCUMULATE:
4407       if (accumulated_undo)
4408         new_undo_buffer_position = FALSE;
4409       accumulated_undo = TRUE;
4410       break;
4411
4412     default:
4413       break;
4414   }
4415
4416   if (new_undo_buffer_position)
4417   {
4418     /* new position in undo buffer ring */
4419     undo_buffer_position = (undo_buffer_position + 1) % NUM_UNDO_STEPS;
4420
4421     if (undo_buffer_steps < NUM_UNDO_STEPS - 1)
4422       undo_buffer_steps++;
4423   }
4424
4425   for(x=0; x<lev_fieldx; x++)
4426     for(y=0; y<lev_fieldy; y++)
4427       UndoBuffer[undo_buffer_position][x][y] = Feld[x][y];
4428
4429   /* check if drawing operation forces change of border style */
4430   last_border_element = BorderElement;
4431   SetBorderElement();
4432   if (BorderElement != last_border_element)
4433     DrawMiniLevel(ed_fieldx, ed_fieldy, level_xpos, level_ypos);
4434
4435 #if 0
4436 #ifdef DEBUG
4437   printf("level saved to undo buffer\n");
4438 #endif
4439 #endif
4440 }
4441
4442 static void RandomPlacement(int new_element)
4443 {
4444   static boolean free_position[MAX_LEV_FIELDX][MAX_LEV_FIELDY];
4445   int num_free_positions;
4446   int num_percentage;
4447   int num_elements;
4448   int x, y;
4449
4450   /* determine number of free positions for the new elements */
4451   /* (maybe this statement should be formatted a bit more readable...) */
4452   num_free_positions = 0;
4453   for (x=0; x<lev_fieldx; x++)
4454     for (y=0; y<lev_fieldy; y++)
4455       if ((free_position[x][y] =
4456            ((random_placement_background_restricted &&
4457              Feld[x][y] == random_placement_background_element) ||
4458             (!random_placement_background_restricted &&
4459              Feld[x][y] != new_element))) == TRUE)
4460         num_free_positions++;
4461
4462   /* determine number of new elements to place there */
4463   num_percentage = num_free_positions * random_placement_value / 100;
4464   num_elements = (random_placement_method == RANDOM_USE_PERCENTAGE ?
4465                   num_percentage : random_placement_value);
4466
4467   /* if not more free positions than elements to place, fill whole level */
4468   if (num_elements >= num_free_positions)
4469   {
4470     for (x=0; x<lev_fieldx; x++)
4471       for (y=0; y<lev_fieldy; y++)
4472         Feld[x][y] = new_element;
4473
4474     DrawMiniLevel(ed_fieldx, ed_fieldy, level_xpos, level_ypos);
4475     CopyLevelToUndoBuffer(UNDO_IMMEDIATE);
4476     return;
4477   }
4478
4479   while (num_elements > 0)
4480   {
4481     x = RND(lev_fieldx);
4482     y = RND(lev_fieldy);
4483
4484     /* don't place element at the same position twice */
4485     if (free_position[x][y])
4486     {
4487       free_position[x][y] = FALSE;
4488       Feld[x][y] = new_element;
4489       num_elements--;
4490     }
4491   }
4492
4493   DrawMiniLevel(ed_fieldx, ed_fieldy, level_xpos, level_ypos);
4494   CopyLevelToUndoBuffer(UNDO_IMMEDIATE);
4495 }
4496
4497 void WrapLevel(int dx, int dy)
4498 {
4499   int wrap_dx = lev_fieldx - dx;
4500   int wrap_dy = lev_fieldy - dy;
4501   int x, y;
4502
4503   for(x=0; x<lev_fieldx; x++)
4504     for(y=0; y<lev_fieldy; y++)
4505       FieldBackup[x][y] = Feld[x][y];
4506
4507   for(x=0; x<lev_fieldx; x++)
4508     for(y=0; y<lev_fieldy; y++)
4509       Feld[x][y] =
4510         FieldBackup[(x + wrap_dx) % lev_fieldx][(y + wrap_dy) % lev_fieldy];
4511
4512   DrawMiniLevel(ed_fieldx, ed_fieldy, level_xpos, level_ypos);
4513   CopyLevelToUndoBuffer(UNDO_ACCUMULATE);
4514 }
4515
4516 static void HandleDrawingAreas(struct GadgetInfo *gi)
4517 {
4518   static boolean started_inside_drawing_area = FALSE;
4519   int id = gi->custom_id;
4520   boolean button_press_event;
4521   boolean button_release_event;
4522   boolean inside_drawing_area = !gi->event.off_borders;
4523   boolean draw_level = (id == GADGET_ID_DRAWING_LEVEL);
4524   int actual_drawing_function;
4525   int button = gi->event.button;
4526   int new_element = BUTTON_ELEMENT(button);
4527   int sx = gi->event.x, sy = gi->event.y;
4528   int min_sx = 0, min_sy = 0;
4529   int max_sx = gi->drawing.area_xsize - 1, max_sy = gi->drawing.area_ysize - 1;
4530   int lx = 0, ly = 0;
4531   int min_lx = 0, min_ly = 0;
4532   int max_lx = lev_fieldx - 1, max_ly = lev_fieldy - 1;
4533   int x, y;
4534
4535   /* handle info callback for each invocation of action callback */
4536   gi->callback_info(gi);
4537
4538   button_press_event = (gi->event.type == GD_EVENT_PRESSED);
4539   button_release_event = (gi->event.type == GD_EVENT_RELEASED);
4540
4541   /* make sure to stay inside drawing area boundaries */
4542   sx = (sx < min_sx ? min_sx : sx > max_sx ? max_sx : sx);
4543   sy = (sy < min_sy ? min_sy : sy > max_sy ? max_sy : sy);
4544
4545   if (draw_level)
4546   {
4547     /* get positions inside level field */
4548     lx = sx + level_xpos;
4549     ly = sy + level_ypos;
4550
4551     if (!IN_LEV_FIELD(lx, ly))
4552       inside_drawing_area = FALSE;
4553
4554     /* make sure to stay inside level field boundaries */
4555     lx = (lx < min_lx ? min_lx : lx > max_lx ? max_lx : lx);
4556     ly = (ly < min_ly ? min_ly : ly > max_ly ? max_ly : ly);
4557
4558     /* correct drawing area positions accordingly */
4559     sx = lx - level_xpos;
4560     sy = ly - level_ypos;
4561   }
4562
4563   if (button_press_event)
4564     started_inside_drawing_area = inside_drawing_area;
4565
4566   if (!started_inside_drawing_area)
4567     return;
4568
4569   if (!button && !button_release_event)
4570     return;
4571
4572   /* automatically switch to 'single item' drawing mode, if needed */
4573   actual_drawing_function =
4574     (draw_level ? drawing_function : GADGET_ID_SINGLE_ITEMS);
4575
4576   switch (actual_drawing_function)
4577   {
4578     case GADGET_ID_SINGLE_ITEMS:
4579       if (draw_level)
4580       {
4581         if (button_release_event)
4582         {
4583           CopyLevelToUndoBuffer(UNDO_IMMEDIATE);
4584
4585           if (edit_mode == ED_MODE_DRAWING && draw_with_brush &&
4586               !inside_drawing_area)
4587             DeleteBrushFromCursor();
4588         }
4589
4590         if (!button)
4591           break;
4592
4593         if (draw_with_brush)
4594         {
4595           if (!button_release_event)
4596             CopyBrushToLevel(sx, sy, button);
4597         }
4598         else if (new_element != Feld[lx][ly])
4599         {
4600           if (new_element == EL_PLAYER_1)
4601           {
4602             /* remove player at old position */
4603             for(y=0; y<lev_fieldy; y++)
4604             {
4605               for(x=0; x<lev_fieldx; x++)
4606               {
4607                 if (Feld[x][y] == EL_PLAYER_1)
4608                 {
4609                   Feld[x][y] = EL_EMPTY;
4610                   if (x - level_xpos >= 0 && x - level_xpos < ed_fieldx &&
4611                       y - level_ypos >= 0 && y - level_ypos < ed_fieldy)
4612                     DrawMiniElement(x - level_xpos, y - level_ypos,
4613                                     EL_EMPTY);
4614                 }
4615               }
4616             }
4617           }
4618
4619           Feld[lx][ly] = new_element;
4620           DrawMiniElement(sx, sy, new_element);
4621         }
4622       }
4623       else
4624       {
4625         DrawMiniGraphicExt(drawto,
4626                            gi->x + sx * MINI_TILEX,
4627                            gi->y + sy * MINI_TILEY,
4628                            el2edimg(new_element));
4629         DrawMiniGraphicExt(window,
4630                            gi->x + sx * MINI_TILEX,
4631                            gi->y + sy * MINI_TILEY,
4632                            el2edimg(new_element));
4633
4634         if (id == GADGET_ID_AMOEBA_CONTENT)
4635           level.amoeba_content = new_element;
4636         else if (id == GADGET_ID_CUSTOM_CHANGED &&
4637                  IS_CUSTOM_ELEMENT(properties_element))
4638         {
4639           int i = properties_element - EL_CUSTOM_START;
4640
4641           level.custom_element_successor[i] = new_element;
4642         }
4643         else if (id == GADGET_ID_RANDOM_BACKGROUND)
4644           random_placement_background_element = new_element;
4645         else if (id >= GADGET_ID_ELEM_CONTENT_0 &&
4646                  id <= GADGET_ID_ELEM_CONTENT_7)
4647           level.yam_content[id - GADGET_ID_ELEM_CONTENT_0][sx][sy] =
4648             new_element;
4649       }
4650       break;
4651
4652     case GADGET_ID_CONNECTED_ITEMS:
4653       {
4654         static int last_sx = -1;
4655         static int last_sy = -1;
4656
4657         if (button_release_event)
4658           CopyLevelToUndoBuffer(UNDO_IMMEDIATE);
4659
4660         if (button)
4661         {
4662           if (!button_press_event)
4663             DrawLine(last_sx, last_sy, sx, sy, new_element, TRUE);
4664
4665           last_sx = sx;
4666           last_sy = sy;
4667         }
4668       }
4669       break;
4670
4671     case GADGET_ID_LINE:
4672     case GADGET_ID_ARC:
4673     case GADGET_ID_RECTANGLE:
4674     case GADGET_ID_FILLED_BOX:
4675     case GADGET_ID_GRAB_BRUSH:
4676     case GADGET_ID_TEXT:
4677       {
4678         static int last_sx = -1;
4679         static int last_sy = -1;
4680         static int start_sx = -1;
4681         static int start_sy = -1;
4682         void (*draw_func)(int, int, int, int, int, boolean);
4683
4684         if (drawing_function == GADGET_ID_LINE)
4685           draw_func = DrawLine;
4686         else if (drawing_function == GADGET_ID_ARC)
4687           draw_func = DrawArc;
4688         else if (drawing_function == GADGET_ID_RECTANGLE)
4689           draw_func = DrawBox;
4690         else if (drawing_function == GADGET_ID_FILLED_BOX)
4691           draw_func = DrawFilledBox;
4692         else if (drawing_function == GADGET_ID_GRAB_BRUSH)
4693           draw_func = SelectArea;
4694         else /* (drawing_function == GADGET_ID_TEXT) */
4695           draw_func = SetTextCursor;
4696
4697         if (button_press_event)
4698         {
4699           draw_func(sx, sy, sx, sy, new_element, FALSE);
4700           start_sx = last_sx = sx;
4701           start_sy = last_sy = sy;
4702
4703           if (drawing_function == GADGET_ID_TEXT)
4704             DrawLevelText(0, 0, 0, TEXT_END);
4705         }
4706         else if (button_release_event)
4707         {
4708           draw_func(start_sx, start_sy, sx, sy, new_element, TRUE);
4709           if (drawing_function == GADGET_ID_GRAB_BRUSH)
4710           {
4711             CopyAreaToBrush(start_sx, start_sy, sx, sy, button);
4712             CopyBrushToCursor(sx, sy);
4713             ClickOnGadget(level_editor_gadget[GADGET_ID_SINGLE_ITEMS],
4714                           MB_LEFTBUTTON);
4715             draw_with_brush = TRUE;
4716           }
4717           else if (drawing_function == GADGET_ID_TEXT)
4718             DrawLevelText(sx, sy, 0, TEXT_INIT);
4719           else
4720             CopyLevelToUndoBuffer(UNDO_IMMEDIATE);
4721         }
4722         else if (last_sx != sx || last_sy != sy)
4723         {
4724           draw_func(start_sx, start_sy, last_sx, last_sy, -1, FALSE);
4725           draw_func(start_sx, start_sy, sx, sy, new_element, FALSE);
4726           last_sx = sx;
4727           last_sy = sy;
4728         }
4729       }
4730       break;
4731
4732     case GADGET_ID_FLOOD_FILL:
4733       if (button_press_event && Feld[lx][ly] != new_element)
4734       {
4735         FloodFill(lx, ly, new_element);
4736         DrawMiniLevel(ed_fieldx, ed_fieldy, level_xpos, level_ypos);
4737         CopyLevelToUndoBuffer(UNDO_IMMEDIATE);
4738       }
4739       break;
4740
4741     case GADGET_ID_PICK_ELEMENT:
4742       if (button_release_event)
4743         ClickOnGadget(level_editor_gadget[last_drawing_function],
4744                       MB_LEFTBUTTON);
4745       else
4746         PickDrawingElement(button, Feld[lx][ly]);
4747
4748       break;
4749
4750     default:
4751       break;
4752   }
4753 }
4754
4755 static void HandleCounterButtons(struct GadgetInfo *gi)
4756 {
4757   int gadget_id = gi->custom_id;
4758   int counter_id = gi->custom_type_id;
4759   int button = gi->event.button;
4760   int *counter_value = counterbutton_info[counter_id].value;
4761   int step = BUTTON_STEPSIZE(button) *
4762     (gadget_id == counterbutton_info[counter_id].gadget_id_down ? -1 : +1);
4763
4764   if (counter_id == ED_COUNTER_ID_SELECT_LEVEL)
4765   {
4766     boolean pressed = (gi->event.type == GD_EVENT_PRESSED);
4767     boolean released = (gi->event.type == GD_EVENT_RELEASED);
4768     boolean level_changed = LevelChanged();
4769
4770     if ((level_changed && pressed) || (!level_changed && released))
4771       return;
4772
4773     if (level_changed && !Request("Level has changed! Discard changes ?",
4774                                   REQ_ASK))
4775     {
4776       if (gadget_id == counterbutton_info[counter_id].gadget_id_text)
4777         ModifyEditorCounter(counter_id, *counter_value);
4778       return;
4779     }
4780   }
4781
4782   if (gadget_id == counterbutton_info[counter_id].gadget_id_text)
4783     *counter_value = gi->text.number_value;
4784   else
4785     ModifyEditorCounter(counter_id, *counter_value + step);
4786
4787   switch (counter_id)
4788   {
4789     case ED_COUNTER_ID_ELEM_CONTENT:
4790       DrawElementContentAreas();
4791       break;
4792
4793     case ED_COUNTER_ID_LEVEL_XSIZE:
4794     case ED_COUNTER_ID_LEVEL_YSIZE:
4795       lev_fieldx = level.fieldx;
4796       lev_fieldy = level.fieldy;
4797       break;
4798
4799     case ED_COUNTER_ID_SELECT_LEVEL:
4800       LoadLevel(level_nr);
4801       TapeErase();
4802       ResetUndoBuffer();
4803       DrawEditModeWindow();
4804       break;
4805
4806     default:
4807       break;
4808   }
4809 }
4810
4811 static void HandleTextInputGadgets(struct GadgetInfo *gi)
4812 {
4813   strcpy(textinput_info[gi->custom_type_id].value, gi->text.value);
4814 }
4815
4816 static void HandleSelectboxGadgets(struct GadgetInfo *gi)
4817 {
4818   int type_id = gi->custom_type_id;
4819
4820   *selectbox_info[type_id].index = gi->selectbox.index;
4821
4822 #if 0
4823   printf("Selected text value: '%s' [%d]\n",
4824          selectbox_info[type_id].options[gi->selectbox.index].text,
4825          selectbox_info[type_id].options[gi->selectbox.index].value);
4826 #endif
4827 }
4828
4829 static void HandleTextbuttonGadgets(struct GadgetInfo *gi)
4830 {
4831   if (gi->custom_type_id >= ED_TEXTBUTTON_ID_PROPERTIES_INFO &&
4832       gi->custom_type_id <= ED_TEXTBUTTON_ID_PROPERTIES_ADVANCED)
4833   {
4834     edit_mode_properties = gi->custom_type_id;
4835
4836     DrawPropertiesWindow();
4837   }
4838 }
4839
4840 static void HandleRadiobuttons(struct GadgetInfo *gi)
4841 {
4842   *radiobutton_info[gi->custom_type_id].value =
4843     radiobutton_info[gi->custom_type_id].checked_value;
4844 }
4845
4846 static void HandleCheckbuttons(struct GadgetInfo *gi)
4847 {
4848   int type_id = gi->custom_type_id;
4849
4850   *checkbutton_info[type_id].value ^= TRUE;
4851
4852   if (type_id >= ED_CHECKBUTTON_ID_CUSTOM_FIRST &&
4853       type_id <= ED_CHECKBUTTON_ID_CUSTOM_LAST)
4854     CopyCustomElementPropertiesToGame(properties_element);
4855 }
4856
4857 static void HandleControlButtons(struct GadgetInfo *gi)
4858 {
4859   int id = gi->custom_id;
4860   int button = gi->event.button;
4861   int step = BUTTON_STEPSIZE(button);
4862   int new_element = BUTTON_ELEMENT(button);
4863   int i, x, y;
4864
4865   if (edit_mode == ED_MODE_DRAWING && drawing_function == GADGET_ID_TEXT)
4866     DrawLevelText(0, 0, 0, TEXT_END);
4867
4868   if (id < ED_NUM_CTRL1_BUTTONS && id != GADGET_ID_PROPERTIES &&
4869       edit_mode != ED_MODE_DRAWING)
4870   {
4871     DrawDrawingWindow();
4872     edit_mode = ED_MODE_DRAWING;
4873   }
4874
4875   switch (id)
4876   {
4877     case GADGET_ID_SCROLL_LEFT:
4878       if (level_xpos >= 0)
4879       {
4880         if (lev_fieldx < ed_fieldx - 2)
4881           break;
4882
4883         level_xpos -= step;
4884         if (level_xpos < -1)
4885           level_xpos = -1;
4886         if (button == 1)
4887           ScrollMiniLevel(level_xpos, level_ypos, ED_SCROLL_RIGHT);
4888         else
4889           DrawMiniLevel(ed_fieldx, ed_fieldy, level_xpos, level_ypos);
4890
4891         ModifyGadget(level_editor_gadget[GADGET_ID_SCROLL_HORIZONTAL],
4892                      GDI_SCROLLBAR_ITEM_POSITION, level_xpos + 1, GDI_END);
4893       }
4894       break;
4895
4896     case GADGET_ID_SCROLL_RIGHT:
4897       if (level_xpos <= lev_fieldx - ed_fieldx)
4898       {
4899         if (lev_fieldx < ed_fieldx - 2)
4900           break;
4901
4902         level_xpos += step;
4903         if (level_xpos > lev_fieldx - ed_fieldx + 1)
4904           level_xpos = lev_fieldx - ed_fieldx + 1;
4905         if (button == 1)
4906           ScrollMiniLevel(level_xpos, level_ypos, ED_SCROLL_LEFT);
4907         else
4908           DrawMiniLevel(ed_fieldx, ed_fieldy, level_xpos, level_ypos);
4909
4910         ModifyGadget(level_editor_gadget[GADGET_ID_SCROLL_HORIZONTAL],
4911                      GDI_SCROLLBAR_ITEM_POSITION, level_xpos + 1, GDI_END);
4912       }
4913       break;
4914
4915     case GADGET_ID_SCROLL_UP:
4916       if (level_ypos >= 0)
4917       {
4918         if (lev_fieldy < ed_fieldy - 2)
4919           break;
4920
4921         level_ypos -= step;
4922         if (level_ypos < -1)
4923           level_ypos = -1;
4924         if (button == 1)
4925           ScrollMiniLevel(level_xpos, level_ypos, ED_SCROLL_DOWN);
4926         else
4927           DrawMiniLevel(ed_fieldx, ed_fieldy, level_xpos, level_ypos);
4928
4929         ModifyGadget(level_editor_gadget[GADGET_ID_SCROLL_VERTICAL],
4930                      GDI_SCROLLBAR_ITEM_POSITION, level_ypos + 1, GDI_END);
4931       }
4932       break;
4933
4934     case GADGET_ID_SCROLL_DOWN:
4935       if (level_ypos <= lev_fieldy - ed_fieldy)
4936       {
4937         if (lev_fieldy < ed_fieldy - 2)
4938           break;
4939
4940         level_ypos += step;
4941         if (level_ypos > lev_fieldy - ed_fieldy + 1)
4942           level_ypos = lev_fieldy - ed_fieldy + 1;
4943         if (button == 1)
4944           ScrollMiniLevel(level_xpos, level_ypos, ED_SCROLL_UP);
4945         else
4946           DrawMiniLevel(ed_fieldx, ed_fieldy, level_xpos, level_ypos);
4947
4948         ModifyGadget(level_editor_gadget[GADGET_ID_SCROLL_VERTICAL],
4949                      GDI_SCROLLBAR_ITEM_POSITION, level_ypos + 1, GDI_END);
4950       }
4951       break;
4952
4953     case GADGET_ID_SCROLL_HORIZONTAL:
4954       level_xpos = gi->event.item_position - 1;
4955       DrawMiniLevel(ed_fieldx, ed_fieldy, level_xpos, level_ypos);
4956       break;
4957
4958     case GADGET_ID_SCROLL_VERTICAL:
4959       level_ypos = gi->event.item_position - 1;
4960       DrawMiniLevel(ed_fieldx, ed_fieldy, level_xpos, level_ypos);
4961       break;
4962
4963     case GADGET_ID_SCROLL_LIST_UP:
4964     case GADGET_ID_SCROLL_LIST_DOWN:
4965     case GADGET_ID_SCROLL_LIST_VERTICAL:
4966       if (id == GADGET_ID_SCROLL_LIST_VERTICAL)
4967         element_shift = gi->event.item_position * ED_ELEMENTLIST_BUTTONS_HORIZ;
4968       else
4969       {
4970         step *= (id == GADGET_ID_SCROLL_LIST_UP ? -1 : +1);
4971         element_shift += step * ED_ELEMENTLIST_BUTTONS_HORIZ;
4972
4973         if (element_shift < 0)
4974           element_shift = 0;
4975         if (element_shift > num_editor_elements - ED_NUM_ELEMENTLIST_BUTTONS)
4976           element_shift = num_editor_elements - ED_NUM_ELEMENTLIST_BUTTONS;
4977
4978         ModifyGadget(level_editor_gadget[GADGET_ID_SCROLL_LIST_VERTICAL],
4979                      GDI_SCROLLBAR_ITEM_POSITION,
4980                      element_shift / ED_ELEMENTLIST_BUTTONS_HORIZ, GDI_END);
4981       }
4982
4983       for (i=0; i<ED_NUM_ELEMENTLIST_BUTTONS; i++)
4984       {
4985         int gadget_id = GADGET_ID_ELEMENTLIST_FIRST + i;
4986         struct GadgetInfo *gi = level_editor_gadget[gadget_id];
4987         struct GadgetDesign *gd = &gi->deco.design;
4988         int element = editor_elements[element_shift + i];
4989
4990         UnmapGadget(gi);
4991         getMiniGraphicSource(el2edimg(element), &gd->bitmap, &gd->x, &gd->y);
4992         ModifyGadget(gi, GDI_INFO_TEXT, getElementInfoText(element), GDI_END);
4993         MapGadget(gi);
4994       }
4995       break;
4996
4997     case GADGET_ID_WRAP_LEFT:
4998       WrapLevel(-step, 0);
4999       break;
5000
5001     case GADGET_ID_WRAP_RIGHT:
5002       WrapLevel(step, 0);
5003       break;
5004
5005     case GADGET_ID_WRAP_UP:
5006       WrapLevel(0, -step);
5007       break;
5008
5009     case GADGET_ID_WRAP_DOWN:
5010       WrapLevel(0, step);
5011       break;
5012
5013     case GADGET_ID_SINGLE_ITEMS:
5014     case GADGET_ID_CONNECTED_ITEMS:
5015     case GADGET_ID_LINE:
5016     case GADGET_ID_ARC:
5017     case GADGET_ID_TEXT:
5018     case GADGET_ID_RECTANGLE:
5019     case GADGET_ID_FILLED_BOX:
5020     case GADGET_ID_FLOOD_FILL:
5021     case GADGET_ID_GRAB_BRUSH:
5022     case GADGET_ID_PICK_ELEMENT:
5023       last_drawing_function = drawing_function;
5024       drawing_function = id;
5025       draw_with_brush = FALSE;
5026       break;
5027
5028     case GADGET_ID_RANDOM_PLACEMENT:
5029       RandomPlacement(new_element);
5030       break;
5031
5032     case GADGET_ID_PROPERTIES:
5033       if (edit_mode != ED_MODE_PROPERTIES)
5034       {
5035         properties_element = new_element;
5036         DrawPropertiesWindow();
5037         edit_mode = ED_MODE_PROPERTIES;
5038       }
5039       else
5040       {
5041         DrawDrawingWindow();
5042         edit_mode = ED_MODE_DRAWING;
5043       }
5044       break;
5045
5046     case GADGET_ID_UNDO:
5047       if (undo_buffer_steps == 0)
5048       {
5049         Request("Undo buffer empty !", REQ_CONFIRM);
5050         break;
5051       }
5052
5053       undo_buffer_position =
5054         (undo_buffer_position - 1 + NUM_UNDO_STEPS) % NUM_UNDO_STEPS;
5055       undo_buffer_steps--;
5056
5057       for(x=0; x<lev_fieldx; x++)
5058         for(y=0; y<lev_fieldy; y++)
5059           Feld[x][y] = UndoBuffer[undo_buffer_position][x][y];
5060       DrawMiniLevel(ed_fieldx, ed_fieldy, level_xpos,level_ypos);
5061       break;
5062
5063     case GADGET_ID_INFO:
5064       if (edit_mode != ED_MODE_INFO)
5065       {
5066         DrawLevelInfoWindow();
5067         edit_mode = ED_MODE_INFO;
5068       }
5069       else
5070       {
5071         DrawDrawingWindow();
5072         edit_mode = ED_MODE_DRAWING;
5073       }
5074       break;
5075
5076     case GADGET_ID_CLEAR:
5077       for(x=0; x<MAX_LEV_FIELDX; x++)
5078         for(y=0; y<MAX_LEV_FIELDY; y++)
5079           Feld[x][y] = (button == 1 ? EL_EMPTY : new_element);
5080       CopyLevelToUndoBuffer(GADGET_ID_CLEAR);
5081
5082       DrawMiniLevel(ed_fieldx, ed_fieldy, level_xpos, level_ypos);
5083       break;
5084
5085     case GADGET_ID_SAVE:
5086       if (leveldir_current->readonly)
5087       {
5088         Request("This level is read only !", REQ_CONFIRM);
5089         break;
5090       }
5091
5092       if (!LevelContainsPlayer)
5093         Request("No Level without Gregor Mc Duffin please !", REQ_CONFIRM);
5094       else
5095       {
5096         if (Request("Save this level and kill the old ?", REQ_ASK))
5097         {
5098           CopyPlayfield(Feld, Ur);
5099
5100           SaveLevel(level_nr);
5101         }
5102       }
5103       break;
5104
5105     case GADGET_ID_TEST:
5106       if (!LevelContainsPlayer)
5107         Request("No Level without Gregor Mc Duffin please !", REQ_CONFIRM);
5108       else
5109       {
5110         if (LevelChanged())
5111           level.game_version = GAME_VERSION_ACTUAL;
5112
5113         CopyPlayfield(Ur, FieldBackup);
5114         CopyPlayfield(Feld, Ur);
5115
5116         UnmapLevelEditorGadgets();
5117         UndrawSpecialEditorDoor();
5118
5119         CloseDoor(DOOR_CLOSE_ALL);
5120
5121         DrawCompleteVideoDisplay();
5122
5123         if (setup.autorecord)
5124           TapeStartRecording();
5125
5126         level_editor_test_game = TRUE;
5127         game_status = GAME_MODE_PLAYING;
5128
5129         InitGame();
5130       }
5131       break;
5132
5133     case GADGET_ID_EXIT:
5134       RequestExitLevelEditor(TRUE);     /* if level has changed, ask user */
5135       break;
5136
5137     default:
5138       if (id >= GADGET_ID_ELEMENTLIST_FIRST &&
5139           id <= GADGET_ID_ELEMENTLIST_LAST)
5140       {
5141         int element_position = id - GADGET_ID_ELEMENTLIST_FIRST;
5142         int new_element = editor_elements[element_position + element_shift];
5143
5144         PickDrawingElement(button, new_element);
5145
5146 #if 1
5147         if (!stick_element_properties_window)
5148 #else
5149         if (!HAS_CONTENT(properties_element) ||
5150             !stick_element_properties_window)
5151 #endif
5152         {
5153           properties_element = new_element;
5154           if (edit_mode == ED_MODE_PROPERTIES)
5155             DrawPropertiesWindow();
5156         }
5157
5158         if (drawing_function == GADGET_ID_PICK_ELEMENT)
5159           ClickOnGadget(level_editor_gadget[last_drawing_function],
5160                         MB_LEFTBUTTON);
5161       }
5162 #ifdef DEBUG
5163       else if (gi->event.type == GD_EVENT_PRESSED)
5164         printf("default: HandleControlButtons: GD_EVENT_PRESSED(%d)\n", id);
5165       else if (gi->event.type == GD_EVENT_RELEASED)
5166         printf("default: HandleControlButtons: GD_EVENT_RELEASED(%d)\n", id);
5167       else if (gi->event.type == GD_EVENT_MOVING)
5168         printf("default: HandleControlButtons: GD_EVENT_MOVING(%d)\n", id);
5169       else
5170         printf("default: HandleControlButtons: ? (id == %d)\n", id);
5171 #endif
5172       break;
5173   }
5174 }
5175
5176 void HandleLevelEditorKeyInput(Key key)
5177 {
5178   char letter = getCharFromKey(key);
5179   int button = MB_LEFTBUTTON;
5180
5181   if (drawing_function == GADGET_ID_TEXT &&
5182       DrawLevelText(0, 0, 0, TEXT_QUERY_TYPING) == TRUE)
5183   {
5184     if (letter)
5185       DrawLevelText(0, 0, letter, TEXT_WRITECHAR);
5186     else if (key == KSYM_Delete || key == KSYM_BackSpace)
5187       DrawLevelText(0, 0, 0, TEXT_BACKSPACE);
5188     else if (key == KSYM_Return)
5189       DrawLevelText(0, 0, 0, TEXT_NEWLINE);
5190     else if (key == KSYM_Escape)
5191       DrawLevelText(0, 0, 0, TEXT_END);
5192   }
5193   else if (button_status == MB_RELEASED)
5194   {
5195     int i, id = GADGET_ID_NONE;
5196
5197     switch (key)
5198     {
5199       case KSYM_Left:
5200         id = GADGET_ID_SCROLL_LEFT;
5201         break;
5202       case KSYM_Right:
5203         id = GADGET_ID_SCROLL_RIGHT;
5204         break;
5205       case KSYM_Up:
5206         id = GADGET_ID_SCROLL_UP;
5207         break;
5208       case KSYM_Down:
5209         id = GADGET_ID_SCROLL_DOWN;
5210         break;
5211       case KSYM_Page_Up:
5212         id = GADGET_ID_SCROLL_LIST_UP;
5213         button = MB_RIGHTBUTTON;
5214         break;
5215       case KSYM_Page_Down:
5216         id = GADGET_ID_SCROLL_LIST_DOWN;
5217         button = MB_RIGHTBUTTON;
5218         break;
5219
5220       case KSYM_Escape:
5221         if (edit_mode == ED_MODE_DRAWING)
5222         {
5223           RequestExitLevelEditor(setup.ask_on_escape);
5224         }
5225         else
5226         {
5227           DrawDrawingWindow();
5228           edit_mode = ED_MODE_DRAWING;
5229         }
5230         break;
5231
5232       default:
5233         break;
5234     }
5235
5236     if (id != GADGET_ID_NONE)
5237       ClickOnGadget(level_editor_gadget[id], button);
5238     else if (letter == '.')
5239       ClickOnGadget(level_editor_gadget[GADGET_ID_SINGLE_ITEMS], button);
5240     else if (key == KSYM_Return || key == setup.shortcut.toggle_pause)
5241       ClickOnGadget(level_editor_gadget[GADGET_ID_TEST], button);
5242     else
5243       for (i=0; i<ED_NUM_CTRL_BUTTONS; i++)
5244         if (letter && letter == control_info[i].shortcut)
5245           if (!anyTextGadgetActive())
5246             ClickOnGadget(level_editor_gadget[i], button);
5247   }
5248 }
5249
5250 void HandleLevelEditorIdle()
5251 {
5252   static unsigned long action_delay = 0;
5253   unsigned long action_delay_value = GameFrameDelay;
5254   int xpos = 1, ypos = 2;
5255
5256   if (edit_mode != ED_MODE_PROPERTIES)
5257     return;
5258
5259   if (!DelayReached(&action_delay, action_delay_value))
5260     return;
5261
5262   DrawGraphicAnimationExt(drawto,
5263                           SX + xpos * TILEX,
5264                           SY + ypos * TILEY + MINI_TILEY / 2,
5265                           el2img(properties_element), -1, NO_MASKING);
5266
5267   MarkTileDirty(xpos, ypos);
5268   MarkTileDirty(xpos, ypos + 1);
5269
5270   FrameCounter++;       /* increase animation frame counter */
5271 }
5272
5273 void ClearEditorGadgetInfoText()
5274 {
5275   DrawBackground(INFOTEXT_XPOS, INFOTEXT_YPOS, INFOTEXT_XSIZE, INFOTEXT_YSIZE);
5276 }
5277
5278 void HandleEditorGadgetInfoText(void *ptr)
5279 {
5280   struct GadgetInfo *gi = (struct GadgetInfo *)ptr;
5281   char infotext[MAX_OUTPUT_LINESIZE + 1];
5282   char shortcut[MAX_OUTPUT_LINESIZE + 1];
5283   int max_infotext_len = getMaxInfoTextLength();
5284
5285   if (game_status != GAME_MODE_EDITOR)
5286     return;
5287
5288   ClearEditorGadgetInfoText();
5289
5290   if (gi->event.type == GD_EVENT_INFO_LEAVING)
5291     return;
5292
5293   /* misuse this function to delete brush cursor, if needed */
5294   if (edit_mode == ED_MODE_DRAWING && draw_with_brush)
5295     DeleteBrushFromCursor();
5296
5297   if (gi == NULL || gi->info_text == NULL)
5298     return;
5299
5300   strncpy(infotext, gi->info_text, max_infotext_len);
5301   infotext[max_infotext_len] = '\0';
5302
5303   if (gi->custom_id < ED_NUM_CTRL_BUTTONS)
5304   {
5305     int key = control_info[gi->custom_id].shortcut;
5306
5307     if (key)
5308     {
5309       if (gi->custom_id == GADGET_ID_SINGLE_ITEMS)      /* special case 1 */
5310         sprintf(shortcut, " ('.' or '%c')", key);
5311       else if (gi->custom_id == GADGET_ID_TEST)         /* special case 2 */
5312         sprintf(shortcut, " ('Enter' or 'Shift-%c')", key);
5313       else                                              /* normal case */
5314         sprintf(shortcut, " ('%s%c')",
5315                 (key >= 'A' && key <= 'Z' ? "Shift-" : ""), key);
5316
5317       if (strlen(infotext) + strlen(shortcut) <= max_infotext_len)
5318         strcat(infotext, shortcut);
5319     }
5320   }
5321
5322   DrawText(INFOTEXT_XPOS, INFOTEXT_YPOS, infotext, FONT_TEXT_2);
5323 }
5324
5325 static void HandleDrawingAreaInfo(struct GadgetInfo *gi)
5326 {
5327   static int start_lx, start_ly;
5328   char *infotext;
5329   int id = gi->custom_id;
5330   int sx = gi->event.x;
5331   int sy = gi->event.y;
5332   int lx = sx + level_xpos;
5333   int ly = sy + level_ypos;
5334   int min_sx = 0, min_sy = 0;
5335   int max_sx = gi->drawing.area_xsize - 1;
5336   int max_sy = gi->drawing.area_ysize - 1;
5337
5338   ClearEditorGadgetInfoText();
5339
5340   if (gi->event.type == GD_EVENT_INFO_LEAVING)
5341     return;
5342
5343   /* make sure to stay inside drawing area boundaries */
5344   sx = (sx < min_sx ? min_sx : sx > max_sx ? max_sx : sx);
5345   sy = (sy < min_sy ? min_sy : sy > max_sy ? max_sy : sy);
5346
5347   if (id == GADGET_ID_DRAWING_LEVEL)
5348   {
5349     if (button_status)
5350     {
5351       int min_lx = 0, min_ly = 0;
5352       int max_lx = lev_fieldx - 1, max_ly = lev_fieldy - 1;
5353
5354       /* get positions inside level field */
5355       lx = sx + level_xpos;
5356       ly = sy + level_ypos;
5357
5358       /* make sure to stay inside level field boundaries */
5359       lx = (lx < min_lx ? min_lx : lx > max_lx ? max_lx : lx);
5360       ly = (ly < min_ly ? min_ly : ly > max_ly ? max_ly : ly);
5361
5362       /* correct drawing area positions accordingly */
5363       sx = lx - level_xpos;
5364       sy = ly - level_ypos;
5365     }
5366
5367     if (IN_ED_FIELD(sx,sy) && IN_LEV_FIELD(lx, ly))
5368     {
5369       if (button_status)        /* if (gi->state == GD_BUTTON_PRESSED) */
5370       {
5371         if (gi->event.type == GD_EVENT_PRESSED)
5372         {
5373           start_lx = lx;
5374           start_ly = ly;
5375         }
5376
5377         switch (drawing_function)
5378         {
5379           case GADGET_ID_SINGLE_ITEMS:
5380             infotext = "Drawing single items";
5381             break;
5382           case GADGET_ID_CONNECTED_ITEMS:
5383             infotext = "Drawing connected items";
5384             break;
5385           case GADGET_ID_LINE:
5386             infotext = "Drawing line";
5387             break;
5388           case GADGET_ID_ARC:
5389             infotext = "Drawing arc";
5390             break;
5391           case GADGET_ID_TEXT:
5392             infotext = "Setting text cursor";
5393             break;
5394           case GADGET_ID_RECTANGLE:
5395             infotext = "Drawing rectangle";
5396             break;
5397           case GADGET_ID_FILLED_BOX:
5398             infotext = "Drawing filled box";
5399             break;
5400           case GADGET_ID_FLOOD_FILL:
5401             infotext = "Flood fill";
5402             break;
5403           case GADGET_ID_GRAB_BRUSH:
5404             infotext = "Grabbing brush";
5405             break;
5406           case GADGET_ID_PICK_ELEMENT:
5407             infotext = "Picking element";
5408             break;
5409
5410           default:
5411             infotext = "Drawing position";
5412             break;
5413         }
5414
5415         if (drawing_function == GADGET_ID_PICK_ELEMENT)
5416           DrawTextF(INFOTEXT_XPOS - SX, INFOTEXT_YPOS - SY, FONT_TEXT_2,
5417                     "%s: %d, %d", infotext, lx, ly);
5418         else
5419           DrawTextF(INFOTEXT_XPOS - SX, INFOTEXT_YPOS - SY, FONT_TEXT_2,
5420                     "%s: %d, %d", infotext,
5421                     ABS(lx - start_lx) + 1, ABS(ly - start_ly) + 1);
5422       }
5423       else if (drawing_function == GADGET_ID_PICK_ELEMENT)
5424         DrawTextF(INFOTEXT_XPOS - SX, INFOTEXT_YPOS - SY, FONT_TEXT_2,
5425                   "%s", getElementInfoText(Feld[lx][ly]));
5426       else
5427         DrawTextF(INFOTEXT_XPOS - SX, INFOTEXT_YPOS - SY, FONT_TEXT_2,
5428                   "Level position: %d, %d", lx, ly);
5429     }
5430
5431     /* misuse this function to draw brush cursor, if needed */
5432     if (edit_mode == ED_MODE_DRAWING && draw_with_brush && !button_status)
5433     {
5434       if (IN_ED_FIELD(sx, sy) && IN_LEV_FIELD(lx, ly))
5435         CopyBrushToCursor(sx, sy);
5436       else
5437         DeleteBrushFromCursor();
5438     }
5439   }
5440   else if (id == GADGET_ID_AMOEBA_CONTENT)
5441     DrawTextF(INFOTEXT_XPOS - SX, INFOTEXT_YPOS - SY, FONT_TEXT_2,
5442               "Amoeba content");
5443   else if (id == GADGET_ID_CUSTOM_CHANGED)
5444     DrawTextF(INFOTEXT_XPOS - SX, INFOTEXT_YPOS - SY, FONT_TEXT_2,
5445               "Next element after change");
5446   else if (id == GADGET_ID_RANDOM_BACKGROUND)
5447     DrawTextF(INFOTEXT_XPOS - SX, INFOTEXT_YPOS - SY, FONT_TEXT_2,
5448               "Random placement background");
5449   else
5450     DrawTextF(INFOTEXT_XPOS - SX, INFOTEXT_YPOS - SY, FONT_TEXT_2,
5451               "Content area %d position: %d, %d",
5452               id - GADGET_ID_ELEM_CONTENT_0 + 1, sx, sy);
5453 }
5454
5455 void RequestExitLevelEditor(boolean ask_if_level_has_changed)
5456 {
5457   if (!ask_if_level_has_changed ||
5458       !LevelChanged() ||
5459       Request("Level has changed! Exit without saving ?",
5460               REQ_ASK | REQ_STAY_OPEN))
5461   {
5462     CloseDoor(DOOR_CLOSE_1);
5463     /*
5464     CloseDoor(DOOR_CLOSE_ALL);
5465     */
5466     game_status = GAME_MODE_MAIN;
5467     DrawMainMenu();
5468   }
5469   else
5470   {
5471     CloseDoor(DOOR_CLOSE_1);
5472     BlitBitmap(bitmap_db_door, bitmap_db_door,
5473                DOOR_GFX_PAGEX2, DOOR_GFX_PAGEY1, DXSIZE,DYSIZE,
5474                DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1);
5475     OpenDoor(DOOR_OPEN_1);
5476   }
5477 }