+
+ return typing;
+}
+
+static void SetTextCursor(int unused_sx, int unused_sy, int sx, int sy,
+ int element, boolean change_level)
+{
+ int lx = sx + level_xpos;
+ int ly = sy + level_ypos;
+
+ if (element == -1)
+ DrawMiniElement(sx, sy, Feld[lx][ly]);
+ else
+ DrawAreaBorder(sx, sy, sx, sy);
+}
+
+static void CopyLevelToUndoBuffer(int mode)
+{
+ static boolean accumulated_undo = FALSE;
+ boolean new_undo_buffer_position = TRUE;
+ int last_border_element;
+ int x, y;
+
+ switch (mode)
+ {
+ case UNDO_IMMEDIATE:
+ accumulated_undo = FALSE;
+ break;
+
+ case UNDO_ACCUMULATE:
+ if (accumulated_undo)
+ new_undo_buffer_position = FALSE;
+ accumulated_undo = TRUE;
+ break;
+
+ default:
+ break;
+ }
+
+ if (new_undo_buffer_position)
+ {
+ /* new position in undo buffer ring */
+ undo_buffer_position = (undo_buffer_position + 1) % NUM_UNDO_STEPS;
+
+ if (undo_buffer_steps < NUM_UNDO_STEPS - 1)
+ undo_buffer_steps++;
+ }
+
+ for(x=0; x<lev_fieldx; x++)
+ for(y=0; y<lev_fieldy; y++)
+ UndoBuffer[undo_buffer_position][x][y] = Feld[x][y];
+
+ /* check if change of border style was forced by drawing operation */
+ last_border_element = BorderElement;
+ SetBorderElement();
+ if (BorderElement != last_border_element)
+ DrawMiniLevel(ed_fieldx, ed_fieldy, level_xpos, level_ypos);
+
+#if 0
+#ifdef DEBUG
+ printf("level saved to undo buffer\n");
+#endif
+#endif
+}
+
+static void RandomPlacement(int new_element)
+{
+ static boolean free_position[MAX_LEV_FIELDX][MAX_LEV_FIELDY];
+ int num_free_positions;
+ int num_percentage;
+ int num_elements;
+ int x, y;
+
+ /* determine number of free positions for the new elements */
+ /* (maybe this statement should be formatted a bit more readable...) */
+ num_free_positions = 0;
+ for (x=0; x<lev_fieldx; x++)
+ for (y=0; y<lev_fieldy; y++)
+ if ((free_position[x][y] =
+ ((random_placement_background_restricted &&
+ Feld[x][y] == random_placement_background_element) ||
+ (!random_placement_background_restricted &&
+ Feld[x][y] != new_element))) == TRUE)
+ num_free_positions++;
+
+ /* determine number of new elements to place there */
+ num_percentage = num_free_positions * random_placement_value / 100;
+ num_elements = (random_placement_method == RANDOM_USE_PERCENTAGE ?
+ num_percentage : random_placement_value);
+
+ /* if not more free positions than elements to place, fill whole level */
+ if (num_elements >= num_free_positions)
+ {
+ for (x=0; x<lev_fieldx; x++)
+ for (y=0; y<lev_fieldy; y++)
+ Feld[x][y] = new_element;
+
+ DrawMiniLevel(ed_fieldx, ed_fieldy, level_xpos, level_ypos);
+ CopyLevelToUndoBuffer(UNDO_IMMEDIATE);
+ return;
+ }
+
+ while (num_elements > 0)
+ {
+ x = RND(lev_fieldx);
+ y = RND(lev_fieldy);
+
+ /* don't place element at the same position twice */
+ if (free_position[x][y])
+ {
+ free_position[x][y] = FALSE;
+ Feld[x][y] = new_element;
+ num_elements--;
+ }
+ }
+
+ DrawMiniLevel(ed_fieldx, ed_fieldy, level_xpos, level_ypos);
+ CopyLevelToUndoBuffer(UNDO_IMMEDIATE);
+}
+
+void WrapLevel(int dx, int dy)
+{
+ int wrap_dx = lev_fieldx - dx;
+ int wrap_dy = lev_fieldy - dy;
+ int x, y;
+
+ for(x=0; x<lev_fieldx; x++)
+ for(y=0; y<lev_fieldy; y++)
+ FieldBackup[x][y] = Feld[x][y];
+
+ for(x=0; x<lev_fieldx; x++)
+ for(y=0; y<lev_fieldy; y++)
+ Feld[x][y] =
+ FieldBackup[(x + wrap_dx) % lev_fieldx][(y + wrap_dy) % lev_fieldy];
+
+ DrawMiniLevel(ed_fieldx, ed_fieldy, level_xpos, level_ypos);
+ CopyLevelToUndoBuffer(UNDO_ACCUMULATE);
+}
+
+static void HandleDrawingAreas(struct GadgetInfo *gi)
+{
+ static boolean started_inside_drawing_area = FALSE;
+ int id = gi->custom_id;
+ boolean button_press_event;
+ boolean button_release_event;
+ boolean inside_drawing_area = !gi->event.off_borders;
+ boolean draw_level = (id == GADGET_ID_DRAWING_LEVEL);
+ int actual_drawing_function;
+ int button = gi->event.button;
+ int new_element = BUTTON_ELEMENT(button);
+ int sx = gi->event.x, sy = gi->event.y;
+ int min_sx = 0, min_sy = 0;
+ int max_sx = gi->drawing.area_xsize - 1, max_sy = gi->drawing.area_ysize - 1;
+ int lx = 0, ly = 0;
+ int min_lx = 0, min_ly = 0;
+ int max_lx = lev_fieldx - 1, max_ly = lev_fieldy - 1;
+ int x, y;
+
+ /* handle info callback for each invocation of action callback */
+ gi->callback_info(gi);
+
+ /*
+ if (edit_mode != ED_MODE_DRAWING)
+ return;
+ */
+
+ button_press_event = (gi->event.type == GD_EVENT_PRESSED);
+ button_release_event = (gi->event.type == GD_EVENT_RELEASED);
+
+ /* make sure to stay inside drawing area boundaries */
+ sx = (sx < min_sx ? min_sx : sx > max_sx ? max_sx : sx);
+ sy = (sy < min_sy ? min_sy : sy > max_sy ? max_sy : sy);
+
+ if (draw_level)
+ {
+ /* get positions inside level field */
+ lx = sx + level_xpos;
+ ly = sy + level_ypos;
+
+ if (!IN_LEV_FIELD(lx, ly))
+ inside_drawing_area = FALSE;
+
+ /* make sure to stay inside level field boundaries */
+ lx = (lx < min_lx ? min_lx : lx > max_lx ? max_lx : lx);
+ ly = (ly < min_ly ? min_ly : ly > max_ly ? max_ly : ly);
+
+ /* correct drawing area positions accordingly */
+ sx = lx - level_xpos;
+ sy = ly - level_ypos;
+ }
+
+ if (button_press_event)
+ started_inside_drawing_area = inside_drawing_area;
+
+ if (!started_inside_drawing_area)
+ return;
+
+ if (!button && !button_release_event)
+ return;
+
+
+#if 0
+ if (button_release_event)
+ button = 0;
+#endif
+
+#if 0
+ if (!draw_level && drawing_function != GADGET_ID_SINGLE_ITEMS)
+ return;
+#endif
+
+ /* automatically switch to 'single item' drawing mode, if needed */
+ actual_drawing_function =
+ (draw_level ? drawing_function : GADGET_ID_SINGLE_ITEMS);
+
+ switch (actual_drawing_function)
+ {
+ case GADGET_ID_SINGLE_ITEMS:
+ if (draw_level)
+ {
+ if (button_release_event)
+ {
+ CopyLevelToUndoBuffer(UNDO_IMMEDIATE);
+
+ if (edit_mode == ED_MODE_DRAWING && draw_with_brush &&
+ !inside_drawing_area)
+ DeleteBrushFromCursor();
+ }
+
+ if (!button)
+ break;
+
+ if (draw_with_brush)
+ {
+ if (!button_release_event)
+ CopyBrushToLevel(sx, sy, button);
+ }
+ else if (new_element != Feld[lx][ly])
+ {
+ if (new_element == EL_SPIELFIGUR)
+ {
+ /* remove player at old position */
+ for(y=0; y<lev_fieldy; y++)
+ {
+ for(x=0; x<lev_fieldx; x++)
+ {
+ if (Feld[x][y] == EL_SPIELFIGUR || Feld[x][y] == EL_SPIELER1)
+ {
+ Feld[x][y] = EL_LEERRAUM;
+ if (x - level_xpos >= 0 && x - level_xpos < ed_fieldx &&
+ y - level_ypos >= 0 && y - level_ypos < ed_fieldy)
+ DrawMiniElement(x - level_xpos, y - level_ypos,
+ EL_LEERRAUM);
+ }
+ }
+ }
+ }
+
+ Feld[lx][ly] = new_element;
+ DrawMiniElement(sx, sy, new_element);
+ }
+ }
+ else
+ {
+ DrawMiniGraphicExt(drawto, gc,
+ gi->x + sx * MINI_TILEX,
+ gi->y + sy * MINI_TILEY,
+ el2gfx(new_element));
+ DrawMiniGraphicExt(window, gc,
+ gi->x + sx * MINI_TILEX,
+ gi->y + sy * MINI_TILEY,
+ el2gfx(new_element));
+
+ if (id == GADGET_ID_AMOEBA_CONTENT)
+ level.amoebe_inhalt = new_element;
+ else if (id == GADGET_ID_RANDOM_BACKGROUND)
+ random_placement_background_element = new_element;
+ else if (id >= GADGET_ID_ELEM_CONTENT_0 &&
+ id <= GADGET_ID_ELEM_CONTENT_7)
+ level.mampfer_inhalt[id - GADGET_ID_ELEM_CONTENT_0][sx][sy] =
+ new_element;
+ }
+ break;
+
+ case GADGET_ID_CONNECTED_ITEMS:
+ {
+ static int last_sx = -1;
+ static int last_sy = -1;
+
+ if (button_release_event)
+ CopyLevelToUndoBuffer(UNDO_IMMEDIATE);
+
+ if (button)
+ {
+ if (!button_press_event)
+ DrawLine(last_sx, last_sy, sx, sy, new_element, TRUE);
+
+ last_sx = sx;
+ last_sy = sy;
+ }
+ }
+ break;
+
+ case GADGET_ID_LINE:
+ case GADGET_ID_ARC:
+ case GADGET_ID_RECTANGLE:
+ case GADGET_ID_FILLED_BOX:
+ case GADGET_ID_GRAB_BRUSH:
+ case GADGET_ID_TEXT:
+ {
+ static int last_sx = -1;
+ static int last_sy = -1;
+ static int start_sx = -1;
+ static int start_sy = -1;
+ void (*draw_func)(int, int, int, int, int, boolean);
+
+ if (drawing_function == GADGET_ID_LINE)
+ draw_func = DrawLine;
+ else if (drawing_function == GADGET_ID_ARC)
+ draw_func = DrawArc;
+ else if (drawing_function == GADGET_ID_RECTANGLE)
+ draw_func = DrawRectangle;
+ else if (drawing_function == GADGET_ID_FILLED_BOX)
+ draw_func = DrawFilledBox;
+ else if (drawing_function == GADGET_ID_GRAB_BRUSH)
+ draw_func = SelectArea;
+ else /* (drawing_function == GADGET_ID_TEXT) */
+ draw_func = SetTextCursor;
+
+ if (button_press_event)
+ {
+ draw_func(sx, sy, sx, sy, new_element, FALSE);
+ start_sx = last_sx = sx;
+ start_sy = last_sy = sy;
+
+ if (drawing_function == GADGET_ID_TEXT)
+ DrawLevelText(0, 0, 0, TEXT_END);
+ }
+ else if (button_release_event)
+ {
+ draw_func(start_sx, start_sy, sx, sy, new_element, TRUE);
+ if (drawing_function == GADGET_ID_GRAB_BRUSH)
+ {
+ CopyAreaToBrush(start_sx, start_sy, sx, sy, button);
+ CopyBrushToCursor(sx, sy);
+ ClickOnGadget(level_editor_gadget[GADGET_ID_SINGLE_ITEMS],MB_LEFT);
+ draw_with_brush = TRUE;
+ }
+ else if (drawing_function == GADGET_ID_TEXT)
+ DrawLevelText(sx, sy, 0, TEXT_INIT);
+ else
+ CopyLevelToUndoBuffer(UNDO_IMMEDIATE);
+ }
+ else if (last_sx != sx || last_sy != sy)
+ {
+ draw_func(start_sx, start_sy, last_sx, last_sy, -1, FALSE);
+ draw_func(start_sx, start_sy, sx, sy, new_element, FALSE);
+ last_sx = sx;
+ last_sy = sy;
+ }
+ }
+ break;
+
+ case GADGET_ID_FLOOD_FILL:
+ if (button_press_event && Feld[lx][ly] != new_element)
+ {
+ FloodFill(lx, ly, new_element);
+ DrawMiniLevel(ed_fieldx, ed_fieldy, level_xpos, level_ypos);
+ CopyLevelToUndoBuffer(UNDO_IMMEDIATE);
+ }
+ break;
+
+ case GADGET_ID_PICK_ELEMENT:
+
+ /*
+ if (button_press_event)
+ PickDrawingElement(button, Feld[lx][ly]);
+ */
+
+ if (button_release_event)
+ ClickOnGadget(level_editor_gadget[last_drawing_function], MB_LEFT);
+ else
+ PickDrawingElement(button, Feld[lx][ly]);
+
+ break;
+
+ default:
+ break;
+ }
+}
+
+static void HandleCounterButtons(struct GadgetInfo *gi)
+{
+ int id = gi->custom_id;
+ int button = gi->event.button;
+ int step = (button == 1 ? 1 : button == 2 ? 5 : 10);
+
+ switch (id)
+ {
+ case GADGET_ID_ELEM_SCORE_DOWN:
+ case GADGET_ID_ELEM_SCORE_UP:
+ step *= (id == GADGET_ID_ELEM_SCORE_DOWN ? -1 : 1);
+ ModifyEditorCounter(ED_COUNTER_ID_ELEM_SCORE,
+ *gadget_elem_score_value + step);
+ break;
+ case GADGET_ID_ELEM_SCORE_TEXT:
+ *gadget_elem_score_value = gi->text.number_value;
+ break;
+
+ case GADGET_ID_ELEM_CONTENT_DOWN:
+ case GADGET_ID_ELEM_CONTENT_UP:
+ step *= (id == GADGET_ID_ELEM_CONTENT_DOWN ? -1 : 1);
+ ModifyEditorCounter(ED_COUNTER_ID_ELEM_CONTENT,
+ *gadget_elem_content_value + step);
+ DrawElementContentAreas();
+ break;
+ case GADGET_ID_ELEM_CONTENT_TEXT:
+ *gadget_elem_content_value = gi->text.number_value;
+ DrawElementContentAreas();
+ break;
+
+ case GADGET_ID_LEVEL_XSIZE_DOWN:
+ case GADGET_ID_LEVEL_XSIZE_UP:
+ step *= (id == GADGET_ID_LEVEL_XSIZE_DOWN ? -1 : 1);
+ ModifyEditorCounter(ED_COUNTER_ID_LEVEL_XSIZE,
+ *gadget_level_xsize_value + step);
+ level.fieldx = lev_fieldx;
+ break;
+ case GADGET_ID_LEVEL_XSIZE_TEXT:
+ *gadget_level_xsize_value = gi->text.number_value;
+ level.fieldx = lev_fieldx;
+ break;
+
+ case GADGET_ID_LEVEL_YSIZE_DOWN:
+ case GADGET_ID_LEVEL_YSIZE_UP:
+ step *= (id == GADGET_ID_LEVEL_YSIZE_DOWN ? -1 : 1);
+ ModifyEditorCounter(ED_COUNTER_ID_LEVEL_YSIZE,
+ *gadget_level_ysize_value + step);
+ level.fieldy = lev_fieldy;
+ break;
+ case GADGET_ID_LEVEL_YSIZE_TEXT:
+ *gadget_level_ysize_value = gi->text.number_value;
+ level.fieldy = lev_fieldy;
+ break;
+
+ case GADGET_ID_LEVEL_RANDOM_DOWN:
+ case GADGET_ID_LEVEL_RANDOM_UP:
+ step *= (id == GADGET_ID_LEVEL_RANDOM_DOWN ? -1 : 1);
+ ModifyEditorCounter(ED_COUNTER_ID_LEVEL_RANDOM,
+ *gadget_level_random_value + step);
+ break;
+ case GADGET_ID_LEVEL_RANDOM_TEXT:
+ *gadget_level_random_value = gi->text.number_value;
+ break;
+
+ case GADGET_ID_LEVEL_COLLECT_DOWN:
+ case GADGET_ID_LEVEL_COLLECT_UP:
+ step *= (id == GADGET_ID_LEVEL_COLLECT_DOWN ? -1 : 1);
+ ModifyEditorCounter(ED_COUNTER_ID_LEVEL_COLLECT,
+ *gadget_level_collect_value + step);
+ break;
+ case GADGET_ID_LEVEL_COLLECT_TEXT:
+ *gadget_level_collect_value = gi->text.number_value;
+ break;
+
+ case GADGET_ID_LEVEL_TIMELIMIT_DOWN:
+ case GADGET_ID_LEVEL_TIMELIMIT_UP:
+ step *= (id == GADGET_ID_LEVEL_TIMELIMIT_DOWN ? -1 : 1);
+ ModifyEditorCounter(ED_COUNTER_ID_LEVEL_TIMELIMIT,
+ *gadget_level_timelimit_value + step);
+ break;
+ case GADGET_ID_LEVEL_TIMELIMIT_TEXT:
+ *gadget_level_timelimit_value = gi->text.number_value;
+ break;
+
+ case GADGET_ID_LEVEL_TIMESCORE_DOWN:
+ case GADGET_ID_LEVEL_TIMESCORE_UP:
+ step *= (id == GADGET_ID_LEVEL_TIMESCORE_DOWN ? -1 : 1);
+ ModifyEditorCounter(ED_COUNTER_ID_LEVEL_TIMESCORE,
+ *gadget_level_timescore_value + step);
+ break;
+ case GADGET_ID_LEVEL_TIMESCORE_TEXT:
+ *gadget_level_timescore_value = gi->text.number_value;
+ break;
+
+ default:
+ break;
+ }
+}
+
+static void HandleTextInputGadgets(struct GadgetInfo *gi)
+{
+ int id = gi->custom_id;
+
+ switch (id)
+ {
+ case GADGET_ID_LEVEL_NAME:
+ strcpy(level.name, gi->text.value);
+ break;
+
+ case GADGET_ID_LEVEL_AUTHOR:
+ strcpy(level.author, gi->text.value);
+ break;
+
+ default:
+ break;
+ }
+}
+
+static void HandleControlButtons(struct GadgetInfo *gi)
+{
+ int id = gi->custom_id;
+ int button = gi->event.button;
+ int step = (button == 1 ? 1 : button == 2 ? 5 : 10);
+ int new_element = BUTTON_ELEMENT(button);
+ int player_present = FALSE;
+ int level_changed = FALSE;
+ int i, x, y;
+
+ if (edit_mode == ED_MODE_DRAWING && drawing_function == GADGET_ID_TEXT)
+ DrawLevelText(0, 0, 0, TEXT_END);
+
+ if (id < ED_NUM_CTRL1_BUTTONS && id != GADGET_ID_PROPERTIES &&
+ edit_mode != ED_MODE_DRAWING)
+ {
+ DrawDrawingWindow();
+ edit_mode = ED_MODE_DRAWING;
+ }
+
+ switch (id)
+ {
+ case GADGET_ID_SCROLL_LEFT:
+ if (level_xpos >= 0)
+ {
+ int gadget_id = GADGET_ID_SCROLL_HORIZONTAL;
+ struct GadgetInfo *gi = level_editor_gadget[gadget_id];
+
+ if (lev_fieldx < ed_fieldx - 2)
+ break;
+
+ level_xpos -= step;
+ if (level_xpos < -1)
+ level_xpos = -1;
+ if (button == 1)
+ ScrollMiniLevel(level_xpos, level_ypos, ED_SCROLL_RIGHT);
+ else
+ DrawMiniLevel(ed_fieldx, ed_fieldy, level_xpos, level_ypos);
+
+ ModifyGadget(gi, GDI_SCROLLBAR_ITEM_POSITION, level_xpos + 1, GDI_END);
+ }
+ break;
+
+ case GADGET_ID_SCROLL_RIGHT:
+ if (level_xpos <= lev_fieldx - ed_fieldx)
+ {
+ int gadget_id = GADGET_ID_SCROLL_HORIZONTAL;
+ struct GadgetInfo *gi = level_editor_gadget[gadget_id];
+
+ if (lev_fieldx < ed_fieldx - 2)
+ break;
+
+ level_xpos += step;
+ if (level_xpos > lev_fieldx - ed_fieldx + 1)
+ level_xpos = lev_fieldx - ed_fieldx + 1;
+ if (button == 1)
+ ScrollMiniLevel(level_xpos, level_ypos, ED_SCROLL_LEFT);
+ else
+ DrawMiniLevel(ed_fieldx, ed_fieldy, level_xpos, level_ypos);
+
+ ModifyGadget(gi, GDI_SCROLLBAR_ITEM_POSITION, level_xpos + 1, GDI_END);
+ }
+ break;
+
+ case GADGET_ID_SCROLL_UP:
+ if (level_ypos >= 0)
+ {
+ int gadget_id = GADGET_ID_SCROLL_VERTICAL;
+ struct GadgetInfo *gi = level_editor_gadget[gadget_id];
+
+ if (lev_fieldy < ed_fieldy - 2)
+ break;
+
+ level_ypos -= step;
+ if (level_ypos < -1)
+ level_ypos = -1;
+ if (button == 1)
+ ScrollMiniLevel(level_xpos, level_ypos, ED_SCROLL_DOWN);
+ else
+ DrawMiniLevel(ed_fieldx, ed_fieldy, level_xpos, level_ypos);
+
+ ModifyGadget(gi, GDI_SCROLLBAR_ITEM_POSITION, level_ypos + 1, GDI_END);
+ }
+ break;
+
+ case GADGET_ID_SCROLL_DOWN:
+ if (level_ypos <= lev_fieldy - ed_fieldy)
+ {
+ int gadget_id = GADGET_ID_SCROLL_VERTICAL;
+ struct GadgetInfo *gi = level_editor_gadget[gadget_id];
+
+ if (lev_fieldy < ed_fieldy - 2)
+ break;
+
+ level_ypos += step;
+ if (level_ypos > lev_fieldy - ed_fieldy + 1)
+ level_ypos = lev_fieldy - ed_fieldy + 1;
+ if (button == 1)
+ ScrollMiniLevel(level_xpos, level_ypos, ED_SCROLL_UP);
+ else
+ DrawMiniLevel(ed_fieldx, ed_fieldy, level_xpos, level_ypos);
+
+ ModifyGadget(gi, GDI_SCROLLBAR_ITEM_POSITION, level_ypos + 1, GDI_END);
+ }
+ break;
+
+ case GADGET_ID_SCROLL_HORIZONTAL:
+ level_xpos = gi->event.item_position - 1;
+ DrawMiniLevel(ed_fieldx, ed_fieldy, level_xpos, level_ypos);
+ break;
+
+ case GADGET_ID_SCROLL_VERTICAL:
+ level_ypos = gi->event.item_position - 1;
+ DrawMiniLevel(ed_fieldx, ed_fieldy, level_xpos, level_ypos);
+ break;
+
+ case GADGET_ID_ELEMENTLIST_UP:
+ case GADGET_ID_ELEMENTLIST_DOWN:
+ step *= (id == GADGET_ID_ELEMENTLIST_UP ? -1 : +1);
+ element_shift += step * ED_ELEMENTLIST_BUTTONS_HORIZ;
+
+ if (element_shift < 0)
+ element_shift = 0;
+ if (element_shift > elements_in_list - ED_NUM_ELEMENTLIST_BUTTONS)
+ element_shift = elements_in_list - ED_NUM_ELEMENTLIST_BUTTONS;
+
+ for (i=0; i<ED_NUM_ELEMENTLIST_BUTTONS; i++)
+ {
+ int gadget_id = GADGET_ID_ELEMENTLIST_FIRST + i;
+ struct GadgetInfo *gi = level_editor_gadget[gadget_id];
+ struct GadgetDesign *gd = &gi->deco.design;
+ int element = editor_element[element_shift + i];
+
+ UnmapGadget(gi);
+ getMiniGraphicSource(el2gfx(element), &gd->pixmap, &gd->x, &gd->y);
+ ModifyGadget(gi, GDI_INFO_TEXT, element_info[element], GDI_END);
+ MapGadget(gi);
+ }
+ break;
+
+ case GADGET_ID_WRAP_LEFT:
+ WrapLevel(-step, 0);
+ break;
+
+ case GADGET_ID_WRAP_RIGHT:
+ WrapLevel(step, 0);
+ break;
+
+ case GADGET_ID_WRAP_UP:
+ WrapLevel(0, -step);
+ break;
+
+ case GADGET_ID_WRAP_DOWN:
+ WrapLevel(0, step);
+ break;
+
+ case GADGET_ID_SINGLE_ITEMS:
+ case GADGET_ID_CONNECTED_ITEMS:
+ case GADGET_ID_LINE:
+ case GADGET_ID_ARC:
+ case GADGET_ID_TEXT:
+ case GADGET_ID_RECTANGLE:
+ case GADGET_ID_FILLED_BOX:
+ case GADGET_ID_FLOOD_FILL:
+ case GADGET_ID_GRAB_BRUSH:
+ case GADGET_ID_PICK_ELEMENT:
+ last_drawing_function = drawing_function;
+ drawing_function = id;
+ draw_with_brush = FALSE;
+ break;
+
+ case GADGET_ID_RANDOM_PLACEMENT:
+ RandomPlacement(new_element);
+ break;
+
+ case GADGET_ID_PROPERTIES:
+ if (edit_mode != ED_MODE_PROPERTIES)
+ {
+ properties_element = new_element;
+ DrawPropertiesWindow();
+ edit_mode = ED_MODE_PROPERTIES;
+ }
+ else
+ {
+ DrawDrawingWindow();
+ edit_mode = ED_MODE_DRAWING;
+ }
+ break;
+
+ case GADGET_ID_UNDO:
+ if (undo_buffer_steps == 0)
+ {
+ Request("Undo buffer empty !", REQ_CONFIRM);
+ break;
+ }
+
+ undo_buffer_position =
+ (undo_buffer_position - 1 + NUM_UNDO_STEPS) % NUM_UNDO_STEPS;
+ undo_buffer_steps--;
+
+ for(x=0; x<lev_fieldx; x++)
+ for(y=0; y<lev_fieldy; y++)
+ Feld[x][y] = UndoBuffer[undo_buffer_position][x][y];
+ DrawMiniLevel(ed_fieldx, ed_fieldy, level_xpos,level_ypos);
+ break;
+
+ case GADGET_ID_INFO:
+ if (edit_mode != ED_MODE_INFO)
+ {
+ DrawLevelInfoWindow();
+ edit_mode = ED_MODE_INFO;
+ }
+ else
+ {
+ DrawDrawingWindow();
+ edit_mode = ED_MODE_DRAWING;
+ }
+ break;
+
+ case GADGET_ID_CLEAR:
+ for(x=0; x<MAX_LEV_FIELDX; x++)
+ for(y=0; y<MAX_LEV_FIELDY; y++)
+ Feld[x][y] = (button == 1 ? EL_LEERRAUM : new_element);
+ CopyLevelToUndoBuffer(GADGET_ID_CLEAR);
+
+ DrawMiniLevel(ed_fieldx, ed_fieldy, level_xpos, level_ypos);
+ break;
+
+ case GADGET_ID_SAVE:
+ if (leveldir[leveldir_nr].readonly)
+ {
+ Request("This level is read only !", REQ_CONFIRM);
+ break;
+ }
+
+ for(y=0; y<lev_fieldy; y++)
+ for(x=0; x<lev_fieldx; x++)
+ if (Feld[x][y] != Ur[x][y])
+ level_changed = TRUE;
+
+ if (0 && !level_changed)
+ {
+ Request("Level has not changed !", REQ_CONFIRM);
+ break;
+ }
+
+ for(y=0; y<lev_fieldy; y++)
+ for(x=0; x<lev_fieldx; x++)
+ if (Feld[x][y] == EL_SPIELFIGUR ||
+ Feld[x][y] == EL_SPIELER1 ||
+ Feld[x][y] == EL_SP_MURPHY)
+ player_present = TRUE;
+
+ if (!player_present)
+ Request("No Level without Gregor Mc Duffin please !", REQ_CONFIRM);
+ else
+ {
+ if (Request("Save this level and kill the old ?", REQ_ASK))
+ {
+ for(x=0; x<lev_fieldx; x++)
+ for(y=0; y<lev_fieldy; y++)
+ Ur[x][y] = Feld[x][y];
+ SaveLevel(level_nr);
+ }
+ }
+ break;
+
+ case GADGET_ID_TEST:
+ for(y=0; y<lev_fieldy; y++)
+ for(x=0; x<lev_fieldx; x++)
+ if (Feld[x][y] == EL_SPIELFIGUR ||
+ Feld[x][y] == EL_SPIELER1 ||
+ Feld[x][y] == EL_SP_MURPHY)
+ player_present = TRUE;
+
+ if (!player_present)
+ Request("No Level without Gregor Mc Duffin please !", REQ_CONFIRM);
+ else
+ {
+ for(x=0; x<lev_fieldx; x++)
+ for(y=0; y<lev_fieldy; y++)
+ FieldBackup[x][y] = Ur[x][y];
+
+ for(x=0; x<lev_fieldx; x++)
+ for(y=0; y<lev_fieldy; y++)
+ Ur[x][y] = Feld[x][y];
+
+ UnmapLevelEditorGadgets();
+
+ /* draw smaller door */
+ XCopyArea(display, pix[PIX_DOOR], drawto, gc,
+ DOOR_GFX_PAGEX7, 64,
+ 108, 64,
+ EX - 4, EY - 12);
+ redraw_mask |= REDRAW_ALL;
+
+ CloseDoor(DOOR_CLOSE_ALL);
+
+ DrawCompleteVideoDisplay();
+
+ if (setup.autorecord)
+ TapeStartRecording();
+
+ level_editor_test_game = TRUE;
+ game_status = PLAYING;
+
+ InitGame();
+ }
+ break;
+
+ case GADGET_ID_EXIT:
+ for(y=0; y<lev_fieldy; y++)
+ for(x=0; x<lev_fieldx; x++)
+ if (Feld[x][y] != Ur[x][y])
+ level_changed = TRUE;
+
+ if (!level_changed ||
+ Request("Level has changed! Exit without saving ?",
+ REQ_ASK | REQ_STAY_OPEN))
+ {
+ CloseDoor(DOOR_CLOSE_1);
+
+ /*
+ CloseDoor(DOOR_CLOSE_ALL);
+ */
+
+ /* draw smaller door */
+ XCopyArea(display, pix[PIX_DOOR], drawto, gc,
+ DOOR_GFX_PAGEX7, 64,
+ 108, 64,
+ EX - 4, EY - 12);
+ redraw_mask |= REDRAW_ALL;
+
+ game_status = MAINMENU;
+ DrawMainMenu();
+ }
+ else
+ {
+ CloseDoor(DOOR_CLOSE_1);
+ XCopyArea(display, pix[PIX_DB_DOOR], pix[PIX_DB_DOOR], gc,
+ DOOR_GFX_PAGEX2, DOOR_GFX_PAGEY1, DXSIZE,DYSIZE,
+ DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1);
+ OpenDoor(DOOR_OPEN_1);
+ }
+ break;
+
+ case GADGET_ID_RANDOM_PERCENTAGE:
+ *radiobutton_info[ED_RADIOBUTTON_ID_PERCENTAGE].value =
+ radiobutton_info[ED_RADIOBUTTON_ID_PERCENTAGE].checked_value;
+ break;
+
+ case GADGET_ID_RANDOM_QUANTITY:
+ *radiobutton_info[ED_RADIOBUTTON_ID_QUANTITY].value =
+ radiobutton_info[ED_RADIOBUTTON_ID_QUANTITY].checked_value;
+ break;
+
+ case GADGET_ID_RANDOM_RESTRICTED:
+ *checkbutton_info[ED_CHECKBUTTON_ID_RANDOM_RESTRICTED].value ^= TRUE;
+ break;
+
+ case GADGET_ID_DOUBLE_SPEED:
+ *checkbutton_info[ED_CHECKBUTTON_ID_DOUBLE_SPEED].value ^= TRUE;
+ break;
+
+ case GADGET_ID_STICK_ELEMENT:
+ *checkbutton_info[ED_CHECKBUTTON_ID_STICK_ELEMENT].value ^= TRUE;
+ break;
+
+ default:
+ if (id >= GADGET_ID_ELEMENTLIST_FIRST &&
+ id <= GADGET_ID_ELEMENTLIST_LAST)
+ {
+ int element_position = id - GADGET_ID_ELEMENTLIST_FIRST;
+ int new_element = editor_element[element_position + element_shift];
+
+ PickDrawingElement(button, new_element);
+
+ if (!HAS_CONTENT(properties_element) ||
+ !stick_element_properties_window)
+ {
+ properties_element = new_element;
+ if (edit_mode == ED_MODE_PROPERTIES)
+ DrawPropertiesWindow();
+ }
+
+ if (drawing_function == GADGET_ID_PICK_ELEMENT)
+ ClickOnGadget(level_editor_gadget[last_drawing_function], MB_LEFT);
+ }
+#ifdef DEBUG
+ else if (gi->event.type == GD_EVENT_PRESSED)
+ printf("default: HandleControlButtons: GD_EVENT_PRESSED(%d)\n", id);
+ else if (gi->event.type == GD_EVENT_RELEASED)
+ printf("default: HandleControlButtons: GD_EVENT_RELEASED(%d)\n", id);
+ else if (gi->event.type == GD_EVENT_MOVING)
+ printf("default: HandleControlButtons: GD_EVENT_MOVING(%d)\n", id);
+ else
+ printf("default: HandleControlButtons: ? (id == %d)\n", id);
+#endif
+ break;
+ }
+}
+
+void HandleLevelEditorKeyInput(KeySym key)
+{
+ char letter = getCharFromKeySym(key);
+ int button = MB_LEFT;
+
+ if (drawing_function == GADGET_ID_TEXT &&
+ DrawLevelText(0, 0, 0, TEXT_QUERY_TYPING) == TRUE)
+ {
+ if (letter)
+ DrawLevelText(0, 0, letter, TEXT_WRITECHAR);
+ else if (key == XK_Delete || key == XK_BackSpace)
+ DrawLevelText(0, 0, 0, TEXT_BACKSPACE);
+ else if (key == XK_Return)
+ DrawLevelText(0, 0, 0, TEXT_NEWLINE);
+ }
+ else if (button_status == MB_RELEASED)
+ {
+ int i, id;
+
+ switch (key)
+ {
+ case XK_Left:
+ id = GADGET_ID_SCROLL_LEFT;
+ break;
+ case XK_Right:
+ id = GADGET_ID_SCROLL_RIGHT;
+ break;
+ case XK_Up:
+ id = GADGET_ID_SCROLL_UP;
+ break;
+ case XK_Down:
+ id = GADGET_ID_SCROLL_DOWN;
+ break;
+ case XK_Page_Up:
+ id = GADGET_ID_ELEMENTLIST_UP;
+ button = 3;
+ break;
+ case XK_Page_Down:
+ id = GADGET_ID_ELEMENTLIST_DOWN;
+ button = 3;
+ break;
+
+ default:
+ id = GADGET_ID_NONE;
+ break;
+ }
+
+ if (id != GADGET_ID_NONE)
+ ClickOnGadget(level_editor_gadget[id], button);
+ else if (letter == '.')
+ ClickOnGadget(level_editor_gadget[GADGET_ID_SINGLE_ITEMS], button);
+ else
+ for (i=0; i<ED_NUM_CTRL_BUTTONS; i++)
+ if (letter && letter == control_info[i].shortcut)
+ if (!anyTextGadgetActive())
+ ClickOnGadget(level_editor_gadget[i], button);
+ }
+}
+
+void ClearEditorGadgetInfoText()
+{
+ XFillRectangle(display, drawto, gc,
+ INFOTEXT_XPOS, INFOTEXT_YPOS, INFOTEXT_XSIZE, INFOTEXT_YSIZE);
+ redraw_mask |= REDRAW_FIELD;
+}
+
+void HandleEditorGadgetInfoText(void *ptr)
+{
+ struct GadgetInfo *gi = (struct GadgetInfo *)ptr;
+ char infotext[MAX_INFOTEXT_LEN + 1];
+ char shortcut[20];
+
+ ClearEditorGadgetInfoText();
+
+ /* misuse this function to delete brush cursor, if needed */
+ if (edit_mode == ED_MODE_DRAWING && draw_with_brush)
+ DeleteBrushFromCursor();
+
+ if (gi == NULL || gi->info_text == NULL)
+ return;
+
+ strncpy(infotext, gi->info_text, MAX_INFOTEXT_LEN);
+ infotext[MAX_INFOTEXT_LEN] = '\0';
+
+ if (gi->custom_id < ED_NUM_CTRL_BUTTONS)
+ {
+ int key = control_info[gi->custom_id].shortcut;
+
+ if (key)
+ {
+ sprintf(shortcut, " ('%s%c')",
+ (key >= 'A' && key <= 'Z' ? "Shift-" :
+ gi->custom_id == GADGET_ID_SINGLE_ITEMS ? ".' or '" : ""),
+ key);
+
+ if (strlen(infotext) + strlen(shortcut) <= MAX_INFOTEXT_LEN)
+ strcat(infotext, shortcut);
+ }
+ }
+
+ DrawText(INFOTEXT_XPOS, INFOTEXT_YPOS, infotext, FS_SMALL, FC_YELLOW);
+}
+
+static void HandleDrawingAreaInfo(struct GadgetInfo *gi)
+{
+ static int start_lx, start_ly;
+ char *infotext;
+ int id = gi->custom_id;
+ int sx = gi->event.x;
+ int sy = gi->event.y;
+ int lx = sx + level_xpos;
+ int ly = sy + level_ypos;
+ int min_sx = 0, min_sy = 0;
+ int max_sx = gi->drawing.area_xsize - 1;
+ int max_sy = gi->drawing.area_ysize - 1;
+
+ ClearEditorGadgetInfoText();
+
+ /* make sure to stay inside drawing area boundaries */
+ sx = (sx < min_sx ? min_sx : sx > max_sx ? max_sx : sx);
+ sy = (sy < min_sy ? min_sy : sy > max_sy ? max_sy : sy);
+
+ if (id == GADGET_ID_DRAWING_LEVEL)
+ {
+ if (button_status)
+ {
+ int min_lx = 0, min_ly = 0;
+ int max_lx = lev_fieldx - 1, max_ly = lev_fieldy - 1;
+
+ /* get positions inside level field */
+ lx = sx + level_xpos;
+ ly = sy + level_ypos;
+
+ /* make sure to stay inside level field boundaries */
+ lx = (lx < min_lx ? min_lx : lx > max_lx ? max_lx : lx);
+ ly = (ly < min_ly ? min_ly : ly > max_ly ? max_ly : ly);
+
+ /* correct drawing area positions accordingly */
+ sx = lx - level_xpos;
+ sy = ly - level_ypos;
+ }
+
+ if (IN_ED_FIELD(sx,sy) && IN_LEV_FIELD(lx, ly))
+ {
+ if (button_status) /* if (gi->state == GD_BUTTON_PRESSED) */
+ {
+ if (gi->event.type == GD_EVENT_PRESSED)
+ {
+ start_lx = lx;
+ start_ly = ly;
+ }
+
+ switch (drawing_function)
+ {
+ case GADGET_ID_SINGLE_ITEMS:
+ infotext = "Drawing single items";
+ break;
+ case GADGET_ID_CONNECTED_ITEMS:
+ infotext = "Drawing connected items";
+ break;
+ case GADGET_ID_LINE:
+ infotext = "Drawing line";
+ break;
+ case GADGET_ID_ARC:
+ infotext = "Drawing arc";
+ break;
+ case GADGET_ID_TEXT:
+ infotext = "Setting text cursor";
+ break;
+ case GADGET_ID_RECTANGLE:
+ infotext = "Drawing rectangle";
+ break;
+ case GADGET_ID_FILLED_BOX:
+ infotext = "Drawing filled box";
+ break;
+ case GADGET_ID_FLOOD_FILL:
+ infotext = "Flood fill";
+ break;
+ case GADGET_ID_GRAB_BRUSH:
+ infotext = "Grabbing brush";
+ break;
+ case GADGET_ID_PICK_ELEMENT:
+ infotext = "Picking element";
+ break;
+
+ default:
+ infotext = "Drawing position";
+ break;
+ }
+
+ if (drawing_function == GADGET_ID_PICK_ELEMENT)
+ DrawTextF(INFOTEXT_XPOS - SX, INFOTEXT_YPOS - SY, FC_YELLOW,
+ "%s: %d, %d", infotext, lx, ly);
+ else
+ DrawTextF(INFOTEXT_XPOS - SX, INFOTEXT_YPOS - SY, FC_YELLOW,
+ "%s: %d, %d", infotext,
+ ABS(lx - start_lx) + 1, ABS(ly - start_ly) + 1);
+ }
+ else if (drawing_function == GADGET_ID_PICK_ELEMENT)
+ DrawTextF(INFOTEXT_XPOS - SX, INFOTEXT_YPOS - SY, FC_YELLOW,
+ "%s", element_info[Feld[lx][ly]]);
+ else
+ DrawTextF(INFOTEXT_XPOS - SX, INFOTEXT_YPOS - SY, FC_YELLOW,
+ "Level position: %d, %d", lx, ly);
+ }
+
+ /* misuse this function to draw brush cursor, if needed */
+ if (edit_mode == ED_MODE_DRAWING && draw_with_brush && !button_status)
+ {
+ if (IN_ED_FIELD(sx, sy) && IN_LEV_FIELD(lx, ly))
+ CopyBrushToCursor(sx, sy);
+ else
+ DeleteBrushFromCursor();
+ }
+ }
+ else if (id == GADGET_ID_AMOEBA_CONTENT)
+ DrawTextF(INFOTEXT_XPOS - SX, INFOTEXT_YPOS - SY, FC_YELLOW,
+ "Amoeba content");
+ else if (id == GADGET_ID_RANDOM_BACKGROUND)
+ DrawTextF(INFOTEXT_XPOS - SX, INFOTEXT_YPOS - SY, FC_YELLOW,
+ "Random placement background");
+ else
+ DrawTextF(INFOTEXT_XPOS - SX, INFOTEXT_YPOS - SY, FC_YELLOW,
+ "Content area %d position: %d, %d",
+ id - GADGET_ID_ELEM_CONTENT_0 + 1, sx, sy);