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