X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Feditor.c;h=7d885e14920f23e15f48600485cfba00240d4d99;hb=0c2b6a7610933f9098ec233f7b4c2b52eac3535c;hp=88b7d7dcd7b746b474c2204ef6569920a7c6b6bf;hpb=65e73b3607d8d4aef09abaf1f44d090197953f21;p=rocksndiamonds.git diff --git a/src/editor.c b/src/editor.c index 88b7d7dc..7d885e14 100644 --- a/src/editor.c +++ b/src/editor.c @@ -18,6 +18,7 @@ #include "buttons.h" #include "files.h" #include "game.h" +#include "tape.h" /* positions in the level editor */ #define ED_WIN_MB_LEFT_XPOS 7 @@ -48,8 +49,13 @@ #define RANDOM_USE_PERCENTAGE 0 #define RANDOM_USE_NUM_OBJECTS 1 +/* values for elements with content */ +#define MAX_ELEMCONT 8 + /* values for the control window */ -#define ED_CTRL_BUTTONS_GFX_YPOS 236 +#define ED_CTRL_BUTTONS_GFX_YPOS 236 +#define ED_CTRL_BUTTONS_ALT_GFX_YPOS 142 + #define ED_CTRL1_BUTTONS_HORIZ 4 #define ED_CTRL1_BUTTONS_VERT 4 #define ED_CTRL1_BUTTON_XSIZE 22 @@ -66,11 +72,37 @@ #define ED_NUM_CTRL2_BUTTONS (ED_CTRL2_BUTTONS_HORIZ * ED_CTRL2_BUTTONS_VERT) #define ED_NUM_CTRL_BUTTONS (ED_NUM_CTRL1_BUTTONS + ED_NUM_CTRL2_BUTTONS) -/* values for other gadgets */ -#define ED_SCORE_XPOS TILEX -#define ED_SCORE_YPOS (7 * TILEY) +/* values for properties window */ +#define ED_PROPERTIES_XPOS (TILEX - MINI_TILEX/2) +/* values for counter gadgets */ #define ED_COUNT_VALUE_XOFFSET 5 #define ED_COUNT_VALUE_YOFFSET 3 +#define ED_COUNT_SCORE_XPOS ED_PROPERTIES_XPOS +#define ED_COUNT_SCORE_YPOS (14 * MINI_TILEY) +#define ED_COUNT_ELEMCONT_XPOS ED_PROPERTIES_XPOS +#define ED_COUNT_ELEMCONT_YPOS (17 * MINI_TILEY) + +/* values for element content drawing areas */ +#define ED_AREA_ELEMCONT_XPOS (TILEX) +#define ED_AREA_ELEMCONT_YPOS (10 * TILEY) + +/* values for scrolling gadgets */ +#define ED_SCROLL_UP_XPOS (SXSIZE - ED_SCROLLBUTTON_XSIZE) +#define ED_SCROLL_UP_YPOS (0) +#define ED_SCROLL_DOWN_XPOS ED_SCROLL_UP_XPOS +#define ED_SCROLL_DOWN_YPOS (SYSIZE - TILEX - ED_SCROLLBUTTON_YSIZE) +#define ED_SCROLL_LEFT_XPOS (0) +#define ED_SCROLL_LEFT_YPOS (SYSIZE - ED_SCROLLBUTTON_YSIZE) +#define ED_SCROLL_RIGHT_XPOS (SXSIZE - TILEX - ED_SCROLLBUTTON_XSIZE) +#define ED_SCROLL_RIGHT_YPOS ED_SCROLL_LEFT_YPOS +#define ED_SCROLL_VERTICAL_XPOS ED_SCROLL_UP_XPOS +#define ED_SCROLL_VERTICAL_YPOS (ED_SCROLL_UP_YPOS + 20) +#define ED_SCROLL_VERTICAL_XSIZE 30 +#define ED_SCROLL_VERTICAL_YSIZE (SYSIZE - TILEY - 2 * 20) +#define ED_SCROLL_HORIZONTAL_XPOS (ED_SCROLL_LEFT_XPOS + 30) +#define ED_SCROLL_HORIZONTAL_YPOS (SYSIZE - 30) +#define ED_SCROLL_HORIZONTAL_XSIZE (SXSIZE - TILEX - 2*30) +#define ED_SCROLL_HORIZONTAL_YSIZE 30 /* control button identifiers */ #define ED_CTRL_ID_SINGLE_ITEMS 0 @@ -83,10 +115,12 @@ #define ED_CTRL_ID_PROPERTIES 7 #define ED_CTRL_ID_FLOOD_FILL 8 #define ED_CTRL_ID_WRAP_LEFT 9 +#define ED_CTRL_ID_UNUSED1 10 #define ED_CTRL_ID_WRAP_RIGHT 11 #define ED_CTRL_ID_RANDOM_PLACEMENT 12 #define ED_CTRL_ID_BRUSH 13 #define ED_CTRL_ID_WRAP_DOWN 14 +#define ED_CTRL_ID_PICK_ELEMENT 15 #define ED_CTRL_ID_UNDO 16 #define ED_CTRL_ID_INFO 17 #define ED_CTRL_ID_SAVE 18 @@ -97,40 +131,107 @@ /* counter button identifiers */ #define ED_CTRL_ID_SCORE_DOWN 22 #define ED_CTRL_ID_SCORE_UP 23 +#define ED_CTRL_ID_ELEMCONT_DOWN 24 +#define ED_CTRL_ID_ELEMCONT_UP 25 /* drawing area identifiers */ -#define ED_CTRL_ID_DRAWING_LEVEL 24 +#define ED_CTRL_ID_DRAWING_LEVEL 26 +#define ED_CTRL_ID_ELEMCONT_0 27 +#define ED_CTRL_ID_ELEMCONT_7 34 +#define ED_CTRL_ID_AMOEBA_CONTENT 35 + +/* text input identifiers */ +#define ED_CTRL_ID_LEVEL_NAME 36 -#define ED_NUM_GADGETS 25 +/* gadgets for scrolling of drawing area */ +#define ED_CTRL_ID_SCROLL_UP 37 +#define ED_CTRL_ID_SCROLL_DOWN 38 +#define ED_CTRL_ID_SCROLL_LEFT 39 +#define ED_CTRL_ID_SCROLL_RIGHT 40 +#define ED_CTRL_ID_SCROLL_VERTICAL 41 +#define ED_CTRL_ID_SCROLL_HORIZONTAL 42 + +#define ED_NUM_GADGETS 43 /* values for counter gadgets */ #define ED_COUNTER_SCORE 0 +#define ED_COUNTER_ELEMCONT 1 + +#define ED_NUM_COUNTERBUTTONS 2 +#define ED_NUM_SCROLLBUTTONS 4 +#define ED_NUM_SCROLLBARS 2 + +/* values for CopyLevelToUndoBuffer() */ +#define UNDO_IMMEDIATE 0 +#define UNDO_ACCUMULATE 1 + +static struct +{ + int x, y; + int gadget_id; +} counterbutton_info[ED_NUM_COUNTERBUTTONS] = +{ + { ED_COUNT_SCORE_XPOS, ED_COUNT_SCORE_YPOS, ED_CTRL_ID_SCORE_DOWN }, + { ED_COUNT_ELEMCONT_XPOS, ED_COUNT_ELEMCONT_YPOS, ED_CTRL_ID_ELEMCONT_DOWN } +}; -#define ED_NUM_COUNTERS 1 +static struct +{ + int xpos, ypos; + int x, y; + int gadget_id; +} scrollbutton_info[ED_NUM_SCROLLBUTTONS] = +{ + { ED_BUTTON_UP_XPOS, ED_BUTTON_UP_YPOS, + ED_SCROLL_UP_XPOS, ED_SCROLL_UP_YPOS, ED_CTRL_ID_SCROLL_UP }, + { ED_BUTTON_DOWN_XPOS, ED_BUTTON_DOWN_YPOS, + ED_SCROLL_DOWN_XPOS, ED_SCROLL_DOWN_YPOS, ED_CTRL_ID_SCROLL_DOWN }, + { ED_BUTTON_LEFT_XPOS, ED_BUTTON_LEFT_YPOS, + ED_SCROLL_LEFT_XPOS, ED_SCROLL_LEFT_YPOS, ED_CTRL_ID_SCROLL_LEFT }, + { ED_BUTTON_RIGHT_XPOS, ED_BUTTON_RIGHT_YPOS, + ED_SCROLL_RIGHT_XPOS, ED_SCROLL_RIGHT_YPOS, ED_CTRL_ID_SCROLL_RIGHT } +}; static struct { + int xpos, ypos; int x, y; + int width, height; + int type; int gadget_id; -} counter_info[ED_NUM_COUNTERS] = +} scrollbar_info[ED_NUM_SCROLLBARS] = { - { ED_SCORE_XPOS, ED_SCORE_YPOS, ED_CTRL_ID_SCORE_DOWN } + { GAME_CONTROL_XPOS, GAME_CONTROL_YPOS - GAME_BUTTON_YSIZE, + ED_SCROLL_VERTICAL_XPOS, ED_SCROLL_VERTICAL_YPOS, + ED_SCROLL_VERTICAL_XSIZE, ED_SCROLL_VERTICAL_YSIZE, + GD_TYPE_SCROLLBAR_VERTICAL, + ED_CTRL_ID_SCROLL_VERTICAL }, + { GAME_CONTROL_XPOS, GAME_CONTROL_YPOS - GAME_BUTTON_YSIZE, + ED_SCROLL_HORIZONTAL_XPOS, ED_SCROLL_HORIZONTAL_YPOS, + ED_SCROLL_HORIZONTAL_XSIZE, ED_SCROLL_HORIZONTAL_YSIZE, + GD_TYPE_SCROLLBAR_HORIZONTAL, + ED_CTRL_ID_SCROLL_HORIZONTAL }, }; + /* forward declaration for internal use */ static void DrawDrawingWindow(); -static void DrawPropertiesWindow(int); -static void CopyLevelToUndoBuffer(); -static void HandleDrawingAreas(struct GadgetInfo *); -static void HandleCounterButtons(struct GadgetInfo *); +static void DrawPropertiesWindow(); +static void CopyLevelToUndoBuffer(int); static void HandleControlButtons(struct GadgetInfo *); +static void HandleCounterButtons(struct GadgetInfo *); +static void HandleDrawingAreas(struct GadgetInfo *); +static void HandleTextInputGadgets(struct GadgetInfo *); static struct GadgetInfo *level_editor_gadget[ED_NUM_GADGETS]; static boolean level_editor_gadgets_created = FALSE; static int drawing_function = ED_CTRL_ID_SINGLE_ITEMS; +static int last_drawing_function = ED_CTRL_ID_SINGLE_ITEMS; +static int properties_element = 0; -static short OrigBackup[MAX_LEV_FIELDX][MAX_LEV_FIELDY]; +static short ElementContent[MAX_ELEMCONT][3][3]; +static short FieldBackup[MAX_LEV_FIELDX][MAX_LEV_FIELDY]; static short UndoBuffer[NUM_UNDO_STEPS][MAX_LEV_FIELDX][MAX_LEV_FIELDY]; static int undo_buffer_position = 0; static int undo_buffer_steps = 0; @@ -145,6 +246,7 @@ static int random_placement_method = RANDOM_USE_NUM_OBJECTS; /* pointer to score value */ static int *gadget_score_value; +static int *gadget_areas_value; static int level_xpos,level_ypos; static int edit_mode; @@ -153,7 +255,8 @@ static int new_element1 = EL_MAUERWERK; static int new_element2 = EL_LEERRAUM; static int new_element3 = EL_ERDREICH; -int element_shift; +int element_shift = 0; + int editor_element[] = { EL_CHAR_A + ('B' - 'A'), @@ -177,7 +280,7 @@ int editor_element[] = EL_BETON, EL_FELSBODEN, - EL_SIEB2_LEER, + EL_SIEB2_INAKTIV, EL_AUSGANG_ZU, EL_AUSGANG_AUF, @@ -224,7 +327,7 @@ int editor_element[] = EL_BETON, EL_MAUERWERK, EL_FELSBODEN, - EL_SIEB_LEER, + EL_SIEB_INAKTIV, EL_EDELSTEIN, EL_DIAMANT, @@ -336,6 +439,11 @@ int editor_element[] = EL_MAUER_Y, EL_MAUER_XY, + EL_SPEED_PILL, + EL_LEERRAUM, + EL_LEERRAUM, + EL_LEERRAUM, + EL_CHAR_A + ('S' - 'A'), EL_CHAR_A + ('O' - 'A'), EL_CHAR_A + ('K' - 'A'), @@ -351,6 +459,71 @@ int editor_element[] = EL_SOKOBAN_FELD_VOLL, EL_BETON, + EL_LEERRAUM, + EL_LEERRAUM, + EL_LEERRAUM, + EL_LEERRAUM, + + EL_CHAR('S'), + EL_CHAR('U'), + EL_CHAR('P'), + EL_CHAR('A'), + + EL_CHAR('P'), + EL_CHAR('L'), + EL_CHAR('E'), + EL_CHAR('X'), + + EL_SP_EMPTY, + EL_SP_ZONK, + EL_SP_BASE, + EL_SP_MURPHY, + + EL_SP_INFOTRON, + EL_SP_CHIP_SINGLE, + EL_SP_HARD_GRAY, + EL_SP_EXIT, + + EL_SP_DISK_ORANGE, + EL_SP_PORT1_RIGHT, + EL_SP_PORT1_DOWN, + EL_SP_PORT1_LEFT, + + EL_SP_PORT1_UP, + EL_SP_PORT2_RIGHT, + EL_SP_PORT2_DOWN, + EL_SP_PORT2_LEFT, + + EL_SP_PORT2_UP, + EL_SP_SNIKSNAK, + EL_SP_DISK_YELLOW, + EL_SP_TERMINAL, + + EL_SP_DISK_RED, + EL_SP_PORT_Y, + EL_SP_PORT_X, + EL_SP_PORT_XY, + + EL_SP_ELECTRON, + EL_SP_BUG, + EL_SP_CHIP_LEFT, + EL_SP_CHIP_RIGHT, + + EL_SP_HARD_BASE1, + EL_SP_HARD_GREEN, + EL_SP_HARD_BLUE, + EL_SP_HARD_RED, + + EL_SP_HARD_YELLOW, + EL_SP_HARD_BASE2, + EL_SP_HARD_BASE3, + EL_SP_HARD_BASE4, + + EL_SP_HARD_BASE5, + EL_SP_HARD_BASE6, + EL_SP_CHIP_UPPER, + EL_SP_CHIP_LOWER, + /* EL_CHAR_A + ('D' - 'A'), EL_CHAR_A + ('Y' - 'A'), @@ -445,31 +618,35 @@ int editor_element[] = EL_CHAR_OE, EL_CHAR_UE, - EL_CHAR_COPY + EL_CHAR_COPY, + EL_LEERRAUM }; int elements_in_list = sizeof(editor_element)/sizeof(int); static void ScrollMiniLevel(int from_x, int from_y, int scroll) { int x,y; - int dx = (scroll==ED_SCROLL_LEFT ? -1 : scroll==ED_SCROLL_RIGHT ? 1 : 0); - int dy = (scroll==ED_SCROLL_UP ? -1 : scroll==ED_SCROLL_DOWN ? 1 : 0); - - XCopyArea(display,drawto,drawto,gc, - SX+MINI_TILEX*(dx==-1),SY+MINI_TILEY*(dy==-1), - SXSIZE-MINI_TILEX*ABS(dx),SYSIZE-MINI_TILEY*ABS(dy), - SX+MINI_TILEX*(dx==+1),SY+MINI_TILEY*(dy==+1)); + int dx = (scroll == ED_SCROLL_LEFT ? -1 : scroll == ED_SCROLL_RIGHT ? 1 : 0); + int dy = (scroll == ED_SCROLL_UP ? -1 : scroll == ED_SCROLL_DOWN ? 1 : 0); + + XCopyArea(display, drawto, drawto, gc, + SX + (dx == -1 ? MINI_TILEX : 0), + SY + (dy == -1 ? MINI_TILEY : 0), + (ED_FIELDX * MINI_TILEX) - (dx != 0 ? MINI_TILEX : 0), + (ED_FIELDY * MINI_TILEY) - (dy != 0 ? MINI_TILEY : 0), + SX + (dx == +1 ? MINI_TILEX : 0), + SY + (dy == +1 ? MINI_TILEY : 0)); if (dx) { - x = (dx==1 ? 0 : 2*SCR_FIELDX-1); - for(y=0;y<2*SCR_FIELDY;y++) - DrawMiniElementOrWall(x,y,from_x,from_y); + x = (dx == 1 ? 0 : ED_FIELDX - 1); + for(y=0; yevent.type; - - printf("HandleControlButtons: (%d,%d) (%d,%d) [%d] ", - gi->x, gi->y, - gi->event.x, gi->event.y, gi->event.button); - - if (event_type == GD_EVENT_PRESSED) - printf("GD_EVENT_PRESSED\n"); - else if (event_type == GD_EVENT_RELEASED) - printf("GD_EVENT_RELEASED\n"); - else if (event_type == GD_EVENT_MOVING) - printf("GD_EVENT_MOVING\n"); - else - printf("?\n"); -} - -#endif - - -static void CreateCounterButtons(int counter_id) -{ - int i; - - for (i=0; i<2; i++) + /* create buttons for scrolling of drawing area */ + for (i=0; i lev_fieldx - 2*SCR_FIELDX + 1) - level_xpos = lev_fieldx - 2*SCR_FIELDX + 1; - if (lev_fieldx < 2*SCR_FIELDX - 2) + if (level_xpos > lev_fieldx - ED_FIELDX + 1) + level_xpos = lev_fieldx - ED_FIELDX + 1; + if (lev_fieldx < ED_FIELDX - 2) level_xpos = -1; if (level_ypos < -1) level_ypos = -1; - if (level_ypos > lev_fieldy - 2*SCR_FIELDY + 1) - level_ypos = lev_fieldy - 2*SCR_FIELDY + 1; - if (lev_fieldy < 2*SCR_FIELDY - 2) + if (level_ypos > lev_fieldy - ED_FIELDY + 1) + level_ypos = lev_fieldy - ED_FIELDY + 1; + if (lev_fieldy < ED_FIELDY - 2) level_ypos = -1; } +static void PickDrawingElement(int button, int element) +{ + if (button < 1 || button > 3) + return; + + if (button == 1) + { + new_element1 = element; + DrawMiniGraphicExt(drawto, gc, + DX + ED_WIN_MB_LEFT_XPOS, + DY + ED_WIN_MB_LEFT_YPOS, + el2gfx(new_element1)); + } + else if (button == 2) + { + new_element2 = element; + DrawMiniGraphicExt(drawto, gc, + DX + ED_WIN_MB_MIDDLE_XPOS, + DY + ED_WIN_MB_MIDDLE_YPOS, + el2gfx(new_element2)); + } + else + { + new_element3 = element; + DrawMiniGraphicExt(drawto, gc, + DX + ED_WIN_MB_RIGHT_XPOS, + DY + ED_WIN_MB_RIGHT_YPOS, + el2gfx(new_element3)); + } + + redraw_mask |= REDRAW_DOOR_1; +} + void LevelEd(int mx, int my, int button) { static int last_button = 0; @@ -1019,9 +1444,9 @@ void LevelEd(int mx, int my, int button) if (x>lev_fieldx || y>lev_fieldy || (x==0 && level_xpos<0) || - (x==2*SCR_FIELDX-1 && level_xpos>lev_fieldx-2*SCR_FIELDX) || + (x==ED_FIELDX-1 && level_xpos>lev_fieldx-ED_FIELDX) || (y==0 && level_ypos<0) || - (y==2*SCR_FIELDY-1 && level_ypos>lev_fieldy-2*SCR_FIELDY)) + (y==ED_FIELDY-1 && level_ypos>lev_fieldy-ED_FIELDY)) return; from_x = x+level_xpos; @@ -1056,11 +1481,18 @@ void LevelEd(int mx, int my, int button) element_shiftelements_in_list-MAX_ELEM_X*MAX_ELEM_Y) @@ -1080,29 +1512,14 @@ void LevelEd(int mx, int my, int button) else new_element = EL_LEERRAUM; - if (last_button==1) - new_element1 = new_element; - else if (last_button==2) - new_element2 = new_element; - else if (last_button==3) - new_element3 = new_element; - - DrawMiniGraphicExt(drawto,gc, - DX+ED_WIN_MB_LEFT_XPOS, - DY+ED_WIN_MB_LEFT_YPOS, - el2gfx(new_element1)); - DrawMiniGraphicExt(drawto,gc, - DX+ED_WIN_MB_MIDDLE_XPOS, - DY+ED_WIN_MB_MIDDLE_YPOS, - el2gfx(new_element2)); - DrawMiniGraphicExt(drawto,gc, - DX+ED_WIN_MB_RIGHT_XPOS, - DY+ED_WIN_MB_RIGHT_YPOS, - el2gfx(new_element3)); - redraw_mask |= REDRAW_DOOR_1; - - if (edit_mode == ED_MODE_PROPERTIES) - DrawPropertiesWindow(new_element); + PickDrawingElement(last_button, new_element); + + if (!HAS_CONTENT(properties_element)) + { + properties_element = new_element; + if (edit_mode == ED_MODE_PROPERTIES) + DrawPropertiesWindow(); + } } if (edit_mode == ED_MODE_DRAWING) /********** EDIT-FENSTER **********/ @@ -1134,7 +1551,7 @@ void LevelEd(int mx, int my, int button) { if (!DelayReached(&choice_delay, GADGET_FRAME_DELAY)) break; - if (lev_fieldx<2*SCR_FIELDX-2) + if (lev_fieldxlev_fieldx-2*SCR_FIELDX+1) - level_xpos = lev_fieldx-2*SCR_FIELDX+1; + 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 @@ -1168,7 +1585,7 @@ void LevelEd(int mx, int my, int button) { if (!DelayReached(&choice_delay, GADGET_FRAME_DELAY)) break; - if (lev_fieldy<2*SCR_FIELDY-2) + if (lev_fieldylev_fieldy-2*SCR_FIELDY+1) - level_ypos = lev_fieldy-2*SCR_FIELDY+1; + 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 @@ -1216,9 +1633,9 @@ void LevelEd(int mx, int my, int button) if (!button || !in_field_pressed || button<1 || button>3 || (y==0 && level_ypos<0) || - (y==2*SCR_FIELDY-1 && level_ypos>lev_fieldy-2*SCR_FIELDY) || + (y==ED_FIELDY-1 && level_ypos>lev_fieldy-ED_FIELDY) || (x==0 && level_xpos<0) || - (x==2*SCR_FIELDX-1 && level_xpos>lev_fieldx-2*SCR_FIELDX) || + (x==ED_FIELDX-1 && level_xpos>lev_fieldx-ED_FIELDX) || x>lev_fieldx || y>lev_fieldy) return; @@ -1237,8 +1654,8 @@ void LevelEd(int mx, int my, int button) if (Feld[x][y]==EL_SPIELFIGUR || Feld[x][y]==EL_SPIELER1) { Feld[x][y] = EL_LEERRAUM; - if (x-level_xpos>=0 && x-level_xpos<2*SCR_FIELDX && - y-level_ypos>=0 && y-level_ypos<2*SCR_FIELDY) + if (x-level_xpos>=0 && x-level_xpos=0 && y-level_ypos to_x) + swap_numbers(&from_x, &to_x); - safety++; + if (from_y > to_y) + swap_numbers(&from_y, &to_y); + + from_sx = SX + from_x * MINI_TILEX; + from_sy = SY + from_y * MINI_TILEY; + to_sx = SX + to_x * MINI_TILEX + MINI_TILEX - 1; + to_sy = SY + to_y * MINI_TILEY + MINI_TILEY - 1; + + XSetForeground(display, gc, WhitePixel(display, screen)); + + XDrawLine(display, drawto, gc, from_sx, from_sy, to_sx, from_sy); + XDrawLine(display, drawto, gc, to_sx, from_sy, to_sx, to_sy); + XDrawLine(display, drawto, gc, to_sx, to_sy, from_sx, to_sy); + XDrawLine(display, drawto, gc, from_sx, to_sy, from_sx, from_sy); + + XSetForeground(display, gc, BlackPixel(display, screen)); + + if (from_x == to_x && from_y == to_y) + MarkTileDirty(from_x/2, from_y/2); + else + redraw_mask |= REDRAW_FIELD; +} + +static void SelectArea(int from_x, int from_y, int to_x, int to_y, + int element, boolean change_level) +{ + if (element == -1 || change_level) + DrawRectangle(from_x, from_y, to_x, to_y, -1, FALSE); + else + DrawAreaBorder(from_x, from_y, to_x, to_y); +} + +/* values for CopyBrushExt() */ +#define CB_AREA_TO_BRUSH 0 +#define CB_BRUSH_TO_LEVEL 1 + +static void CopyBrushExt(int from_x, int from_y, int to_x, int to_y, int mode) +{ + static short brush_buffer[MAX_LEV_FIELDX][MAX_LEV_FIELDY]; + static brush_from_x, brush_from_y; + static brush_to_x, brush_to_y; + int x, y; + + if (from_x > to_x) + swap_numbers(&from_x, &to_x); + + if (from_y > to_y) + swap_numbers(&from_y, &to_y); + + if (mode == CB_AREA_TO_BRUSH) + { + for (y=from_y; y<=to_y; y++) + for (x=from_x; x<=to_x; x++) + brush_buffer[x][y] = Feld[x][y]; + + brush_from_x = from_x; + brush_from_y = from_y; + brush_to_x = to_x; + brush_to_y = to_y; + } + else + { + for (y=brush_from_y; y<=brush_to_y; y++) + for (x=brush_from_x; x<=brush_to_x; x++) + Feld[x][y] = brush_buffer[x][y]; + CopyLevelToUndoBuffer(UNDO_IMMEDIATE); + } +} + +static void CopyAreaToBrush(int from_x, int from_y, int to_x, int to_y) +{ + CopyBrushExt(from_x, from_y, to_x, to_y, CB_AREA_TO_BRUSH); +} + +#if 0 +static void CopyBrushToLevel() +{ + CopyBrushExt(0, 0, 0, 0, CB_BRUSH_TO_LEVEL); +} +#endif + +static void FloodFill(int from_x, int from_y, int fill_element) +{ + int i,x,y; + int old_element; + static int check[4][2] = { {-1,0}, {0,-1}, {1,0}, {0,1} }; + static int safety = 0; + + /* check if starting field still has the desired content */ + if (Feld[from_x][from_y] == fill_element) + return; + + safety++; if (safety > lev_fieldx*lev_fieldy) Error(ERR_EXIT, "Something went wrong in 'FloodFill()'. Please debug."); @@ -1914,24 +2555,138 @@ static void FloodFill(int from_x, int from_y, int fill_element) safety--; } -static void CopyLevelToUndoBuffer() +/* values for DrawLevelText() modes */ +#define TEXT_INIT 0 +#define TEXT_SETCURSOR 1 +#define TEXT_WRITECHAR 2 +#define TEXT_BACKSPACE 3 +#define TEXT_NEWLINE 4 +#define TEXT_END 5 + +static void DrawLevelText(int sx, int sy, char letter, int mode) { + static short delete_buffer[MAX_LEV_FIELDX]; + static int start_sx, start_sy; + static int last_sx, last_sy; + static boolean typing = FALSE; + int letter_element = EL_CHAR_ASCII0 + letter; + int lx, ly; + + if (mode != TEXT_INIT) + { + if (!typing) + return; + + if (mode != TEXT_SETCURSOR) + { + sx = last_sx; + sy = last_sy; + } + + lx = last_sx + level_xpos; + ly = last_sy + level_ypos; + } + + switch (mode) + { + case TEXT_INIT: + if (typing) + DrawLevelText(0, 0, 0, TEXT_END); + + typing = TRUE; + start_sx = last_sx = sx; + start_sy = last_sy = sy; + DrawLevelText(sx, sy, 0, TEXT_SETCURSOR); + break; + + case TEXT_SETCURSOR: + DrawMiniElement(last_sx, last_sy, Feld[lx][ly]); + DrawAreaBorder(sx, sy, sx, sy); + last_sx = sx; + last_sy = sy; + break; + + case TEXT_WRITECHAR: + if (letter_element >= EL_CHAR_START && letter_element <= EL_CHAR_END) + { + delete_buffer[sx - start_sx] = Feld[lx][ly]; + Feld[lx][ly] = letter_element; + + if (sx + 1 < ED_FIELDX && lx + 1 < lev_fieldx) + DrawLevelText(sx + 1, sy, 0, TEXT_SETCURSOR); + else if (sy + 1 < ED_FIELDY && ly + 1 < lev_fieldy) + DrawLevelText(start_sx, sy + 1, 0, TEXT_SETCURSOR); + else + DrawLevelText(0, 0, 0, TEXT_END); + } + break; + + case TEXT_BACKSPACE: + if (sx > start_sx) + { + Feld[lx - 1][ly] = delete_buffer[sx - start_sx - 1]; + DrawMiniElement(sx - 1, sy, new_element3); + DrawLevelText(sx - 1, sy, 0, TEXT_SETCURSOR); + } + break; + + case TEXT_NEWLINE: + if (sy + 1 < ED_FIELDY - 1 && ly + 1 < lev_fieldy - 1) + DrawLevelText(start_sx, sy + 1, 0, TEXT_SETCURSOR); + else + DrawLevelText(0, 0, 0, TEXT_END); + break; + + case TEXT_END: + CopyLevelToUndoBuffer(UNDO_IMMEDIATE); + DrawMiniElement(sx, sy, Feld[lx][ly]); + typing = FALSE; + break; + + default: + break; + } +} + +static void CopyLevelToUndoBuffer(int mode) +{ + static boolean accumulated_undo = FALSE; + boolean new_undo_buffer_position = TRUE; int x, y; - undo_buffer_position = (undo_buffer_position + 1) % NUM_UNDO_STEPS; + switch (mode) + { + case UNDO_IMMEDIATE: + accumulated_undo = FALSE; + break; - if (undo_buffer_steps < NUM_UNDO_STEPS - 1) - undo_buffer_steps++; + case UNDO_ACCUMULATE: + if (accumulated_undo) + new_undo_buffer_position = FALSE; + accumulated_undo = TRUE; + break; - for(x=0; xcustom_id; boolean inside_drawing_area = !gi->event.off_borders; boolean button_press_event; boolean button_release_event; + boolean draw_level = (id == ED_CTRL_ID_DRAWING_LEVEL); int new_element; int button = gi->event.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, ly; + int min_lx = 0, min_ly = 0; + int max_lx = lev_fieldx - 1, max_ly = lev_fieldy - 1; int x, y; + /* 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); - sx = (sx < 0 ? 0 : sx > 2*SCR_FIELDX - 1 ? 2*SCR_FIELDX - 1 : sx); - sy = (sy < 0 ? 0 : sy > 2*SCR_FIELDY - 1 ? 2*SCR_FIELDY - 1 : sy); - lx = sx + level_xpos; - ly = sy + level_ypos; + /* 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; + + /* 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; @@ -1999,52 +2797,68 @@ static void HandleDrawingAreas(struct GadgetInfo *gi) if (!started_inside_drawing_area) return; - printf("%d,%d, %d,%d, %d,%d.\n", - gi->event.x, gi->event.y, sx, sy, lx, ly); - - if ((!button && !button_release_event) || - sx > lev_fieldx || sy > lev_fieldy || - (sx == 0 && level_xpos<0) || - (sx == 2*SCR_FIELDX - 1 && level_xpos > lev_fieldx - 2*SCR_FIELDX) || - (sy == 0 && level_ypos < 0) || - (sy == 2*SCR_FIELDY - 1 && level_ypos > lev_fieldy - 2*SCR_FIELDY)) + if (!button && !button_release_event) return; new_element = (button == 1 ? new_element1 : button == 2 ? new_element2 : button == 3 ? new_element3 : 0); + if (!draw_level && drawing_function != ED_CTRL_ID_SINGLE_ITEMS) + return; + switch (drawing_function) { case ED_CTRL_ID_SINGLE_ITEMS: - if (button_release_event) - CopyLevelToUndoBuffer(); + if (draw_level) + { + if (button_release_event) + CopyLevelToUndoBuffer(UNDO_IMMEDIATE); - if (!button) - break; + if (!button) + break; - if (new_element != Feld[lx][ly]) - { - if (new_element == EL_SPIELFIGUR) + if (new_element != Feld[lx][ly]) { - /* remove player at old position */ - for(y=0; y= 0 && x - level_xpos < 2*SCR_FIELDX && - y - level_ypos >= 0 && y - level_ypos < 2*SCR_FIELDY) - DrawMiniElement(x - level_xpos, y - level_ypos, EL_LEERRAUM); + 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); + 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 == ED_CTRL_ID_AMOEBA_CONTENT) + level.amoebe_inhalt = new_element; + else if (id >= ED_CTRL_ID_ELEMCONT_0 && id <= ED_CTRL_ID_ELEMCONT_7) + level.mampfer_inhalt[id - ED_CTRL_ID_ELEMCONT_0][sx][sy] = + new_element; } break; @@ -2054,7 +2868,7 @@ static void HandleDrawingAreas(struct GadgetInfo *gi) static int last_sy = -1; if (button_release_event) - CopyLevelToUndoBuffer(); + CopyLevelToUndoBuffer(UNDO_IMMEDIATE); if (button) { @@ -2070,6 +2884,7 @@ static void HandleDrawingAreas(struct GadgetInfo *gi) case ED_CTRL_ID_LINE: case ED_CTRL_ID_RECTANGLE: case ED_CTRL_ID_FILLED_BOX: + case ED_CTRL_ID_BRUSH: { static int last_sx = -1; static int last_sy = -1; @@ -2081,19 +2896,27 @@ static void HandleDrawingAreas(struct GadgetInfo *gi) draw_func = DrawLine; else if (drawing_function == ED_CTRL_ID_RECTANGLE) draw_func = DrawRectangle; - else + else if (drawing_function == ED_CTRL_ID_FILLED_BOX) draw_func = DrawFilledBox; + else + draw_func = SelectArea; if (button_press_event) { - last_sx = start_sx = sx; - last_sy = start_sy = sy; draw_func(sx, sy, sx, sy, new_element, FALSE); + start_sx = last_sx = sx; + start_sy = last_sy = sy; } else if (button_release_event) { draw_func(start_sx, start_sy, sx, sy, new_element, TRUE); - CopyLevelToUndoBuffer(); + if (drawing_function == ED_CTRL_ID_BRUSH) + { + CopyAreaToBrush(start_sx, start_sy, sx, sy); + draw_with_brush = TRUE; + } + else + CopyLevelToUndoBuffer(UNDO_IMMEDIATE); } else if (last_sx != sx || last_sy != sy) { @@ -2105,141 +2928,32 @@ static void HandleDrawingAreas(struct GadgetInfo *gi) } break; + case ED_CTRL_ID_TEXT: + if (button_press_event) + DrawLevelText(sx, sy, 0, TEXT_INIT); + break; + case ED_CTRL_ID_FLOOD_FILL: if (button_press_event && Feld[lx][ly] != new_element) { FloodFill(lx, ly, new_element); DrawMiniLevel(level_xpos, level_ypos); - CopyLevelToUndoBuffer(); + CopyLevelToUndoBuffer(UNDO_IMMEDIATE); } break; - default: + case ED_CTRL_ID_PICK_ELEMENT: + if (button_press_event) + PickDrawingElement(button, Feld[lx][ly]); + if (button_release_event) + ClickOnGadget(level_editor_gadget[last_drawing_function]); break; - } -} - - -#if 0 - -static void HandlePressedControlButtons() -{ - static unsigned long button_delay = 0; - int i; - - /* buttons with action when held pressed */ - int gadget_id[] = - { - ED_CTRL_ID_WRAP_UP, - ED_CTRL_ID_WRAP_LEFT, - ED_CTRL_ID_WRAP_RIGHT, - ED_CTRL_ID_WRAP_DOWN, - ED_CTRL_ID_SCORE_DOWN, - ED_CTRL_ID_SCORE_UP, - -1 - }; - - if (!DelayReached(&button_delay, GADGET_FRAME_DELAY)) - return; - - for (i=0; gadget_id[i] != -1; i++) - { - int id = gadget_id[i]; - int state = level_editor_gadget[id]->state; - int button = level_editor_gadget[id]->event.button; - int step = (button == 1 ? 1 : button == 2 ? 5 : 10); - - if (state != GD_BUTTON_PRESSED) - continue; - - switch (id) - { - case ED_CTRL_ID_WRAP_LEFT: - if (level_xpos >= 0) - { - if (lev_fieldx < 2*SCR_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(level_xpos, level_ypos); - } - break; - - case ED_CTRL_ID_WRAP_RIGHT: - if (level_xpos <= lev_fieldx - 2*SCR_FIELDX) - { - if (lev_fieldx < 2*SCR_FIELDX - 2) - break; - - level_xpos += step; - if (level_xpos > lev_fieldx - 2*SCR_FIELDX + 1) - level_xpos = lev_fieldx - 2*SCR_FIELDX + 1; - if (button == 1) - ScrollMiniLevel(level_xpos, level_ypos, ED_SCROLL_LEFT); - else - DrawMiniLevel(level_xpos, level_ypos); - } - break; - - case ED_CTRL_ID_WRAP_UP: - if (level_ypos >= 0) - { - if (lev_fieldy < 2*SCR_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(level_xpos, level_ypos); - } - break; - - case ED_CTRL_ID_WRAP_DOWN: - if (level_ypos <= lev_fieldy - 2*SCR_FIELDY) - { - if (lev_fieldy < 2*SCR_FIELDY - 2) - break; - - level_ypos += step; - if (level_ypos > lev_fieldy - 2*SCR_FIELDY + 1) - level_ypos = lev_fieldy - 2*SCR_FIELDY + 1; - if (button == 1) - ScrollMiniLevel(level_xpos, level_ypos, ED_SCROLL_UP); - else - DrawMiniLevel(level_xpos, level_ypos); - } - break; - - case ED_CTRL_ID_SCORE_DOWN: - case ED_CTRL_ID_SCORE_UP: - *gadget_score_value += (id == ED_CTRL_ID_SCORE_DOWN ? -step : step); - if (*gadget_score_value < 0) - *gadget_score_value = 0; - else if (*gadget_score_value > 255) - *gadget_score_value = 255; - - DrawCounterValueField(ED_COUNTER_SCORE, *gadget_score_value); - break; - - default: - break; - } + default: + break; } } -#endif - - - static void HandleCounterButtons(struct GadgetInfo *gi) { int id = gi->custom_id; @@ -2259,6 +2973,18 @@ static void HandleCounterButtons(struct GadgetInfo *gi) DrawCounterValueField(ED_COUNTER_SCORE, *gadget_score_value); break; + case ED_CTRL_ID_ELEMCONT_DOWN: + case ED_CTRL_ID_ELEMCONT_UP: + *gadget_areas_value += (id == ED_CTRL_ID_ELEMCONT_DOWN ? -step : step); + if (*gadget_areas_value < 1) + *gadget_areas_value = 1; + else if (*gadget_areas_value > MAX_ELEMCONT) + *gadget_areas_value = MAX_ELEMCONT; + + DrawCounterValueField(ED_COUNTER_ELEMCONT, *gadget_areas_value); + DrawElementContentAreas(); + break; + default: break; } @@ -2278,7 +3004,11 @@ static void HandleControlButtons(struct GadgetInfo *gi) button == 2 ? new_element2 : button == 3 ? new_element3 : 0); - if (id < ED_NUM_CTRL1_BUTTONS && edit_mode != ED_MODE_DRAWING) + if (edit_mode == ED_MODE_DRAWING && drawing_function == ED_CTRL_ID_TEXT) + DrawLevelText(0, 0, 0, TEXT_END); + + if (id < ED_NUM_CTRL1_BUTTONS && id != ED_CTRL_ID_PROPERTIES && + edit_mode != ED_MODE_DRAWING) { DrawDrawingWindow(); edit_mode = ED_MODE_DRAWING; @@ -2286,53 +3016,58 @@ static void HandleControlButtons(struct GadgetInfo *gi) switch (id) { - case ED_CTRL_ID_SINGLE_ITEMS: - case ED_CTRL_ID_CONNECTED_ITEMS: - case ED_CTRL_ID_LINE: - case ED_CTRL_ID_TEXT: - case ED_CTRL_ID_RECTANGLE: - case ED_CTRL_ID_FILLED_BOX: - case ED_CTRL_ID_FLOOD_FILL: - case ED_CTRL_ID_BRUSH: - drawing_function = id; - break; - - case ED_CTRL_ID_WRAP_LEFT: + case ED_CTRL_ID_SCROLL_LEFT: if (level_xpos >= 0) { - if (lev_fieldx < 2*SCR_FIELDX - 2) + int gadget_id = ED_CTRL_ID_SCROLL_HORIZONTAL; + struct GadgetInfo *gi = level_editor_gadget[gadget_id]; + struct GadgetScrollbar *gs = &gi->scrollbar; + + if (lev_fieldx < ED_FIELDX - 2) break; level_xpos -= step; - if (level_xpos <- 1) + if (level_xpos < -1) level_xpos = -1; if (button == 1) ScrollMiniLevel(level_xpos, level_ypos, ED_SCROLL_RIGHT); else DrawMiniLevel(level_xpos, level_ypos); + + AdjustScrollbar(gi, gs->items_max, level_xpos + 1); } break; - case ED_CTRL_ID_WRAP_RIGHT: - if (level_xpos <= lev_fieldx - 2*SCR_FIELDX) + case ED_CTRL_ID_SCROLL_RIGHT: + if (level_xpos <= lev_fieldx - ED_FIELDX) { - if (lev_fieldx < 2*SCR_FIELDX - 2) + int gadget_id = ED_CTRL_ID_SCROLL_HORIZONTAL; + struct GadgetInfo *gi = level_editor_gadget[gadget_id]; + struct GadgetScrollbar *gs = &gi->scrollbar; + + if (lev_fieldx < ED_FIELDX - 2) break; level_xpos += step; - if (level_xpos > lev_fieldx - 2*SCR_FIELDX + 1) - level_xpos = lev_fieldx - 2*SCR_FIELDX + 1; + 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(level_xpos, level_ypos); + + AdjustScrollbar(gi, gs->items_max, level_xpos + 1); } break; - case ED_CTRL_ID_WRAP_UP: + case ED_CTRL_ID_SCROLL_UP: if (level_ypos >= 0) { - if (lev_fieldy < 2*SCR_FIELDY - 2) + int gadget_id = ED_CTRL_ID_SCROLL_VERTICAL; + struct GadgetInfo *gi = level_editor_gadget[gadget_id]; + struct GadgetScrollbar *gs = &gi->scrollbar; + + if (lev_fieldy < ED_FIELDY - 2) break; level_ypos -= step; @@ -2342,33 +3077,88 @@ static void HandleControlButtons(struct GadgetInfo *gi) ScrollMiniLevel(level_xpos, level_ypos, ED_SCROLL_DOWN); else DrawMiniLevel(level_xpos, level_ypos); + + AdjustScrollbar(gi, gs->items_max, level_ypos + 1); } break; - case ED_CTRL_ID_WRAP_DOWN: - if (level_ypos <= lev_fieldy - 2*SCR_FIELDY) + case ED_CTRL_ID_SCROLL_DOWN: + if (level_ypos <= lev_fieldy - ED_FIELDY) { - if (lev_fieldy < 2*SCR_FIELDY - 2) + int gadget_id = ED_CTRL_ID_SCROLL_VERTICAL; + struct GadgetInfo *gi = level_editor_gadget[gadget_id]; + struct GadgetScrollbar *gs = &gi->scrollbar; + + if (lev_fieldy < ED_FIELDY - 2) break; level_ypos += step; - if (level_ypos > lev_fieldy - 2*SCR_FIELDY + 1) - level_ypos = lev_fieldy - 2*SCR_FIELDY + 1; + 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(level_xpos, level_ypos); + + AdjustScrollbar(gi, gs->items_max, level_ypos + 1); } break; - case ED_CTRL_ID_PROPERTIES: - DrawPropertiesWindow(new_element); - edit_mode = ED_MODE_PROPERTIES; + case ED_CTRL_ID_SCROLL_HORIZONTAL: + level_xpos = gi->event.item_position - 1; + DrawMiniLevel(level_xpos, level_ypos); + break; + + case ED_CTRL_ID_SCROLL_VERTICAL: + level_ypos = gi->event.item_position - 1; + DrawMiniLevel(level_xpos, level_ypos); + break; + + case ED_CTRL_ID_WRAP_LEFT: + WrapLevel(-step, 0); + break; + + case ED_CTRL_ID_WRAP_RIGHT: + WrapLevel(step, 0); + break; + + case ED_CTRL_ID_WRAP_UP: + WrapLevel(0, -step); + break; + + case ED_CTRL_ID_WRAP_DOWN: + WrapLevel(0, step); + break; + + case ED_CTRL_ID_SINGLE_ITEMS: + case ED_CTRL_ID_CONNECTED_ITEMS: + case ED_CTRL_ID_LINE: + case ED_CTRL_ID_TEXT: + case ED_CTRL_ID_RECTANGLE: + case ED_CTRL_ID_FILLED_BOX: + case ED_CTRL_ID_FLOOD_FILL: + case ED_CTRL_ID_BRUSH: + case ED_CTRL_ID_PICK_ELEMENT: + last_drawing_function = drawing_function; + drawing_function = id; break; case ED_CTRL_ID_RANDOM_PLACEMENT: RandomPlacement(button); - CopyLevelToUndoBuffer(); + break; + + case ED_CTRL_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 ED_CTRL_ID_UNDO: @@ -2396,8 +3186,7 @@ static void HandleControlButtons(struct GadgetInfo *gi) } else { - AdjustLevelScrollPosition(); - DrawMiniLevel(level_xpos, level_ypos); + DrawDrawingWindow(); edit_mode = ED_MODE_DRAWING; } break; @@ -2406,7 +3195,7 @@ static void HandleControlButtons(struct GadgetInfo *gi) for(x=0; xevent.type == GD_EVENT_PRESSED) printf("default: HandleControlButtons: GD_EVENT_PRESSED\n"); else if (gi->event.type == GD_EVENT_RELEASED) @@ -2517,6 +3328,47 @@ static void HandleControlButtons(struct GadgetInfo *gi) printf("default: HandleControlButtons: GD_EVENT_MOVING\n"); else printf("default: HandleControlButtons: ?\n"); +#endif + break; + } +} + +void HandleLevelEditorKeyInput(KeySym key) +{ + if (edit_mode == ED_MODE_DRAWING && drawing_function == ED_CTRL_ID_TEXT) + { + char letter = getCharFromKeySym(key); + + /* map lower case letters to upper case */ + if (letter >= 'a' && letter <= 'z') + letter += (int)('A' - 'a'); + else if (letter == 'ä') + letter = 'Ä'; + else if (letter == 'ä') + letter = 'Ö'; + else if (letter == 'ä') + letter = 'Ü'; + + 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); + } +} + +static void HandleTextInputGadgets(struct GadgetInfo *gi) +{ + int id = gi->custom_id; + + switch (id) + { + case ED_CTRL_ID_LEVEL_NAME: + strcpy(level.name, gi->text_value); + break; + + default: break; } }