X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Ftools.c;h=603ebdaa9a949e8d6945679265e363bc2419389b;hb=92a3daab2223b297cdb51fa9763c6acad423b2de;hp=abde1cc7b311b5bb60b7f1562f79c55b181de9ab;hpb=7ecf99096c7c23909ada034e05d971464f66552f;p=rocksndiamonds.git

diff --git a/src/tools.c b/src/tools.c
index abde1cc7..603ebdaa 100644
--- a/src/tools.c
+++ b/src/tools.c
@@ -2465,49 +2465,59 @@ void DrawMiniElementOrWall(int sx, int sy, int scroll_x, int scroll_y)
     DrawMiniGraphic(sx, sy, el2edimg(getBorderElement(x, y)));
 }
 
-void DrawEnvelopeBackground(int envelope_nr, int startx, int starty,
-			    int x, int y, int xsize, int ysize, int font_nr)
+void DrawEnvelopeBackgroundTiles(int graphic, int startx, int starty,
+				 int x, int y, int xsize, int ysize,
+				 int tile_width, int tile_height)
 {
-  int font_width  = getFontWidth(font_nr);
-  int font_height = getFontHeight(font_nr);
-  int graphic = IMG_BACKGROUND_ENVELOPE_1 + envelope_nr;
   Bitmap *src_bitmap;
   int src_x, src_y;
-  int dst_x = SX + startx + x * font_width;
-  int dst_y = SY + starty + y * font_height;
+  int dst_x = startx + x * tile_width;
+  int dst_y = starty + y * tile_height;
   int width  = graphic_info[graphic].width;
   int height = graphic_info[graphic].height;
-  int inner_width  = MAX(width  - 2 * font_width,  font_width);
-  int inner_height = MAX(height - 2 * font_height, font_height);
-  int inner_sx = (width >= 3 * font_width ? font_width : 0);
-  int inner_sy = (height >= 3 * font_height ? font_height : 0);
+  int inner_width_raw  = MAX(width  - 2 * tile_width,  tile_width);
+  int inner_height_raw = MAX(height - 2 * tile_height, tile_height);
+  int inner_width  = inner_width_raw  - (inner_width_raw  % tile_width);
+  int inner_height = inner_height_raw - (inner_height_raw % tile_height);
+  int inner_sx = (width  >= 3 * tile_width  ? tile_width  : 0);
+  int inner_sy = (height >= 3 * tile_height ? tile_height : 0);
   boolean draw_masked = graphic_info[graphic].draw_masked;
 
   getFixedGraphicSource(graphic, 0, &src_bitmap, &src_x, &src_y);
 
-  if (src_bitmap == NULL || width < font_width || height < font_height)
+  if (src_bitmap == NULL || width < tile_width || height < tile_height)
   {
-    ClearRectangle(drawto, dst_x, dst_y, font_width, font_height);
+    ClearRectangle(drawto, dst_x, dst_y, tile_width, tile_height);
     return;
   }
 
-  src_x += (x == 0 ? 0 : x == xsize - 1 ? width  - font_width  :
-	    inner_sx + (x - 1) * font_width  % inner_width);
-  src_y += (y == 0 ? 0 : y == ysize - 1 ? height - font_height :
-	    inner_sy + (y - 1) * font_height % inner_height);
+  src_x += (x == 0 ? 0 : x == xsize - 1 ? width  - tile_width  :
+	    inner_sx + (x - 1) * tile_width  % inner_width);
+  src_y += (y == 0 ? 0 : y == ysize - 1 ? height - tile_height :
+	    inner_sy + (y - 1) * tile_height % inner_height);
 
   if (draw_masked)
   {
     SetClipOrigin(src_bitmap, src_bitmap->stored_clip_gc,
 		  dst_x - src_x, dst_y - src_y);
-    BlitBitmapMasked(src_bitmap, drawto, src_x, src_y, font_width, font_height,
+    BlitBitmapMasked(src_bitmap, drawto, src_x, src_y, tile_width, tile_height,
 		     dst_x, dst_y);
   }
   else
-    BlitBitmap(src_bitmap, drawto, src_x, src_y, font_width, font_height,
+    BlitBitmap(src_bitmap, drawto, src_x, src_y, tile_width, tile_height,
 	       dst_x, dst_y);
 }
 
+void DrawEnvelopeBackground(int graphic, int startx, int starty,
+			    int x, int y, int xsize, int ysize, int font_nr)
+{
+  int font_width  = getFontWidth(font_nr);
+  int font_height = getFontHeight(font_nr);
+
+  DrawEnvelopeBackgroundTiles(graphic, startx, starty, x, y, xsize, ysize,
+			      font_width, font_height);
+}
+
 void AnimateEnvelope(int envelope_nr, int anim_mode, int action)
 {
   int graphic = IMG_BACKGROUND_ENVELOPE_1 + envelope_nr;
@@ -2535,27 +2545,32 @@ void AnimateEnvelope(int envelope_nr, int anim_mode, int action)
   {
     int xsize = (action == ACTION_CLOSING ? xend - (x - xstart) : x) + 2;
     int ysize = (action == ACTION_CLOSING ? yend - (y - ystart) : y) + 2;
-    int sx = (SXSIZE - xsize * font_width)  / 2;
-    int sy = (SYSIZE - ysize * font_height) / 2;
+    int sx = SX + (SXSIZE - xsize * font_width)  / 2;
+    int sy = SY + (SYSIZE - ysize * font_height) / 2;
     int xx, yy;
 
     SetDrawtoField(DRAW_BUFFERED);
 
+#if 1
+    BlitScreenToBitmap(backbuffer);
+#else
     BlitBitmap(fieldbuffer, backbuffer, FX, FY, SXSIZE, SYSIZE, SX, SY);
+#endif
 
     SetDrawtoField(DRAW_BACKBUFFER);
 
-    for (yy = 0; yy < ysize; yy++) for (xx = 0; xx < xsize; xx++)
-      DrawEnvelopeBackground(envelope_nr, sx,sy, xx,yy, xsize, ysize, font_nr);
+    for (yy = 0; yy < ysize; yy++)
+      for (xx = 0; xx < xsize; xx++)
+	DrawEnvelopeBackground(graphic, sx, sy, xx, yy, xsize, ysize, font_nr);
 
 #if 1
-    DrawTextBuffer(SX + sx + font_width, SY + sy + font_height,
+    DrawTextBuffer(sx + font_width, sy + font_height,
 		   level.envelope[envelope_nr].text, font_nr, max_xsize,
 		   xsize - 2, ysize - 2, 0, mask_mode,
 		   level.envelope[envelope_nr].autowrap,
 		   level.envelope[envelope_nr].centered, FALSE);
 #else
-    DrawTextToTextArea(SX + sx + font_width, SY + sy + font_height,
+    DrawTextToTextArea(sx + font_width, sy + font_height,
 		       level.envelope[envelope_nr].text, font_nr, max_xsize,
 		       xsize - 2, ysize - 2, mask_mode);
 #endif
@@ -2567,19 +2582,291 @@ void AnimateEnvelope(int envelope_nr, int anim_mode, int action)
   }
 }
 
-void AnimateEnvelopeDoor(char *text, int anim_mode, int action)
+void ShowEnvelope(int envelope_nr)
+{
+  int element = EL_ENVELOPE_1 + envelope_nr;
+  int graphic = IMG_BACKGROUND_ENVELOPE_1 + envelope_nr;
+  int sound_opening = element_info[element].sound[ACTION_OPENING];
+  int sound_closing = element_info[element].sound[ACTION_CLOSING];
+  boolean ffwd_delay = (tape.playing && tape.fast_forward);
+  boolean no_delay = (tape.warp_forward);
+  int normal_delay_value = ONE_SECOND_DELAY / (ffwd_delay ? 2 : 1);
+  int wait_delay_value = (no_delay ? 0 : normal_delay_value);
+  int anim_mode = graphic_info[graphic].anim_mode;
+  int main_anim_mode = (anim_mode == ANIM_NONE ? ANIM_VERTICAL|ANIM_HORIZONTAL:
+			anim_mode == ANIM_DEFAULT ? ANIM_VERTICAL : anim_mode);
+
+  game.envelope_active = TRUE;	/* needed for RedrawPlayfield() events */
+
+  PlayMenuSoundStereo(sound_opening, SOUND_MIDDLE);
+
+  if (anim_mode == ANIM_DEFAULT)
+    AnimateEnvelope(envelope_nr, ANIM_DEFAULT, ACTION_OPENING);
+
+  AnimateEnvelope(envelope_nr, main_anim_mode, ACTION_OPENING);
+
+  if (tape.playing)
+    Delay(wait_delay_value);
+  else
+    WaitForEventToContinue();
+
+  PlayMenuSoundStereo(sound_closing, SOUND_MIDDLE);
+
+  if (anim_mode != ANIM_NONE)
+    AnimateEnvelope(envelope_nr, main_anim_mode, ACTION_CLOSING);
+
+  if (anim_mode == ANIM_DEFAULT)
+    AnimateEnvelope(envelope_nr, ANIM_DEFAULT, ACTION_CLOSING);
+
+  game.envelope_active = FALSE;
+
+  SetDrawtoField(DRAW_BUFFERED);
+
+  redraw_mask |= REDRAW_FIELD;
+  BackToFront();
+}
+
+static void setRequestPosition(int *x, int *y, boolean add_border_size)
+{
+  int border_size = request.border_size;
+  int sx_center = (request.x != -1 ? request.x : SX + SXSIZE / 2);
+  int sy_center = (request.y != -1 ? request.y : SY + SYSIZE / 2);
+  int sx = sx_center - request.width  / 2;
+  int sy = sy_center - request.height / 2;
+
+  if (add_border_size)
+  {
+    sx += border_size;
+    sy += border_size;
+  }
+
+  *x = sx;
+  *y = sy;
+}
+
+void DrawEnvelopeRequest(char *text)
+{
+  char *text_final = text;
+  char *text_door_style = NULL;
+  int graphic = IMG_BACKGROUND_REQUEST;
+  Bitmap *src_bitmap = graphic_info[graphic].bitmap;
+  int mask_mode = (src_bitmap != NULL ? BLIT_MASKED : BLIT_ON_BACKGROUND);
+  int font_nr = FONT_REQUEST;
+  int font_width = getFontWidth(font_nr);
+  int font_height = getFontHeight(font_nr);
+  int border_size = request.border_size;
+  int line_spacing = request.line_spacing;
+  int line_height = font_height + line_spacing;
+  int text_width = request.width - 2 * border_size;
+  int text_height = request.height - 2 * border_size;
+  int line_length = text_width / font_width;
+  int max_lines = text_height / line_height;
+  int width = request.width;
+  int height = request.height;
+  int tile_size = request.step_offset;
+  int x_steps = width  / tile_size;
+  int y_steps = height / tile_size;
+  int sx, sy;
+  int i, x, y;
+
+  if (request.wrap_single_words)
+  {
+    char *src_text_ptr, *dst_text_ptr;
+
+    text_door_style = checked_malloc(2 * strlen(text) + 1);
+
+    src_text_ptr = text;
+    dst_text_ptr = text_door_style;
+
+    while (*src_text_ptr)
+    {
+      if (*src_text_ptr == ' ' ||
+	  *src_text_ptr == '?' ||
+	  *src_text_ptr == '!')
+	*dst_text_ptr++ = '\n';
+
+      if (*src_text_ptr != ' ')
+	*dst_text_ptr++ = *src_text_ptr;
+
+      src_text_ptr++;
+    }
+
+    *dst_text_ptr = '\0';
+
+    text_final = text_door_style;
+  }
+
+  setRequestPosition(&sx, &sy, FALSE);
+
+  ClearRectangle(backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE);
+
+  for (y = 0; y < y_steps; y++)
+    for (x = 0; x < x_steps; x++)
+      DrawEnvelopeBackgroundTiles(graphic, sx, sy,
+				  x, y, x_steps, y_steps,
+				  tile_size, tile_size);
+
+  DrawTextBuffer(sx + border_size, sy + border_size, text_final, font_nr,
+		 line_length, -1, max_lines, line_spacing, mask_mode,
+		 request.autowrap, request.centered, FALSE);
+
+  for (i = 0; i < NUM_TOOL_BUTTONS; i++)
+    RedrawGadget(tool_gadget[i]);
+
+  // store readily prepared envelope request for later use when animating
+  BlitBitmap(backbuffer, bitmap_db_cross, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
+
+#if 0
+  // !!! TEST !!!
+  BlitBitmap(bitmap_db_store, backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
+  BlitBitmap(bitmap_db_cross, backbuffer, sx, sy, width, height, sx, sy);
+
+  redraw_mask = REDRAW_FIELD | REDRAW_FROM_BACKBUFFER;
+  BackToFront();
+
+  Delay(3000);
+
+  BlitBitmap(bitmap_db_store, backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
+
+  redraw_mask = REDRAW_FIELD | REDRAW_FROM_BACKBUFFER;
+  BackToFront();
+
+  Delay(1000);
+#endif
+
+  if (text_door_style)
+    free(text_door_style);
+}
+
+#if 1
+
+void AnimateEnvelopeRequest(int anim_mode, int action)
 {
+  int graphic = IMG_BACKGROUND_REQUEST;
+  boolean draw_masked = graphic_info[graphic].draw_masked;
+#if 1
+  int delay_value_normal = request.step_delay;
+  int delay_value_fast = delay_value_normal / 2;
+#else
+  int delay_value_normal = GameFrameDelay;
+  int delay_value_fast = FfwdFrameDelay;
+#endif
+  boolean ffwd_delay = (tape.playing && tape.fast_forward);
+  boolean no_delay = (tape.warp_forward);
+  int delay_value = (ffwd_delay ? delay_value_fast : delay_value_normal);
+  int anim_delay_value = (no_delay ? 0 : delay_value + 500 * 0);
+  unsigned int anim_delay = 0;
+
+  int width = request.width;
+  int height = request.height;
+  int tile_size = request.step_offset;
+  int max_xsize = width  / tile_size;
+  int max_ysize = height / tile_size;
+  int max_xsize_inner = max_xsize - 2;
+  int max_ysize_inner = max_ysize - 2;
+
+  int xstart = (anim_mode & ANIM_VERTICAL ? max_xsize_inner : 0);
+  int ystart = (anim_mode & ANIM_HORIZONTAL ? max_ysize_inner : 0);
+  int xend = max_xsize_inner;
+  int yend = (anim_mode != ANIM_DEFAULT ? max_ysize_inner : 0);
+  int xstep = (xstart < xend ? 1 : 0);
+  int ystep = (ystart < yend || xstep == 0 ? 1 : 0);
+  int x, y;
+
+  for (x = xstart, y = ystart; x <= xend && y <= yend; x += xstep, y += ystep)
+  {
+    int xsize = (action == ACTION_CLOSING ? xend - (x - xstart) : x) + 2;
+    int ysize = (action == ACTION_CLOSING ? yend - (y - ystart) : y) + 2;
+    int sx_center = (request.x != -1 ? request.x : SX + SXSIZE / 2);
+    int sy_center = (request.y != -1 ? request.y : SY + SYSIZE / 2);
+    int src_x = sx_center - width  / 2;
+    int src_y = sy_center - height / 2;
+    int dst_x = sx_center - xsize * tile_size / 2;
+    int dst_y = sy_center - ysize * tile_size / 2;
+    int xsize_size_left = (xsize - 1) * tile_size;
+    int ysize_size_top  = (ysize - 1) * tile_size;
+    int max_xsize_pos = (max_xsize - 1) * tile_size;
+    int max_ysize_pos = (max_ysize - 1) * tile_size;
+    int xx, yy;
+
+    BlitBitmap(bitmap_db_store, backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
+
+#if 1
+    for (yy = 0; yy < 2; yy++)
+    {
+      for (xx = 0; xx < 2; xx++)
+      {
+	int src_xx = src_x + xx * max_xsize_pos;
+	int src_yy = src_y + yy * max_ysize_pos;
+	int dst_xx = dst_x + xx * xsize_size_left;
+	int dst_yy = dst_y + yy * ysize_size_top;
+	int xx_size = (xx ? tile_size : xsize_size_left);
+	int yy_size = (yy ? tile_size : ysize_size_top);
+
+	if (draw_masked)
+	  BlitBitmapMasked(bitmap_db_cross, backbuffer,
+			   src_xx, src_yy, xx_size, yy_size, dst_xx, dst_yy);
+	else
+	  BlitBitmap(bitmap_db_cross, backbuffer,
+		     src_xx, src_yy, xx_size, yy_size, dst_xx, dst_yy);
+      }
+    }
+#else
+    BlitBitmap(bitmap_db_cross, backbuffer,
+	       src_x, src_y,
+	       xsize_size_left, ysize_size_top,
+	       dst_x, dst_y);
+    BlitBitmap(bitmap_db_cross, backbuffer,
+	       src_x + max_xsize_pos, src_y,
+	       tile_size, ysize_size_top,
+	       dst_x + xsize_size_left, dst_y);
+    BlitBitmap(bitmap_db_cross, backbuffer,
+	       src_x, src_y + max_ysize_pos,
+	       xsize_size_left, tile_size,
+	       dst_x, dst_y + ysize_size_top);
+    BlitBitmap(bitmap_db_cross, backbuffer,
+	       src_x + max_xsize_pos, src_y + max_ysize_pos,
+	       tile_size, tile_size,
+	       dst_x + xsize_size_left, dst_y + ysize_size_top);
+#endif
+
+#if 1
+    redraw_mask = REDRAW_FIELD | REDRAW_FROM_BACKBUFFER;
+    // redraw_mask |= REDRAW_ALL | REDRAW_FROM_BACKBUFFER;
+#else
+    redraw_mask |= REDRAW_FIELD | REDRAW_FROM_BACKBUFFER;
+#endif
+
 #if 1
+    DoAnimation();
+    BackToFront();
+#else
+    BackToFront();
+#endif
+
+    WaitUntilDelayReached(&anim_delay, anim_delay_value / 2);
+  }
+}
+
+#else
+
+void AnimateEnvelopeRequest(char *text, int anim_mode, int action)
+{
+#if 0
   int envelope_nr = 0;
 #endif
+#if 1
+  int graphic = IMG_BACKGROUND_REQUEST;
+#else
   int graphic = IMG_BACKGROUND_ENVELOPE_1 + envelope_nr;
+#endif
   Bitmap *src_bitmap = graphic_info[graphic].bitmap;
   int mask_mode = (src_bitmap != NULL ? BLIT_MASKED : BLIT_ON_BACKGROUND);
   boolean ffwd_delay = (tape.playing && tape.fast_forward);
   boolean no_delay = (tape.warp_forward);
   unsigned int anim_delay = 0;
   int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
-  int anim_delay_value = (no_delay ? 0 : frame_delay_value);
+  int anim_delay_value = (no_delay ? 0 : frame_delay_value + 500 * 0);
 #if 1
   int max_word_len = maxWordLengthInString(text);
   int font_nr = (max_word_len > 7 ? FONT_TEXT_1 : FONT_TEXT_2);
@@ -2588,11 +2875,13 @@ void AnimateEnvelopeDoor(char *text, int anim_mode, int action)
 #endif
   int font_width = getFontWidth(font_nr);
   int font_height = getFontHeight(font_nr);
+  int line_spacing = 2 * 1;
 #if 1
 
 #if 1
   int max_xsize = DXSIZE / font_width;
-  int max_ysize = DYSIZE / font_height;
+  // int max_ysize = DYSIZE / font_height;
+  int max_ysize = DYSIZE / (font_height + line_spacing);
 #else
   int max_xsize = 7;	/* tools.c: MAX_REQUEST_LINE_FONT1_LEN == 7 */
   int max_ysize = 13;	/* tools.c: MAX_REQUEST_LINES == 13 */
@@ -2662,8 +2951,9 @@ void AnimateEnvelopeDoor(char *text, int anim_mode, int action)
   {
     int xsize = (action == ACTION_CLOSING ? xend - (x - xstart) : x) + 2;
     int ysize = (action == ACTION_CLOSING ? yend - (y - ystart) : y) + 2;
-    int sx = (SXSIZE - xsize * font_width)  / 2;
-    int sy = (SYSIZE - ysize * font_height) / 2;
+    int sx = SX + (SXSIZE - xsize * font_width)  / 2;
+    // int sy = SX + (SYSIZE - ysize * font_height) / 2;
+    int sy = SY + (SYSIZE - ysize * (font_height + line_spacing)) / 2;
     int xx, yy;
 
 #if 1
@@ -2671,23 +2961,30 @@ void AnimateEnvelopeDoor(char *text, int anim_mode, int action)
 #else
     SetDrawtoField(DRAW_BUFFERED);
 
+#if 1
+    BlitScreenToBitmap(backbuffer);
+#else
     BlitBitmap(fieldbuffer, backbuffer, FX, FY, SXSIZE, SYSIZE, SX, SY);
+#endif
 
     SetDrawtoField(DRAW_BACKBUFFER);
 #endif
 
-    for (yy = 0; yy < ysize; yy++) for (xx = 0; xx < xsize; xx++)
-      DrawEnvelopeBackground(envelope_nr, sx,sy, xx,yy, xsize, ysize, font_nr);
+    for (yy = 0; yy < ysize; yy++)
+      for (xx = 0; xx < xsize; xx++)
+	DrawEnvelopeBackgroundTiles(graphic, sx, sy, xx, yy, xsize, ysize,
+				    getFontWidth(font_nr),
+				    getFontHeight(font_nr) + line_spacing);
 
 #if 1
 
 #if 1
-    DrawTextBuffer(SX + sx + font_width, SY + sy + font_height + 8,
+    DrawTextBuffer(sx + font_width, sy + font_height + 8,
 		   text_copy, font_nr, max_xsize,
-		   xsize - 2, ysize - 2, 2, mask_mode,
+		   xsize - 2, ysize - 2, line_spacing, mask_mode,
 		   FALSE, TRUE, FALSE);
 #else
-    DrawTextBuffer(SX + sx + font_width, SY + sy + font_height,
+    DrawTextBuffer(sx + font_width, sy + font_height,
 		   level.envelope[envelope_nr].text, font_nr, max_xsize,
 		   xsize - 2, ysize - 2, 0, mask_mode,
 		   level.envelope[envelope_nr].autowrap,
@@ -2695,21 +2992,31 @@ void AnimateEnvelopeDoor(char *text, int anim_mode, int action)
 #endif
 
 #else
-    DrawTextToTextArea(SX + sx + font_width, SY + sy + font_height,
+    DrawTextToTextArea(sx + font_width, sy + font_height,
 		       level.envelope[envelope_nr].text, font_nr, max_xsize,
 		       xsize - 2, ysize - 2, mask_mode);
 #endif
 
     /* copy request gadgets to door backbuffer */
 #if 1
+    /*
     if ((ysize - 2) > 13)
       BlitBitmap(bitmap_db_door, drawto,
 		 DOOR_GFX_PAGEX1 + (DXSIZE - (xsize - 2) * font_width) / 2,
 		 DOOR_GFX_PAGEY1 + 13 * font_height,
 		 (xsize - 2) * font_width,
 		 (ysize - 2 - 13) * font_height,
-		 SX + sx + font_width,
-		 SY + sy + font_height * (1 + 13));
+		 sx + font_width,
+		 sy + font_height * (1 + 13));
+    */
+    if ((ysize - 2) > 13)
+      BlitBitmap(bitmap_db_door, drawto,
+		 DOOR_GFX_PAGEX1 + (DXSIZE - (xsize - 2) * font_width) / 2,
+		 DOOR_GFX_PAGEY1 + 11 * (font_height + line_spacing * 0),
+		 (xsize - 2) * font_width,
+		 (ysize - 2 - 13) * (font_height + line_spacing),
+		 sx + font_width,
+		 sy + (font_height + line_spacing) * (1 + 13));
 #else
     if ((ysize - 2) > 13)
       BlitBitmap(bitmap_db_door, drawto,
@@ -2717,8 +3024,8 @@ void AnimateEnvelopeDoor(char *text, int anim_mode, int action)
 		 DOOR_GFX_PAGEY1 + 13 * font_height,
 		 (xsize - 2) * font_width,
 		 (ysize - 2 - 13) * font_height,
-		 SX + sx + font_width,
-		 SY + sy + font_height * (1 + 13));
+		 sx + font_width,
+		 sy + font_height * (1 + 13));
 #endif
 
 #if 1
@@ -2743,61 +3050,25 @@ void AnimateEnvelopeDoor(char *text, int anim_mode, int action)
 #endif
 }
 
-void ShowEnvelope(int envelope_nr)
-{
-  int element = EL_ENVELOPE_1 + envelope_nr;
-  int graphic = IMG_BACKGROUND_ENVELOPE_1 + envelope_nr;
-  int sound_opening = element_info[element].sound[ACTION_OPENING];
-  int sound_closing = element_info[element].sound[ACTION_CLOSING];
-  boolean ffwd_delay = (tape.playing && tape.fast_forward);
-  boolean no_delay = (tape.warp_forward);
-  int normal_delay_value = ONE_SECOND_DELAY / (ffwd_delay ? 2 : 1);
-  int wait_delay_value = (no_delay ? 0 : normal_delay_value);
-  int anim_mode = graphic_info[graphic].anim_mode;
-  int main_anim_mode = (anim_mode == ANIM_NONE ? ANIM_VERTICAL|ANIM_HORIZONTAL:
-			anim_mode == ANIM_DEFAULT ? ANIM_VERTICAL : anim_mode);
-
-  game.envelope_active = TRUE;	/* needed for RedrawPlayfield() events */
-
-  PlayMenuSoundStereo(sound_opening, SOUND_MIDDLE);
-
-  if (anim_mode == ANIM_DEFAULT)
-    AnimateEnvelope(envelope_nr, ANIM_DEFAULT, ACTION_OPENING);
-
-  AnimateEnvelope(envelope_nr, main_anim_mode, ACTION_OPENING);
-
-  if (tape.playing)
-    Delay(wait_delay_value);
-  else
-    WaitForEventToContinue();
-
-  PlayMenuSoundStereo(sound_closing, SOUND_MIDDLE);
-
-  if (anim_mode != ANIM_NONE)
-    AnimateEnvelope(envelope_nr, main_anim_mode, ACTION_CLOSING);
-
-  if (anim_mode == ANIM_DEFAULT)
-    AnimateEnvelope(envelope_nr, ANIM_DEFAULT, ACTION_CLOSING);
-
-  game.envelope_active = FALSE;
-
-  SetDrawtoField(DRAW_BUFFERED);
-
-  redraw_mask |= REDRAW_FIELD;
-  BackToFront();
-}
+#endif
 
-void ShowEnvelopeDoor(char *text, int action)
+void ShowEnvelopeRequest(char *text, unsigned int req_state, int action)
 {
 #if 1
   int last_game_status = game_status;	/* save current game status */
   // int last_draw_background_mask = gfx.draw_background_mask;
-  int envelope_nr = 0;
 #endif
+#if 1
+  int graphic = IMG_BACKGROUND_REQUEST;
+  int sound_opening = SND_REQUEST_OPENING;
+  int sound_closing = SND_REQUEST_CLOSING;
+#else
+  int envelope_nr = 0;
   int element = EL_ENVELOPE_1 + envelope_nr;
   int graphic = IMG_BACKGROUND_ENVELOPE_1 + envelope_nr;
   int sound_opening = element_info[element].sound[ACTION_OPENING];
   int sound_closing = element_info[element].sound[ACTION_CLOSING];
+#endif
 #if 0
   boolean ffwd_delay = (tape.playing && tape.fast_forward);
   boolean no_delay = (tape.warp_forward);
@@ -2807,6 +3078,14 @@ void ShowEnvelopeDoor(char *text, int action)
   int anim_mode = graphic_info[graphic].anim_mode;
   int main_anim_mode = (anim_mode == ANIM_NONE ? ANIM_VERTICAL|ANIM_HORIZONTAL:
 			anim_mode == ANIM_DEFAULT ? ANIM_VERTICAL : anim_mode);
+#if 0
+  char *text_copy = getStringCopy(text);
+  char *text_ptr;
+
+  for (text_ptr = text_copy; *text_ptr; text_ptr++)
+    if (*text_ptr == ' ')
+      *text_ptr = '\n';
+#endif
 
 #if 1
   if (game_status == GAME_MODE_PLAYING)
@@ -2829,6 +3108,31 @@ void ShowEnvelopeDoor(char *text, int action)
   {
     BlitBitmap(backbuffer, bitmap_db_store, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
 
+#if 1
+  if (req_state & REQ_ASK)
+  {
+    MapGadget(tool_gadget[TOOL_CTRL_ID_YES]);
+    MapGadget(tool_gadget[TOOL_CTRL_ID_NO]);
+  }
+  else if (req_state & REQ_CONFIRM)
+  {
+    MapGadget(tool_gadget[TOOL_CTRL_ID_CONFIRM]);
+  }
+  else if (req_state & REQ_PLAYER)
+  {
+    MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_1]);
+    MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_2]);
+    MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_3]);
+    MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_4]);
+  }
+#endif
+
+#if 1
+    DrawEnvelopeRequest(text);
+#else
+    DrawEnvelopeRequest(text_copy);
+#endif
+
     if (game_status != GAME_MODE_MAIN)
       InitAnimation();
   }
@@ -2844,9 +3148,9 @@ void ShowEnvelopeDoor(char *text, int action)
     PlayMenuSoundStereo(sound_opening, SOUND_MIDDLE);
 
     if (anim_mode == ANIM_DEFAULT)
-      AnimateEnvelopeDoor(text, ANIM_DEFAULT, ACTION_OPENING);
+      AnimateEnvelopeRequest(ANIM_DEFAULT, ACTION_OPENING);
 
-    AnimateEnvelopeDoor(text, main_anim_mode, ACTION_OPENING);
+    AnimateEnvelopeRequest(main_anim_mode, ACTION_OPENING);
 
 #if 0
     if (tape.playing)
@@ -2860,10 +3164,10 @@ void ShowEnvelopeDoor(char *text, int action)
     PlayMenuSoundStereo(sound_closing, SOUND_MIDDLE);
 
     if (anim_mode != ANIM_NONE)
-      AnimateEnvelopeDoor(text, main_anim_mode, ACTION_CLOSING);
+      AnimateEnvelopeRequest(main_anim_mode, ACTION_CLOSING);
 
     if (anim_mode == ANIM_DEFAULT)
-      AnimateEnvelopeDoor(text, ANIM_DEFAULT, ACTION_CLOSING);
+      AnimateEnvelopeRequest(ANIM_DEFAULT, ACTION_CLOSING);
   }
 
   game.envelope_active = FALSE;
@@ -2900,12 +3204,24 @@ void ShowEnvelopeDoor(char *text, int action)
   /* (important: after "BackToFront()", but before "SetDrawtoField()") */
   game_status = last_game_status;	/* restore current game status */
 
+#if 1
+  if (action == ACTION_CLOSING &&
+      game_status == GAME_MODE_PLAYING &&
+      level.game_engine_type == GAME_ENGINE_TYPE_RND)
+    SetDrawtoField(DRAW_BUFFERED);
+#else
   if (game_status == GAME_MODE_PLAYING &&
       level.game_engine_type == GAME_ENGINE_TYPE_RND)
     SetDrawtoField(DRAW_BUFFERED);
+#endif
+
 #else
   BackToFront();
 #endif
+
+#if 0
+  free(text_copy);
+#endif
 }
 
 void DrawPreviewElement(int dst_x, int dst_y, int element, int tilesize)
@@ -2949,7 +3265,7 @@ void DrawMiniLevel(int size_x, int size_y, int scroll_x, int scroll_y)
   redraw_mask |= REDRAW_FIELD;
 }
 
-static void DrawPreviewLevelExt(int from_x, int from_y)
+static void DrawPreviewLevelPlayfieldExt(int from_x, int from_y)
 {
   boolean show_level_border = (BorderElement != EL_EMPTY);
   int level_xsize = lev_fieldx + (show_level_border ? 2 : 0);
@@ -3085,7 +3401,7 @@ static void DrawPreviewLevelLabelExt(int mode)
   redraw_mask |= REDRAW_MICROLEVEL;
 }
 
-void DrawPreviewLevel(boolean restart)
+static void DrawPreviewLevelExt(boolean restart)
 {
   static unsigned int scroll_delay = 0;
   static unsigned int label_delay = 0;
@@ -3122,7 +3438,7 @@ void DrawPreviewLevel(boolean restart)
     label_state = 1;
     label_counter = 0;
 
-    DrawPreviewLevelExt(from_x, from_y);
+    DrawPreviewLevelPlayfieldExt(from_x, from_y);
     DrawPreviewLevelLabelExt(label_state);
 
     /* initialize delay counters */
@@ -3224,7 +3540,7 @@ void DrawPreviewLevel(boolean restart)
 	break;
     }
 
-    DrawPreviewLevelExt(from_x, from_y);
+    DrawPreviewLevelPlayfieldExt(from_x, from_y);
   }
 
   /* !!! THIS ALL SUCKS -- SHOULD BE CLEANLY REWRITTEN !!! */
@@ -3271,10 +3587,20 @@ void DrawPreviewLevel(boolean restart)
   game_status = last_game_status;	/* restore current game status */
 }
 
-inline void DrawGraphicAnimationExt(DrawBuffer *dst_bitmap, int x, int y,
-				    int graphic, int sync_frame, int mask_mode)
+void DrawPreviewLevelInitial()
 {
-  int frame = getGraphicAnimationFrame(graphic, sync_frame);
+  DrawPreviewLevelExt(TRUE);
+}
+
+void DrawPreviewLevelAnimation()
+{
+  DrawPreviewLevelExt(FALSE);
+}
+
+inline void DrawGraphicAnimationExt(DrawBuffer *dst_bitmap, int x, int y,
+				    int graphic, int sync_frame, int mask_mode)
+{
+  int frame = getGraphicAnimationFrame(graphic, sync_frame);
 
   if (mask_mode == USE_MASKING)
     DrawGraphicThruMaskExt(dst_bitmap, x, y, graphic, frame);
@@ -3830,30 +4156,578 @@ void WaitForEventToContinue()
 	  still_wait = FALSE;
 	  break;
 
-	case EVENT_KEYRELEASE:
-	  ClearPlayerAction();
-	  break;
+	case EVENT_KEYRELEASE:
+	  ClearPlayerAction();
+	  break;
+
+	default:
+	  HandleOtherEvents(&event);
+	  break;
+      }
+    }
+    else if (AnyJoystickButton() == JOY_BUTTON_NEW_PRESSED)
+    {
+      still_wait = FALSE;
+    }
+
+    DoAnimation();
+
+    /* don't eat all CPU time */
+    Delay(10);
+  }
+}
+
+#define MAX_REQUEST_LINES		13
+#define MAX_REQUEST_LINE_FONT1_LEN	7
+#define MAX_REQUEST_LINE_FONT2_LEN	10
+
+#if 1
+
+static int RequestHandleEvents(unsigned int req_state)
+{
+  int last_game_status = game_status;	/* save current game status */
+  int result;
+  int mx, my;
+
+  button_status = MB_RELEASED;
+
+  request_gadget_id = -1;
+  result = -1;
+
+  while (result < 0)
+  {
+    if (PendingEvent())
+    {
+      Event event;
+
+      NextEvent(&event);
+
+      switch (event.type)
+      {
+	case EVENT_BUTTONPRESS:
+	case EVENT_BUTTONRELEASE:
+	case EVENT_MOTIONNOTIFY:
+	{
+	  if (event.type == EVENT_MOTIONNOTIFY)
+	  {
+	    if (!PointerInWindow(window))
+	      continue;	/* window and pointer are on different screens */
+
+	    if (!button_status)
+	      continue;
+
+	    motion_status = TRUE;
+	    mx = ((MotionEvent *) &event)->x;
+	    my = ((MotionEvent *) &event)->y;
+	  }
+	  else
+	  {
+	    motion_status = FALSE;
+	    mx = ((ButtonEvent *) &event)->x;
+	    my = ((ButtonEvent *) &event)->y;
+	    if (event.type == EVENT_BUTTONPRESS)
+	      button_status = ((ButtonEvent *) &event)->button;
+	    else
+	      button_status = MB_RELEASED;
+	  }
+
+	  /* this sets 'request_gadget_id' */
+	  HandleGadgets(mx, my, button_status);
+
+	  switch (request_gadget_id)
+	  {
+	    case TOOL_CTRL_ID_YES:
+	      result = TRUE;
+	      break;
+	    case TOOL_CTRL_ID_NO:
+	      result = FALSE;
+	      break;
+	    case TOOL_CTRL_ID_CONFIRM:
+	      result = TRUE | FALSE;
+	      break;
+
+	    case TOOL_CTRL_ID_PLAYER_1:
+	      result = 1;
+	      break;
+	    case TOOL_CTRL_ID_PLAYER_2:
+	      result = 2;
+	      break;
+	    case TOOL_CTRL_ID_PLAYER_3:
+	      result = 3;
+	      break;
+	    case TOOL_CTRL_ID_PLAYER_4:
+	      result = 4;
+	      break;
+
+	    default:
+	      break;
+	  }
+
+	  break;
+	}
+
+	case EVENT_KEYPRESS:
+	  switch (GetEventKey((KeyEvent *)&event, TRUE))
+	  {
+	    case KSYM_space:
+	      if (req_state & REQ_CONFIRM)
+		result = 1;
+	      break;
+
+	    case KSYM_Return:
+	      result = 1;
+	      break;
+
+	    case KSYM_Escape:
+#if defined(TARGET_SDL2)
+	    case KSYM_Back:
+#endif
+	      result = 0;
+	      break;
+
+	    default:
+	      break;
+	  }
+
+	  if (req_state & REQ_PLAYER)
+	    result = 0;
+	  break;
+
+	case EVENT_KEYRELEASE:
+	  ClearPlayerAction();
+	  break;
+
+	default:
+	  HandleOtherEvents(&event);
+	  break;
+      }
+    }
+    else if (AnyJoystickButton() == JOY_BUTTON_NEW_PRESSED)
+    {
+      int joy = AnyJoystick();
+
+      if (joy & JOY_BUTTON_1)
+	result = 1;
+      else if (joy & JOY_BUTTON_2)
+	result = 0;
+    }
+
+#if 1
+
+    if (game_status == GAME_MODE_PLAYING && local_player->LevelSolved_GameEnd)
+    {
+      HandleGameActions();
+    }
+    else
+    {
+      DoAnimation();
+
+      if (!PendingEvent())	/* delay only if no pending events */
+	Delay(10);
+    }
+
+#if 1
+    game_status = GAME_MODE_PSEUDO_DOOR;
+#endif
+
+    BackToFront();
+
+#if 1
+    game_status = last_game_status;	/* restore current game status */
+#endif
+
+#else
+
+    DoAnimation();
+
+#if 1
+    if (!PendingEvent())	/* delay only if no pending events */
+      Delay(10);
+#else
+    /* don't eat all CPU time */
+    Delay(10);
+#endif
+
+#endif
+  }
+
+  return result;
+}
+
+static boolean RequestDoor(char *text, unsigned int req_state)
+{
+  unsigned int old_door_state;
+  int last_game_status = game_status;	/* save current game status */
+  int max_request_line_len = MAX_REQUEST_LINE_FONT1_LEN;
+  int font_nr = FONT_TEXT_2;
+  char *text_ptr;
+  int result;
+  int ty;
+
+  if (maxWordLengthInString(text) > MAX_REQUEST_LINE_FONT1_LEN)
+  {
+    max_request_line_len = MAX_REQUEST_LINE_FONT2_LEN;
+    font_nr = FONT_TEXT_1;
+  }
+
+  if (game_status == GAME_MODE_PLAYING)
+  {
+    if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
+      BlitScreenToBitmap_EM(backbuffer);
+    else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
+      BlitScreenToBitmap_SP(backbuffer);
+  }
+
+  /* disable deactivated drawing when quick-loading level tape recording */
+  if (tape.playing && tape.deactivate_display)
+    TapeDeactivateDisplayOff(TRUE);
+
+  SetMouseCursor(CURSOR_DEFAULT);
+
+#if defined(NETWORK_AVALIABLE)
+  /* pause network game while waiting for request to answer */
+  if (options.network &&
+      game_status == GAME_MODE_PLAYING &&
+      req_state & REQUEST_WAIT_FOR_INPUT)
+    SendToServer_PausePlaying();
+#endif
+
+  old_door_state = GetDoorState();
+
+  /* simulate releasing mouse button over last gadget, if still pressed */
+  if (button_status)
+    HandleGadgets(-1, -1, 0);
+
+  UnmapAllGadgets();
+
+  /* draw released gadget before proceeding */
+  // BackToFront();
+
+  if (old_door_state & DOOR_OPEN_1)
+  {
+    CloseDoor(DOOR_CLOSE_1);
+
+    /* save old door content */
+    BlitBitmap(bitmap_db_door, bitmap_db_door,
+	       DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1, DXSIZE, DYSIZE,
+	       DOOR_GFX_PAGEX2, DOOR_GFX_PAGEY1);
+  }
+
+  SetDoorBackgroundImage(IMG_BACKGROUND_DOOR);
+  SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
+
+  /* clear door drawing field */
+  DrawBackground(DX, DY, DXSIZE, DYSIZE);
+
+  /* force DOOR font inside door area */
+  game_status = GAME_MODE_PSEUDO_DOOR;
+
+  /* write text for request */
+  for (text_ptr = text, ty = 0; ty < MAX_REQUEST_LINES; ty++)
+  {
+    char text_line[max_request_line_len + 1];
+    int tx, tl, tc = 0;
+
+    if (!*text_ptr)
+      break;
+
+    for (tl = 0, tx = 0; tx < max_request_line_len; tl++, tx++)
+    {
+      tc = *(text_ptr + tx);
+      // if (!tc || tc == ' ')
+      if (!tc || tc == ' ' || tc == '?' || tc == '!')
+	break;
+    }
+
+    if ((tc == '?' || tc == '!') && tl == 0)
+      tl = 1;
+
+    if (!tl)
+    { 
+      text_ptr++; 
+      ty--; 
+      continue; 
+    }
+
+    strncpy(text_line, text_ptr, tl);
+    text_line[tl] = 0;
+
+    DrawText(DX + (DXSIZE - tl * getFontWidth(font_nr)) / 2,
+	     DY + 8 + ty * (getFontHeight(font_nr) + 2),
+	     text_line, font_nr);
+
+    text_ptr += tl + (tc == ' ' ? 1 : 0);
+    // text_ptr += tl + (tc == ' ' || tc == '?' || tc == '!' ? 1 : 0);
+  }
+
+  game_status = last_game_status;	/* restore current game status */
+
+  if (req_state & REQ_ASK)
+  {
+    MapGadget(tool_gadget[TOOL_CTRL_ID_YES]);
+    MapGadget(tool_gadget[TOOL_CTRL_ID_NO]);
+  }
+  else if (req_state & REQ_CONFIRM)
+  {
+    MapGadget(tool_gadget[TOOL_CTRL_ID_CONFIRM]);
+  }
+  else if (req_state & REQ_PLAYER)
+  {
+    MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_1]);
+    MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_2]);
+    MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_3]);
+    MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_4]);
+  }
+
+  /* copy request gadgets to door backbuffer */
+  BlitBitmap(drawto, bitmap_db_door,
+	     DX, DY, DXSIZE, DYSIZE,
+	     DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1);
+
+  OpenDoor(DOOR_OPEN_1);
+
+  if (!(req_state & REQUEST_WAIT_FOR_INPUT))
+  {
+    if (game_status == GAME_MODE_PLAYING)
+    {
+      SetPanelBackground();
+      SetDrawBackgroundMask(REDRAW_DOOR_1);
+    }
+    else
+    {
+      SetDrawBackgroundMask(REDRAW_FIELD);
+    }
+
+    return FALSE;
+  }
+
+  if (game_status != GAME_MODE_MAIN)
+    InitAnimation();
+
+  SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
+
+  // ---------- handle request buttons ----------
+  result = RequestHandleEvents(req_state);
+
+  if (game_status != GAME_MODE_MAIN)
+    StopAnimation();
+
+  UnmapToolButtons();
+
+  if (!(req_state & REQ_STAY_OPEN))
+  {
+    CloseDoor(DOOR_CLOSE_1);
+
+    if (((old_door_state & DOOR_OPEN_1) && !(req_state & REQ_STAY_CLOSED)) ||
+	(req_state & REQ_REOPEN))
+      OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
+  }
+
+  RemapAllGadgets();
+
+  if (game_status == GAME_MODE_PLAYING)
+  {
+    SetPanelBackground();
+    SetDrawBackgroundMask(REDRAW_DOOR_1);
+  }
+  else
+  {
+    SetDrawBackgroundMask(REDRAW_FIELD);
+  }
+
+#if defined(NETWORK_AVALIABLE)
+  /* continue network game after request */
+  if (options.network &&
+      game_status == GAME_MODE_PLAYING &&
+      req_state & REQUEST_WAIT_FOR_INPUT)
+    SendToServer_ContinuePlaying();
+#endif
+
+  /* restore deactivated drawing when quick-loading level tape recording */
+  if (tape.playing && tape.deactivate_display)
+    TapeDeactivateDisplayOn();
+
+  return result;
+}
+
+static boolean RequestEnvelope(char *text, unsigned int req_state)
+{
+  int result;
+#if 0
+  int i;
+#endif
+
+  if (game_status == GAME_MODE_PLAYING)
+  {
+    if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
+      BlitScreenToBitmap_EM(backbuffer);
+    else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
+      BlitScreenToBitmap_SP(backbuffer);
+  }
+
+  /* disable deactivated drawing when quick-loading level tape recording */
+  if (tape.playing && tape.deactivate_display)
+    TapeDeactivateDisplayOff(TRUE);
+
+  SetMouseCursor(CURSOR_DEFAULT);
+
+#if defined(NETWORK_AVALIABLE)
+  /* pause network game while waiting for request to answer */
+  if (options.network &&
+      game_status == GAME_MODE_PLAYING &&
+      req_state & REQUEST_WAIT_FOR_INPUT)
+    SendToServer_PausePlaying();
+#endif
+
+  /* simulate releasing mouse button over last gadget, if still pressed */
+  if (button_status)
+    HandleGadgets(-1, -1, 0);
+
+  UnmapAllGadgets();
+
+  // (replace with setting corresponding request background)
+  // SetDoorBackgroundImage(IMG_BACKGROUND_DOOR);
+  // SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
+
+  /* clear door drawing field */
+  // DrawBackground(DX, DY, DXSIZE, DYSIZE);
+
+#if 0
+  if (global.use_envelope_request)
+  {
+    /* !!! TMP !!! */
+    FreeToolButtons();
+    CreateToolButtons();
+  }
+#endif
+
+#if 0
+#if 0
+  if (req_state & REQ_ASK)
+  {
+    MapGadgetExt(tool_gadget[TOOL_CTRL_ID_YES], FALSE);
+    MapGadgetExt(tool_gadget[TOOL_CTRL_ID_NO], FALSE);
+  }
+  else if (req_state & REQ_CONFIRM)
+  {
+    MapGadgetExt(tool_gadget[TOOL_CTRL_ID_CONFIRM], FALSE);
+  }
+  else if (req_state & REQ_PLAYER)
+  {
+    MapGadgetExt(tool_gadget[TOOL_CTRL_ID_PLAYER_1], FALSE);
+    MapGadgetExt(tool_gadget[TOOL_CTRL_ID_PLAYER_2], FALSE);
+    MapGadgetExt(tool_gadget[TOOL_CTRL_ID_PLAYER_3], FALSE);
+    MapGadgetExt(tool_gadget[TOOL_CTRL_ID_PLAYER_4], FALSE);
+  }
+#else
+  if (req_state & REQ_ASK)
+  {
+    MapGadget(tool_gadget[TOOL_CTRL_ID_YES]);
+    MapGadget(tool_gadget[TOOL_CTRL_ID_NO]);
+  }
+  else if (req_state & REQ_CONFIRM)
+  {
+    MapGadget(tool_gadget[TOOL_CTRL_ID_CONFIRM]);
+  }
+  else if (req_state & REQ_PLAYER)
+  {
+    MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_1]);
+    MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_2]);
+    MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_3]);
+    MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_4]);
+  }
+#endif
+#endif
+
+  ShowEnvelopeRequest(text, req_state, ACTION_OPENING);
+
+#if 0
+  for (i = 0; i < NUM_TOOL_BUTTONS; i++)
+  {
+    if ((req_state & REQ_ASK && (i == TOOL_CTRL_ID_YES ||
+				 i == TOOL_CTRL_ID_NO)) ||
+	(req_state & REQ_CONFIRM && i == TOOL_CTRL_ID_CONFIRM) ||
+	(req_state & REQ_PLAYER && (i == TOOL_CTRL_ID_PLAYER_1 &&
+				    i == TOOL_CTRL_ID_PLAYER_2 &&
+				    i == TOOL_CTRL_ID_PLAYER_3 &&
+				    i == TOOL_CTRL_ID_PLAYER_4)))
+    {
+      int x = tool_gadget[i]->x + dDX;
+      int y = tool_gadget[i]->y + dDY;
+
+      ModifyGadget(tool_gadget[i], GDI_X, x, GDI_Y, y, GDI_END);
+    }
+  }
+#endif
+
+  if (!(req_state & REQUEST_WAIT_FOR_INPUT))
+  {
+    if (game_status == GAME_MODE_PLAYING)
+    {
+      SetPanelBackground();
+      SetDrawBackgroundMask(REDRAW_DOOR_1);
+    }
+    else
+    {
+      SetDrawBackgroundMask(REDRAW_FIELD);
+    }
+
+    return FALSE;
+  }
+
+#if 0
+  if (game_status != GAME_MODE_MAIN)
+    InitAnimation();
+#endif
+
+  SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
+
+  // ---------- handle request buttons ----------
+  result = RequestHandleEvents(req_state);
+
+  if (game_status != GAME_MODE_MAIN)
+    StopAnimation();
+
+  UnmapToolButtons();
+
+  ShowEnvelopeRequest(text, req_state, ACTION_CLOSING);
+
+  RemapAllGadgets();
+
+  if (game_status == GAME_MODE_PLAYING)
+  {
+    SetPanelBackground();
+    SetDrawBackgroundMask(REDRAW_DOOR_1);
+  }
+  else
+  {
+    SetDrawBackgroundMask(REDRAW_FIELD);
+  }
+
+#if defined(NETWORK_AVALIABLE)
+  /* continue network game after request */
+  if (options.network &&
+      game_status == GAME_MODE_PLAYING &&
+      req_state & REQUEST_WAIT_FOR_INPUT)
+    SendToServer_ContinuePlaying();
+#endif
 
