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