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