-	default:
-	  HandleOtherEvents(&event);
-	  break;
-      }
-    }
-    else if (AnyJoystickButton() == JOY_BUTTON_NEW_PRESSED)
-    {
-      still_wait = FALSE;
-    }
+  /* restore deactivated drawing when quick-loading level tape recording */
+  if (tape.playing && tape.deactivate_display)
+    TapeDeactivateDisplayOn();
 
-    DoAnimation();
+  return result;
+}
 
-    /* don't eat all CPU time */
-    Delay(10);
-  }
+boolean Request(char *text, unsigned int req_state)
+{
+  if (global.use_envelope_request)
+    return RequestEnvelope(text, req_state);
+  else
+    return RequestDoor(text, req_state);
 }
 
-#define MAX_REQUEST_LINES		13
-#define MAX_REQUEST_LINE_FONT1_LEN	7
-#define MAX_REQUEST_LINE_FONT2_LEN	10
+#else	// =====================================================================
 
 boolean Request(char *text, unsigned int req_state)
 {
@@ -3868,8 +4742,8 @@ boolean Request(char *text, unsigned int req_state)
   char *text_ptr;
   int i;
 
-#if 1
-  global.use_envelope_request = 0;
+#if 0
+  global.use_envelope_request = 1;
 #endif
 
 #if 1
@@ -4030,7 +4904,7 @@ boolean Request(char *text, unsigned int req_state)
 #if 1
   if (global.use_envelope_request)
   {
-    ShowEnvelopeDoor(text, ACTION_OPENING);
+    ShowEnvelopeRequest(text, ACTION_OPENING);
 
     for (i = 0; i < NUM_TOOL_BUTTONS; i++)
     {
@@ -4172,7 +5046,9 @@ boolean Request(char *text, unsigned int req_state)
 	      break;
 
 	    case KSYM_Escape:
+#if defined(TARGET_SDL2)
 	    case KSYM_Back:
+#endif
 	      result = 0;
 	      break;
 
@@ -4249,7 +5125,7 @@ boolean Request(char *text, unsigned int req_state)
 
 #if 1
   if (global.use_envelope_request)
-    ShowEnvelopeDoor(text, ACTION_CLOSING);
+    ShowEnvelopeRequest(text, ACTION_CLOSING);
 #endif
 
 #if 1
@@ -4292,6 +5168,8 @@ boolean Request(char *text, unsigned int req_state)
   return result;
 }
 
+#endif
+
 unsigned int OpenDoor(unsigned int door_state)
 {
   if (door_state & DOOR_COPY_BACK)
@@ -4350,6 +5228,7 @@ unsigned int MoveDoor(unsigned int door_state)
   unsigned int door_delay_value;
   int stepsize = 1;
 
+#if 0
   if (door_1.width < 0 || door_1.width > DXSIZE)
     door_1.width = DXSIZE;
   if (door_1.height < 0 || door_1.height > DYSIZE)
@@ -4358,6 +5237,7 @@ unsigned int MoveDoor(unsigned int door_state)
     door_2.width = VXSIZE;
   if (door_2.height < 0 || door_2.height > VYSIZE)
     door_2.height = VYSIZE;
+#endif
 
   if (door_state == DOOR_GET_STATE)
     return (door1 | door2);
@@ -4387,6 +5267,8 @@ unsigned int MoveDoor(unsigned int door_state)
   door_delay_value = (door_state & DOOR_ACTION_1 ? door_1.step_delay :
 		      door_2.step_delay);
 
+  // door_delay_value *= 4;	// !!! TEST ONLY !!!
+
   if (setup.quick_doors)
   {
     stepsize = 20;		/* must be chosen to always draw last frame */
@@ -4412,8 +5294,13 @@ unsigned int MoveDoor(unsigned int door_state)
     boolean door_2_done = (!handle_door_2);
     boolean door_1_vertical = (door_1.anim_mode & ANIM_VERTICAL);
     boolean door_2_vertical = (door_2.anim_mode & ANIM_VERTICAL);
+#if 1
+    int door_size_1 = (door_1_vertical ? DYSIZE : DXSIZE);
+    int door_size_2 = (door_2_vertical ? VYSIZE : VXSIZE);
+#else
     int door_size_1 = (door_1_vertical ? door_1.height : door_1.width);
     int door_size_2 = (door_2_vertical ? door_2.height : door_2.width);
+#endif
     int max_door_size_1 = (door_1_vertical ? DYSIZE : DXSIZE);
     int max_door_size_2 = (door_2_vertical ? VYSIZE : VXSIZE);
     int door_size     = (handle_door_1 ? door_size_1     : door_size_2);
@@ -4435,8 +5322,10 @@ unsigned int MoveDoor(unsigned int door_state)
     for (k = start; k <= end && !(door_1_done && door_2_done); k += stepsize)
     {
       int x = k;
+#if 1
       Bitmap *bitmap = graphic_info[IMG_GLOBAL_DOOR].bitmap;
       GC gc = bitmap->stored_clip_gc;
+#endif
 
       if (door_state & DOOR_ACTION_1)
       {
@@ -4444,6 +5333,15 @@ unsigned int MoveDoor(unsigned int door_state)
 	int p = (door_state & DOOR_OPEN_1 ? end - a : a);
 	int i = p + door_skip;
 
+#if 1
+	struct GraphicInfo *g_left  = &graphic_info[IMG_DOOR_1_WING_LEFT];
+	struct GraphicInfo *g_right = &graphic_info[IMG_DOOR_1_WING_RIGHT];
+	Bitmap *bm_left  = g_left->bitmap;
+	Bitmap *bm_right = g_right->bitmap;
+	GC gc_left  = bm_left->stored_clip_gc;
+	GC gc_right = bm_right->stored_clip_gc;
+#endif
+
 	if (door_1.anim_mode & ANIM_STATIC_PANEL)
 	{
 	  BlitBitmap(bitmap_db_door, drawto,
@@ -4461,9 +5359,29 @@ unsigned int MoveDoor(unsigned int door_state)
 
 	if (door_1.anim_mode & ANIM_HORIZONTAL && x <= DXSIZE)
 	{
+#if 1
+	  int src1_x = g_right->src_x;
+	  int src1_y = g_right->src_y;
+	  int src2_x = g_left->src_x + g_left->width - i;
+	  int src2_y = g_left->src_y;
+	  int dst1_x = DX + DXSIZE - i;
+	  int dst1_y = DY;
+	  int dst2_x = DX;
+	  int dst2_y = DY;
+	  int width = i;
+	  int height = DYSIZE;
+
+	  SetClipOrigin(bm_right, gc_right, dst1_x - src1_x, dst1_y - src1_y);
+	  BlitBitmapMasked(bm_right, drawto, src1_x, src1_y, width, height,
+			   dst1_x, dst1_y);
+
+	  SetClipOrigin(bm_left, gc_left, dst2_x - src2_x, dst2_y - src2_y);
+	  BlitBitmapMasked(bm_left, drawto, src2_x, src2_y, width, height,
+			   dst2_x, dst2_y);
+#else
 	  int src1_x = DXSIZE,		src1_y = DOOR_GFX_PAGEY1;
-	  int dst1_x = DX + DXSIZE - i,	dst1_y = DY;
 	  int src2_x = DXSIZE - i,	src2_y = DOOR_GFX_PAGEY1;
+	  int dst1_x = DX + DXSIZE - i,	dst1_y = DY;
 	  int dst2_x = DX,		dst2_y = DY;
 	  int width = i, height = DYSIZE;
 
@@ -4474,12 +5392,33 @@ unsigned int MoveDoor(unsigned int door_state)
 	  SetClipOrigin(bitmap, gc, dst2_x - src2_x, dst2_y - src2_y);
 	  BlitBitmapMasked(bitmap, drawto, src2_x, src2_y, width, height,
 			   dst2_x, dst2_y);
+#endif
 	}
 	else if (door_1.anim_mode & ANIM_VERTICAL && x <= DYSIZE)
 	{
+#if 1
+	  int src1_x = g_right->src_x;
+	  int src1_y = g_right->src_y;
+	  int src2_x = g_left->src_x;
+	  int src2_y = g_left->src_y + g_left->height - i;
+	  int dst1_x = DX;
+	  int dst1_y = DY + DYSIZE - i;
+	  int dst2_x = DX;
+	  int dst2_y = DY;
+	  int width = DXSIZE;
+	  int height = i;
+
+	  SetClipOrigin(bm_right, gc_right, dst1_x - src1_x, dst1_y - src1_y);
+	  BlitBitmapMasked(bm_right, drawto, src1_x, src1_y, width, height,
+			   dst1_x, dst1_y);
+
+	  SetClipOrigin(bm_left, gc_left, dst2_x - src2_x, dst2_y - src2_y);
+	  BlitBitmapMasked(bm_left, drawto, src2_x, src2_y, width, height,
+			   dst2_x, dst2_y);
+#else
 	  int src1_x = DXSIZE,		src1_y = DOOR_GFX_PAGEY1;
-	  int dst1_x = DX,		dst1_y = DY + DYSIZE - i;
 	  int src2_x = 0,		src2_y = DOOR_GFX_PAGEY1 + DYSIZE - i;
+	  int dst1_x = DX,		dst1_y = DY + DYSIZE - i;
 	  int dst2_x = DX,		dst2_y = DY;
 	  int width = DXSIZE, height = i;
 
@@ -4490,11 +5429,94 @@ unsigned int MoveDoor(unsigned int door_state)
 	  SetClipOrigin(bitmap, gc, dst2_x - src2_x, dst2_y - src2_y);
 	  BlitBitmapMasked(bitmap, drawto, src2_x, src2_y, width, height,
 			   dst2_x, dst2_y);
+#endif
 	}
 	else if (x <= DXSIZE)	/* ANIM_DEFAULT */
 	{
 	  int j = (door_1.anim_mode == ANIM_DEFAULT ? (DXSIZE - i) / 3 : 0);
 
+#if 1
+	  int src1_x = g_right->src_x;
+	  int src1_y = g_right->src_y;
+	  int src2_x = g_left->src_x + g_left->width - i;
+	  int src2_y = g_left->src_y;
+	  int dst1_x = DX + DXSIZE - i;
+	  int dst1_y = DY;
+	  int dst2_x = DX;
+	  int dst2_y = DY;
+	  int width = i;
+	  int height1 = 63, height2 = DYSIZE / 2 - height1;
+	  int ypos1 = 0, ypos2 = height2;
+	  int ypos3 = DYSIZE / 2, ypos4 = DYSIZE - height2;
+
+	  SetClipOrigin(bitmap, gc, dst1_x - src1_x, dst1_y - src1_y + j);
+	  BlitBitmapMasked(bitmap, drawto,
+			   src1_x, src1_y + ypos1, width, height2,
+			   dst1_x, dst1_y + ypos1 + j);
+	  BlitBitmapMasked(bitmap, drawto,
+			   src1_x, src1_y + ypos3, width, height1,
+			   dst1_x, dst1_y + ypos3 + j);
+	  SetClipOrigin(bitmap, gc, dst2_x - src2_x, dst2_y - src2_y - j);
+	  BlitBitmapMasked(bitmap, drawto,
+			   src2_x, src2_y + ypos1 + j, width, height2 - j,
+			   dst2_x, dst2_y + ypos1);
+	  BlitBitmapMasked(bitmap, drawto,
+			   src2_x, src2_y + ypos3, width, height1,
+			   dst2_x, dst2_y + ypos3 - j);
+
+	  SetClipOrigin(bitmap, gc, dst2_x - src2_x, dst2_y - src2_y - j);
+	  BlitBitmapMasked(bitmap, drawto,
+			   src2_x, src2_y + ypos2, width, height1,
+			   dst2_x, dst2_y + ypos2 - j);
+	  BlitBitmapMasked(bitmap, drawto,
+			   src2_x, src2_y + ypos4, width, height2,
+			   dst2_x, dst2_y + ypos4 - j);
+	  SetClipOrigin(bitmap, gc, dst1_x - src1_x, dst1_y - src1_y + j);
+	  BlitBitmapMasked(bitmap, drawto,
+			   src1_x, src1_y + ypos2, width, height1,
+			   dst1_x, dst1_y + ypos2 + j);
+	  BlitBitmapMasked(bitmap, drawto,
+			   src1_x, src1_y + ypos4, width, height2 - j,
+			   dst1_x, dst1_y + ypos4 + j);
+#else
+	  int src1_x = DXSIZE,		src1_y = DOOR_GFX_PAGEY1;
+	  int src2_x = DXSIZE - i,	src2_y = DOOR_GFX_PAGEY1;
+	  int dst1_x = DX + DXSIZE - i,	dst1_y = DY;
+	  int dst2_x = DX,		dst2_y = DY;
+	  int width = i, height = DYSIZE;
+	  int ypos1 = 63, ypos2 = 77, ypos3 = 140, ypos4 = 203;
+
+	  SetClipOrigin(bitmap, gc, dst1_x - src1_x, dst1_y - src1_y + j);
+	  BlitBitmapMasked(bitmap, drawto,
+			   src1_x, src1_y, width, ypos2,
+			   dst1_x, dst1_y + j);
+	  BlitBitmapMasked(bitmap, drawto,
+			   src1_x, src1_y + ypos3, width, ypos1,
+			   dst1_x, dst1_y + ypos3 + j);
+	  SetClipOrigin(bitmap, gc, dst2_x - src2_x, dst2_y - src2_y - j);
+	  BlitBitmapMasked(bitmap, drawto,
+			   src2_x, src2_y + j, width, ypos2 - j,
+			   dst2_x, dst2_y);
+	  BlitBitmapMasked(bitmap, drawto,
+			   src2_x, src2_y + ypos3, width, ypos1,
+			   dst2_x, dst2_y + ypos3 - j);
+
+	  SetClipOrigin(bitmap, gc, dst2_x - src2_x, dst2_y - src2_y - j);
+	  BlitBitmapMasked(bitmap, drawto,
+			   src2_x, src2_y + ypos2, width, ypos1,
+			   dst2_x, dst2_y + ypos2 - j);
+	  BlitBitmapMasked(bitmap, drawto,
+			   src2_x, src2_y + ypos4, width, ypos2,
+			   dst2_x, dst2_y + ypos4 - j);
+	  SetClipOrigin(bitmap, gc, dst1_x - src1_x, dst1_y - src1_y + j);
+	  BlitBitmapMasked(bitmap, drawto,
+			   src1_x, src1_y + ypos2, width, ypos1,
+			   dst1_x, dst1_y + ypos2 + j);
+	  BlitBitmapMasked(bitmap, drawto,
+			   src1_x, src1_y + ypos4, width, ypos2 - j,
+			   dst1_x, dst1_y + ypos4 + j);
+
+	  /*
 	  SetClipOrigin(bitmap, gc, DX - i, (DY + j) - DOOR_GFX_PAGEY1);
 	  BlitBitmapMasked(bitmap, drawto,
 			   DXSIZE, DOOR_GFX_PAGEY1, i, 77,
@@ -4524,6 +5546,8 @@ unsigned int MoveDoor(unsigned int door_state)
 	  BlitBitmapMasked(bitmap, drawto,
 			   DXSIZE, DOOR_GFX_PAGEY1 + 203, i, 77 - j,
 			   DX + DXSIZE - i, DY + 203 + j);
+	  */
+#endif
 	}
 
 	redraw_mask |= REDRAW_DOOR_1;
@@ -4536,6 +5560,15 @@ unsigned int MoveDoor(unsigned int door_state)
 	int p = (door_state & DOOR_OPEN_2 ? door_size - a : a);
 	int i = p + door_skip;
 
+#if 1
+	struct GraphicInfo *g_left  = &graphic_info[IMG_DOOR_2_WING_LEFT];
+	struct GraphicInfo *g_right = &graphic_info[IMG_DOOR_2_WING_RIGHT];
+	Bitmap *bm_left  = g_left->bitmap;
+	Bitmap *bm_right = g_right->bitmap;
+	GC gc_left  = bm_left->stored_clip_gc;
+	GC gc_right = bm_right->stored_clip_gc;
+#endif
+
 	if (door_2.anim_mode & ANIM_STATIC_PANEL)
 	{
 	  BlitBitmap(bitmap_db_door, drawto,
@@ -4553,9 +5586,29 @@ unsigned int MoveDoor(unsigned int door_state)
 
 	if (door_2.anim_mode & ANIM_HORIZONTAL && x <= VXSIZE)
 	{
+#if 1
+	  int src1_x = g_right->src_x;
+	  int src1_y = g_right->src_y;
+	  int src2_x = g_left->src_x + g_left->width - i;
+	  int src2_y = g_left->src_y;
+	  int dst1_x = VX + VXSIZE - i;
+	  int dst1_y = VY;
+	  int dst2_x = VX;
+	  int dst2_y = VY;
+	  int width = i;
+	  int height = VYSIZE;
+
+	  SetClipOrigin(bm_right, gc_right, dst1_x - src1_x, dst1_y - src1_y);
+	  BlitBitmapMasked(bm_right, drawto, src1_x, src1_y, width, height,
+			   dst1_x, dst1_y);
+
+	  SetClipOrigin(bm_left, gc_left, dst2_x - src2_x, dst2_y - src2_y);
+	  BlitBitmapMasked(bm_left, drawto, src2_x, src2_y, width, height,
+			   dst2_x, dst2_y);
+#else
 	  int src1_x = VXSIZE,		src1_y = DOOR_GFX_PAGEY2;
-	  int dst1_x = VX + VXSIZE - i,	dst1_y = VY;
 	  int src2_x = VXSIZE - i,	src2_y = DOOR_GFX_PAGEY2;
+	  int dst1_x = VX + VXSIZE - i,	dst1_y = VY;
 	  int dst2_x = VX,		dst2_y = VY;
 	  int width = i, height = VYSIZE;
 
@@ -4566,12 +5619,33 @@ unsigned int MoveDoor(unsigned int door_state)
 	  SetClipOrigin(bitmap, gc, dst2_x - src2_x, dst2_y - src2_y);
 	  BlitBitmapMasked(bitmap, drawto, src2_x, src2_y, width, height,
 			   dst2_x, dst2_y);
+#endif
 	}
 	else if (door_2.anim_mode & ANIM_VERTICAL && x <= VYSIZE)
 	{
+#if 1
+	  int src1_x = g_right->src_x;
+	  int src1_y = g_right->src_y;
+	  int src2_x = g_left->src_x;
+	  int src2_y = g_left->src_y + g_left->height - i;
+	  int dst1_x = VX;
+	  int dst1_y = VY + VYSIZE - i;
+	  int dst2_x = VX;
+	  int dst2_y = VY;
+	  int width = VXSIZE;
+	  int height = i;
+
+	  SetClipOrigin(bm_right, gc_right, dst1_x - src1_x, dst1_y - src1_y);
+	  BlitBitmapMasked(bm_right, drawto, src1_x, src1_y, width, height,
+			   dst1_x, dst1_y);
+
+	  SetClipOrigin(bm_left, gc_left, dst2_x - src2_x, dst2_y - src2_y);
+	  BlitBitmapMasked(bm_left, drawto, src2_x, src2_y, width, height,
+			   dst2_x, dst2_y);
+#else
 	  int src1_x = VXSIZE,		src1_y = DOOR_GFX_PAGEY2;
-	  int dst1_x = VX,		dst1_y = VY + VYSIZE - i;
 	  int src2_x = 0,		src2_y = DOOR_GFX_PAGEY2 + VYSIZE - i;
+	  int dst1_x = VX,		dst1_y = VY + VYSIZE - i;
 	  int dst2_x = VX,		dst2_y = VY;
 	  int width = VXSIZE, height = i;
 
@@ -4582,11 +5656,69 @@ unsigned int MoveDoor(unsigned int door_state)
 	  SetClipOrigin(bitmap, gc, dst2_x - src2_x, dst2_y - src2_y);
 	  BlitBitmapMasked(bitmap, drawto, src2_x, src2_y, width, height,
 			   dst2_x, dst2_y);
+#endif
 	}
 	else if (x <= VXSIZE)	/* ANIM_DEFAULT */
 	{
 	  int j = (door_2.anim_mode == ANIM_DEFAULT ? (VXSIZE - i) / 3 : 0);
 
+#if 1
+	  int src1_x = g_right->src_x;
+	  int src1_y = g_right->src_y;
+	  int src2_x = g_left->src_x + g_left->width - i;
+	  int src2_y = g_left->src_y;
+	  int dst1_x = VX + VXSIZE - i;
+	  int dst1_y = VY;
+	  int dst2_x = VX;
+	  int dst2_y = VY;
+	  int width = i;
+	  int height = VYSIZE / 2;
+	  int ypos1 = 0, ypos2 = VYSIZE / 2;
+
+	  SetClipOrigin(bitmap, gc, dst1_x - src1_x, dst1_y - src1_y + j);
+	  BlitBitmapMasked(bitmap, drawto,
+			   src1_x, src1_y + ypos1, width, height,
+			   dst1_x, dst1_y + ypos1 + j);
+	  SetClipOrigin(bitmap, gc, dst2_x - src2_x, dst2_y - src2_y - j);
+	  BlitBitmapMasked(bitmap, drawto,
+			   src2_x, src2_y + ypos1 + j, width, height - j,
+			   dst2_x, dst2_y + ypos1);
+
+	  SetClipOrigin(bitmap, gc, dst2_x - src2_x, dst2_y - src2_y - j);
+	  BlitBitmapMasked(bitmap, drawto,
+			   src2_x, src2_y + ypos2, width, height,
+			   dst2_x, dst2_y + ypos2 - j);
+	  SetClipOrigin(bitmap, gc, dst1_x - src1_x, dst1_y - src1_y + j);
+	  BlitBitmapMasked(bitmap, drawto,
+			   src1_x, src1_y + ypos2, width, height - j,
+			   dst1_x, dst1_y + ypos2 + j);
+#else
+	  int src1_x = VXSIZE,		src1_y = DOOR_GFX_PAGEY2;
+	  int src2_x = VXSIZE - i,	src2_y = DOOR_GFX_PAGEY2;
+	  int dst1_x = VX + VXSIZE - i,	dst1_y = VY;
+	  int dst2_x = VX,		dst2_y = VY;
+	  int width = i, height = VYSIZE;
+	  int ypos = VYSIZE / 2;
+
+	  SetClipOrigin(bitmap, gc, dst1_x - src1_x, dst1_y - src1_y + j);
+	  BlitBitmapMasked(bitmap, drawto,
+			   src1_x, src1_y, width, ypos,
+			   dst1_x, dst1_y + j);
+	  SetClipOrigin(bitmap, gc, dst2_x - src2_x, dst2_y - src1_y - j);
+	  BlitBitmapMasked(bitmap, drawto,
+			   src2_x, src2_y + j, width, ypos - j,
+			   dst2_x, dst2_y);
+
+	  SetClipOrigin(bitmap, gc, dst2_x - src2_x, dst2_y - src1_y - j);
+	  BlitBitmapMasked(bitmap, drawto,
+			   src2_x, src2_y + ypos, width, ypos,
+			   dst2_x, dst2_y + ypos - j);
+	  SetClipOrigin(bitmap, gc, dst1_x - src1_x, dst1_y - src1_y + j);
+	  BlitBitmapMasked(bitmap, drawto,
+			   src1_x, src1_y + ypos, width, ypos - j,
+			   dst1_x, dst1_y + ypos + j);
+
+	  /*
 	  SetClipOrigin(bitmap, gc, VX - i, (VY + j) - DOOR_GFX_PAGEY2);
 	  BlitBitmapMasked(bitmap, drawto,
 			   VXSIZE, DOOR_GFX_PAGEY2, i, VYSIZE / 2,
@@ -4605,6 +5737,8 @@ unsigned int MoveDoor(unsigned int door_state)
 			   VXSIZE, DOOR_GFX_PAGEY2 + VYSIZE / 2,
 			   i, VYSIZE / 2 - j,
 			   VX + VXSIZE - i, VY + VYSIZE / 2 + j);
+	  */
+#endif
 	}
 
 	redraw_mask |= REDRAW_DOOR_2;
@@ -4633,23 +5767,70 @@ unsigned int MoveDoor(unsigned int door_state)
 
 void DrawSpecialEditorDoor()
 {
-  /* draw bigger toolbox window */
+#if 1
+  struct GraphicInfo *gfx1 = &graphic_info[IMG_DOOR_2_TOP_BORDER_CORRECTION];
+  int top_border_width = gfx1->width;
+  int top_border_height = gfx1->height;
+  int outer_border = viewport.door_2[GAME_MODE_EDITOR].border_size;
+  int ex = EX - outer_border;
+  int ey = EY - outer_border;
+  int vy = VY - outer_border;
+  int exsize = EXSIZE + 2 * outer_border;
+
+  CloseDoor(DOOR_CLOSE_2);
+
+  /* draw bigger level editor toolbox window */
+  BlitBitmap(gfx1->bitmap, drawto, gfx1->src_x, gfx1->src_y,
+	     top_border_width, top_border_height, ex, ey - top_border_height);
+  BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, drawto, ex, vy,
+	     exsize, EYSIZE - VYSIZE + outer_border, ex, ey);
+#else
+  /* draw bigger level editor toolbox window */
   BlitBitmap(graphic_info[IMG_GLOBAL_DOOR].bitmap, drawto,
-	     DOOR_GFX_PAGEX7, 0, EXSIZE + 8, 8,
-	     EX - 4, EY - 12);
+             DOOR_GFX_PAGEX7, 0, EXSIZE + 8, 8,
+             EX - 4, EY - 12);
   BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, drawto,
-	     EX - 6, VY - 4, EXSIZE + 12, EYSIZE - VYSIZE + 4,
-	     EX - 6, EY - 4);
+             EX - 6, VY - 4, EXSIZE + 12, EYSIZE - VYSIZE + 4,
+             EX - 6, EY - 4);
+#endif
 
   redraw_mask |= REDRAW_ALL;
 }
 
 void UndrawSpecialEditorDoor()
 {
+#if 1
+  struct GraphicInfo *gfx1 = &graphic_info[IMG_DOOR_2_TOP_BORDER_CORRECTION];
+  int top_border_width = gfx1->width;
+  int top_border_height = gfx1->height;
+  int outer_border = viewport.door_2[GAME_MODE_EDITOR].border_size;
+  int ex = EX - outer_border;
+  int ey = EY - outer_border;
+  int ey_top = ey - top_border_height;
+  int exsize = EXSIZE + 2 * outer_border;
+  int eysize = EYSIZE + 2 * outer_border;
+
+  /* draw normal tape recorder window */
+  if (graphic_info[IMG_GLOBAL_BORDER].bitmap)
+  {
+    BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, drawto,
+	       ex, ey_top, top_border_width, top_border_height,
+	       ex, ey_top);
+    BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, drawto,
+	       ex, ey, exsize, eysize, ex, ey);
+  }
+  else
+  {
+    // if screen background is set to "[NONE]", clear editor toolbox window
+    ClearRectangle(drawto, ex, ey_top, top_border_width, top_border_height);
+    ClearRectangle(drawto, ex, ey, exsize, eysize);
+  }
+#else
   /* draw normal tape recorder window */
   BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, drawto,
-	     EX - 6, EY - 12, EXSIZE + 12, EYSIZE - VYSIZE + 12,
-	     EX - 6, EY - 12);
+             EX - 6, EY - 12, EXSIZE + 12, EYSIZE - VYSIZE + 12,
+             EX - 6, EY - 12);
+#endif
 
   redraw_mask |= REDRAW_ALL;
 }
@@ -4657,6 +5838,107 @@ void UndrawSpecialEditorDoor()
 
 /* ---------- new tool button stuff ---------------------------------------- */
 
+#if 1
+
+static struct
+{
+  int graphic;
+  struct TextPosInfo *pos;
+  int gadget_id;
+  char *infotext;
+} toolbutton_info[NUM_TOOL_BUTTONS] =
+{
+  {
+    IMG_REQUEST_BUTTON_GFX_YES,		&request.button.yes,
+    TOOL_CTRL_ID_YES,			"yes"
+  },
+  {
+    IMG_REQUEST_BUTTON_GFX_NO,		&request.button.no,
+    TOOL_CTRL_ID_NO,			"no"
+  },
+  {
+    IMG_REQUEST_BUTTON_GFX_CONFIRM,	&request.button.confirm,
+    TOOL_CTRL_ID_CONFIRM,		"confirm"
+  },
+  {
+    IMG_REQUEST_BUTTON_GFX_PLAYER_1,	&request.button.player_1,
+    TOOL_CTRL_ID_PLAYER_1,		"player 1"
+  },
+  {
+    IMG_REQUEST_BUTTON_GFX_PLAYER_2,	&request.button.player_2,
+    TOOL_CTRL_ID_PLAYER_2,		"player 2"
+  },
+  {
+    IMG_REQUEST_BUTTON_GFX_PLAYER_3,	&request.button.player_3,
+    TOOL_CTRL_ID_PLAYER_3,		"player 3"
+  },
+  {
+    IMG_REQUEST_BUTTON_GFX_PLAYER_4,	&request.button.player_4,
+    TOOL_CTRL_ID_PLAYER_4,		"player 4"
+  }
+};
+
+void CreateToolButtons()
+{
+  int i;
+
+  for (i = 0; i < NUM_TOOL_BUTTONS; i++)
+  {
+    struct GraphicInfo *gfx = &graphic_info[toolbutton_info[i].graphic];
+    struct TextPosInfo *pos = toolbutton_info[i].pos;
+    struct GadgetInfo *gi;
+    Bitmap *deco_bitmap = None;
+    int deco_x = 0, deco_y = 0, deco_xpos = 0, deco_ypos = 0;
+    unsigned int event_mask = GD_EVENT_RELEASED;
+    int dx = DX;
+    int dy = DY;
+    int gd_x = gfx->src_x;
+    int gd_y = gfx->src_y;
+    int gd_xp = gfx->src_x + gfx->pressed_xoffset;
+    int gd_yp = gfx->src_y + gfx->pressed_yoffset;
+    int id = i;
+
+    if (global.use_envelope_request)
+      setRequestPosition(&dx, &dy, TRUE);
+
+    if (id >= TOOL_CTRL_ID_PLAYER_1 && id <= TOOL_CTRL_ID_PLAYER_4)
+    {
+      int player_nr = id - TOOL_CTRL_ID_PLAYER_1;
+
+      getSizedGraphicSource(PLAYER_NR_GFX(IMG_PLAYER_1, player_nr), 0,
+			    pos->size, &deco_bitmap, &deco_x, &deco_y);
+      deco_xpos = (gfx->width  - pos->size) / 2;
+      deco_ypos = (gfx->height - pos->size) / 2;
+    }
+
+    gi = CreateGadget(GDI_CUSTOM_ID, id,
+		      GDI_INFO_TEXT, toolbutton_info[i].infotext,
+		      GDI_X, dx + pos->x,
+		      GDI_Y, dy + pos->y,
+		      GDI_WIDTH, gfx->width,
+		      GDI_HEIGHT, gfx->height,
+		      GDI_TYPE, GD_TYPE_NORMAL_BUTTON,
+		      GDI_STATE, GD_BUTTON_UNPRESSED,
+		      GDI_DESIGN_UNPRESSED, gfx->bitmap, gd_x, gd_y,
+		      GDI_DESIGN_PRESSED, gfx->bitmap, gd_xp, gd_yp,
+		      GDI_DECORATION_DESIGN, deco_bitmap, deco_x, deco_y,
+		      GDI_DECORATION_POSITION, deco_xpos, deco_ypos,
+		      GDI_DECORATION_SIZE, pos->size, pos->size,
+		      GDI_DECORATION_SHIFTING, 1, 1,
+		      GDI_DIRECT_DRAW, FALSE,
+		      GDI_EVENT_MASK, event_mask,
+		      GDI_CALLBACK_ACTION, HandleToolButtons,
+		      GDI_END);
+
+    if (gi == NULL)
+      Error(ERR_EXIT, "cannot create gadget");
+
+    tool_gadget[id] = gi;
+  }
+}
+
+#else
+
 /* graphic position values for tool buttons */
 #define TOOL_BUTTON_YES_XPOS		2
 #define TOOL_BUTTON_YES_YPOS		250
@@ -4815,6 +6097,8 @@ void CreateToolButtons()
   }
 }
 
+#endif
+
 void FreeToolButtons()
 {
   int i;
@@ -7221,9 +8505,25 @@ int getBeltSwitchElementFromBeltNrAndBeltDir(int belt_nr, int belt_dir)
 
 int getNumActivePlayers_EM()
 {
+#if 1
+  int num_players = 0;
+  int i;
+
+  if (!tape.playing)
+    return (setup.team_mode ? MAX_PLAYERS : 1);
+
+  for (i = 0; i < MAX_PLAYERS; i++)
+    if (tape.player_participates[i])
+      num_players++;
+
+  return (num_players > 1 ? MAX_PLAYERS : 1);
+
+#else
+
   int num_players = 0;
   int i;
 
+  /* when recording game, activate all connected players */
   if (!tape.playing)
     return -1;
 
@@ -7232,6 +8532,7 @@ int getNumActivePlayers_EM()
       num_players++;
 
   return num_players;
+#endif
 }
 
 int getGameFrameDelay_EM(int native_em_game_frame_delay)
@@ -8981,18 +10282,44 @@ void PlaySoundSelecting()
 #endif
 }
 
-void ToggleFullscreenIfNeeded()
+void ToggleFullscreenOrChangeWindowScalingIfNeeded()
 {
   boolean change_fullscreen = (setup.fullscreen !=
 			       video.fullscreen_enabled);
   boolean change_fullscreen_mode = (video.fullscreen_enabled &&
 				    !strEqual(setup.fullscreen_mode,
 					      video.fullscreen_mode_current));
+  boolean change_window_scaling_percent = (!video.fullscreen_enabled &&
+					   setup.window_scaling_percent !=
+					   video.window_scaling_percent);
+
+  if (change_window_scaling_percent && video.fullscreen_enabled)
+    return;
+
+  if (!change_window_scaling_percent && !video.fullscreen_available)
+    return;
+
+#if defined(TARGET_SDL2)
+  if (change_window_scaling_percent)
+  {
+    SDLSetWindowScaling(setup.window_scaling_percent);
+
+    return;
+  }
+  else if (change_fullscreen)
+  {
+    SDLSetWindowFullscreen(setup.fullscreen);
+
+    /* set setup value according to successfully changed fullscreen mode */
+    setup.fullscreen = video.fullscreen_enabled;
 
-  if (!video.fullscreen_available)
     return;
+  }
+#endif
 
-  if (change_fullscreen || change_fullscreen_mode)
+  if (change_fullscreen ||
+      change_fullscreen_mode ||
+      change_window_scaling_percent)
   {
     Bitmap *tmp_backbuffer = CreateBitmap(WIN_XSIZE, WIN_YSIZE, DEFAULT_DEPTH);
 
@@ -9005,9 +10332,16 @@ void ToggleFullscreenIfNeeded()
       video.fullscreen_enabled = FALSE;		/* force new fullscreen mode */
     }
 
+    if (change_window_scaling_percent)
+    {
+      /* keep window mode, but change window scaling */
+      video.fullscreen_enabled = TRUE;		/* force new window scaling */
+    }
+
     /* toggle fullscreen */
     ChangeVideoModeIfNeeded(setup.fullscreen);
 
+    /* set setup value according to successfully changed fullscreen mode */
     setup.fullscreen = video.fullscreen_enabled;
 
     /* restore backbuffer content from temporary backbuffer backup bitmap */
@@ -9026,25 +10360,42 @@ void ToggleFullscreenIfNeeded()
 
 void ChangeViewportPropertiesIfNeeded()
 {
+#if 0
   int *door_1_x = &DX;
   int *door_1_y = &DY;
   int *door_2_x = (game_status == GAME_MODE_EDITOR ? &EX : &VX);
   int *door_2_y = (game_status == GAME_MODE_EDITOR ? &EY : &VY);
+#endif
   int gfx_game_mode = (game_status == GAME_MODE_PLAYING ||
 		       game_status == GAME_MODE_EDITOR ? game_status :
 		       GAME_MODE_MAIN);
+  int gfx_game_mode2 = (game_status == GAME_MODE_EDITOR ? GAME_MODE_DEFAULT :
+			game_status);
   struct RectWithBorder *vp_playfield = &viewport.playfield[gfx_game_mode];
   struct RectWithBorder *vp_door_1 = &viewport.door_1[gfx_game_mode];
-  struct RectWithBorder *vp_door_2 = &viewport.door_2[gfx_game_mode];
-  int border_size = vp_playfield->border_size;
-  int new_sx = vp_playfield->x + border_size;
-  int new_sy = vp_playfield->y + border_size;
-  int new_sxsize = vp_playfield->width  - 2 * border_size;
-  int new_sysize = vp_playfield->height - 2 * border_size;
-  int new_real_sx = vp_playfield->x;
-  int new_real_sy = vp_playfield->y;
-  int new_full_sxsize = vp_playfield->width;
-  int new_full_sysize = vp_playfield->height;
+  struct RectWithBorder *vp_door_2 = &viewport.door_2[gfx_game_mode2];
+  struct RectWithBorder *vp_door_3 = &viewport.door_2[GAME_MODE_EDITOR];
+  int border_size	= vp_playfield->border_size;
+  int new_sx		= vp_playfield->x + border_size;
+  int new_sy		= vp_playfield->y + border_size;
+  int new_sxsize	= vp_playfield->width  - 2 * border_size;
+  int new_sysize	= vp_playfield->height - 2 * border_size;
+  int new_real_sx	= vp_playfield->x;
+  int new_real_sy	= vp_playfield->y;
+  int new_full_sxsize	= vp_playfield->width;
+  int new_full_sysize	= vp_playfield->height;
+  int new_dx		= vp_door_1->x;
+  int new_dy		= vp_door_1->y;
+  int new_dxsize	= vp_door_1->width;
+  int new_dysize	= vp_door_1->height;
+  int new_vx		= vp_door_2->x;
+  int new_vy		= vp_door_2->y;
+  int new_vxsize	= vp_door_2->width;
+  int new_vysize	= vp_door_2->height;
+  int new_ex		= vp_door_3->x;
+  int new_ey		= vp_door_3->y;
+  int new_exsize	= vp_door_3->width;
+  int new_eysize	= vp_door_3->height;
 #if NEW_TILESIZE
   int new_tilesize_var = TILESIZE / (setup.small_game_graphics ? 2 : 1);
   int tilesize = (gfx_game_mode == GAME_MODE_PLAYING ? new_tilesize_var :
@@ -9118,22 +10469,50 @@ void ChangeViewportPropertiesIfNeeded()
 
   if (new_sx != SX ||
       new_sy != SY ||
+      new_dx != DX ||
+      new_dy != DY ||
+      new_vx != VX ||
+      new_vy != VY ||
+      new_ex != EX ||
+      new_ey != EY ||
       new_sxsize != SXSIZE ||
       new_sysize != SYSIZE ||
+      new_dxsize != DXSIZE ||
+      new_dysize != DYSIZE ||
+      new_vxsize != VXSIZE ||
+      new_vysize != VYSIZE ||
+      new_exsize != EXSIZE ||
+      new_eysize != EYSIZE ||
       new_real_sx != REAL_SX ||
       new_real_sy != REAL_SY ||
       new_full_sxsize != FULL_SXSIZE ||
       new_full_sysize != FULL_SYSIZE ||
-      new_tilesize_var != TILESIZE_VAR ||
+      new_tilesize_var != TILESIZE_VAR
+#if 0
+      ||
       vp_door_1->x != *door_1_x ||
       vp_door_1->y != *door_1_y ||
       vp_door_2->x != *door_2_x ||
-      vp_door_2->y != *door_2_y)
+      vp_door_2->y != *door_2_y
+#endif
+      )
   {
     SX = new_sx;
     SY = new_sy;
+    DX = new_dx;
+    DY = new_dy;
+    VX = new_vx;
+    VY = new_vy;
+    EX = new_ex;
+    EY = new_ey;
     SXSIZE = new_sxsize;
     SYSIZE = new_sysize;
+    DXSIZE = new_dxsize;
+    DYSIZE = new_dysize;
+    VXSIZE = new_vxsize;
+    VYSIZE = new_vysize;
+    EXSIZE = new_exsize;
+    EYSIZE = new_eysize;
     REAL_SX = new_real_sx;
     REAL_SY = new_real_sy;
     FULL_SXSIZE = new_full_sxsize;
@@ -9146,10 +10525,12 @@ void ChangeViewportPropertiesIfNeeded()
 	   setup.small_game_graphics);
 #endif
 
+#if 0
     *door_1_x = vp_door_1->x;
     *door_1_y = vp_door_1->y;
     *door_2_x = vp_door_2->x;
     *door_2_y = vp_door_2->y;
+#endif
 
 #if 1
     init_gfx_buffers = TRUE;