diff --git a/src/command/video.cpp b/src/command/video.cpp
index d3ffaf7fe0..a262c0dcc6 100644
--- a/src/command/video.cpp
+++ b/src/command/video.cpp
@@ -603,6 +603,17 @@ struct video_opt_autoscroll final : public Command {
 	}
 };
 
+struct video_pan_reset final : public validator_video_loaded {
+	CMD_NAME("video/pan_reset")
+	STR_MENU("Reset video pan")
+	STR_DISP("Reset video pan")
+	STR_HELP("Reset the video pan to the original value")
+
+	void operator()(agi::Context *c) override {
+		c->videoDisplay->ResetPan();
+	}
+};
+
 struct video_play final : public validator_video_loaded {
 	CMD_NAME("video/play")
 	CMD_ICON(button_play)
@@ -658,7 +669,7 @@ class video_zoom_100: public validator_video_attached {
 
 	void operator()(agi::Context *c) override {
 		c->videoController->Stop();
-		c->videoDisplay->SetZoom(1.);
+		c->videoDisplay->SetWindowZoom(1.);
 	}
 };
 
@@ -689,7 +700,7 @@ class video_zoom_200: public validator_video_attached {
 
 	void operator()(agi::Context *c) override {
 		c->videoController->Stop();
-		c->videoDisplay->SetZoom(2.);
+		c->videoDisplay->SetWindowZoom(2.);
 	}
 };
 
@@ -707,7 +718,7 @@ class video_zoom_50: public validator_video_attached {
 
 	void operator()(agi::Context *c) override {
 		c->videoController->Stop();
-		c->videoDisplay->SetZoom(.5);
+		c->videoDisplay->SetWindowZoom(.5);
 	}
 };
 
@@ -719,7 +730,7 @@ struct video_zoom_in final : public validator_video_attached {
 	STR_HELP("Zoom video in")
 
 	void operator()(agi::Context *c) override {
-		c->videoDisplay->SetZoom(c->videoDisplay->GetZoom() + .125);
+		c->videoDisplay->SetWindowZoom(c->videoDisplay->GetZoom() + .125);
 	}
 };
 
@@ -731,7 +742,7 @@ struct video_zoom_out final : public validator_video_attached {
 	STR_HELP("Zoom video out")
 
 	void operator()(agi::Context *c) override {
-		c->videoDisplay->SetZoom(c->videoDisplay->GetZoom() - .125);
+		c->videoDisplay->SetWindowZoom(c->videoDisplay->GetZoom() - .125);
 	}
 };
 }
@@ -767,6 +778,7 @@ namespace cmd {
 		reg(agi::make_unique<video_open>());
 		reg(agi::make_unique<video_open_dummy>());
 		reg(agi::make_unique<video_opt_autoscroll>());
+		reg(agi::make_unique<video_pan_reset>());
 		reg(agi::make_unique<video_play>());
 		reg(agi::make_unique<video_play_line>());
 		reg(agi::make_unique<video_show_overscan>());
diff --git a/src/frame_main.cpp b/src/frame_main.cpp
index df115b27c4..b37dafefc0 100644
--- a/src/frame_main.cpp
+++ b/src/frame_main.cpp
@@ -276,9 +276,9 @@ void FrameMain::OnVideoOpen(AsyncVideoProvider *provider) {
 	double zoom = context->videoDisplay->GetZoom();
 	wxSize windowSize = GetSize();
 	if (vidx*3*zoom > windowSize.GetX()*4 || vidy*4*zoom > windowSize.GetY()*6)
-		context->videoDisplay->SetZoom(zoom * .25);
+		context->videoDisplay->SetWindowZoom(zoom * .25);
 	else if (vidx*3*zoom > windowSize.GetX()*2 || vidy*4*zoom > windowSize.GetY()*3)
-		context->videoDisplay->SetZoom(zoom * .5);
+		context->videoDisplay->SetWindowZoom(zoom * .5);
 
 	SetDisplayMode(1,-1);
 
diff --git a/src/libresrc/default_config.json b/src/libresrc/default_config.json
index 318f8d3eef..e177379b23 100644
--- a/src/libresrc/default_config.json
+++ b/src/libresrc/default_config.json
@@ -611,6 +611,7 @@
 			"Fast Jump Step" : 10,
 			"Show Keyframes" : true
 		},
-		"Subtitle Sync" : true
+		"Subtitle Sync" : true,
+		"Video Pan": false
 	}
 }
diff --git a/src/libresrc/default_menu.json b/src/libresrc/default_menu.json
index b1797836f8..8d2f6c55b9 100644
--- a/src/libresrc/default_menu.json
+++ b/src/libresrc/default_menu.json
@@ -156,6 +156,7 @@
         { "submenu" : "main/video/set zoom", "text" : "Set &Zoom" },
         { "submenu" : "main/video/override ar", "text" : "Override &AR" },
         { "command" : "video/show_overscan" },
+        { "command" : "video/pan_reset" },
         {},
         { "command" : "video/jump" },
         { "command" : "video/jump/start" },
diff --git a/src/preferences.cpp b/src/preferences.cpp
index f6320dd75d..1eb906c3ad 100644
--- a/src/preferences.cpp
+++ b/src/preferences.cpp
@@ -433,6 +433,9 @@ void Advanced_Video(wxTreebook *book, Preferences *parent) {
 
 	wxArrayString sp_choice = to_wx(SubtitlesProviderFactory::GetClasses());
 	p->OptionChoice(expert, _("Subtitles provider"), sp_choice, "Subtitle/Provider");
+	
+	p->OptionAdd(expert, _("Video Panning"), "Video/Video Pan");
+	
 
 #ifdef WITH_AVISYNTH
 	auto avisynth = p->PageSizer("Avisynth");
diff --git a/src/project.cpp b/src/project.cpp
index e01dd3749f..26776b370b 100644
--- a/src/project.cpp
+++ b/src/project.cpp
@@ -220,7 +220,7 @@ void Project::LoadUnloadFiles(ProjectProperties properties) {
 				vc->SetAspectRatio(properties.ar_value);
 			else
 				vc->SetAspectRatio(ar_mode);
-			context->videoDisplay->SetZoom(properties.video_zoom);
+			context->videoDisplay->SetWindowZoom(properties.video_zoom);
 		}
 	}
 
diff --git a/src/video_display.cpp b/src/video_display.cpp
index 8d85311a6d..ebee959be5 100644
--- a/src/video_display.cpp
+++ b/src/video_display.cpp
@@ -82,19 +82,20 @@ VideoDisplay::VideoDisplay(wxToolBar *toolbar, bool freeSize, wxComboBox *zoomBo
 : wxGLCanvas(parent, -1, attribList)
 , autohideTools(OPT_GET("Tool/Visual/Autohide"))
 , con(c)
-, zoomValue(OPT_GET("Video/Default Zoom")->GetInt() * .125 + .125)
+, windowZoomValue(OPT_GET("Video/Default Zoom")->GetInt() * .125 + .125)
+, videoZoomValue(1)
 , toolBar(toolbar)
 , zoomBox(zoomBox)
 , freeSize(freeSize)
 , retina_helper(agi::make_unique<RetinaHelper>(this))
 , scale_factor(retina_helper->GetScaleFactor())
 , scale_factor_connection(retina_helper->AddScaleFactorListener([=](int new_scale_factor) {
-	double new_zoom = zoomValue * new_scale_factor / scale_factor;
+	double new_zoom = windowZoomValue * new_scale_factor / scale_factor;
 	scale_factor = new_scale_factor;
-	SetZoom(new_zoom);
+	SetWindowZoom(new_zoom);
 }))
 {
-	zoomBox->SetValue(fmt_wx("%g%%", zoomValue * 100.));
+	zoomBox->SetValue(fmt_wx("%g%%", windowZoomValue * 100.));
 	zoomBox->Bind(wxEVT_COMBOBOX, &VideoDisplay::SetZoomFromBox, this);
 	zoomBox->Bind(wxEVT_TEXT_ENTER, &VideoDisplay::SetZoomFromBoxText, this);
 
@@ -113,6 +114,8 @@ VideoDisplay::VideoDisplay(wxToolBar *toolbar, bool freeSize, wxComboBox *zoomBo
 	Bind(wxEVT_LEFT_DCLICK, &VideoDisplay::OnMouseEvent, this);
 	Bind(wxEVT_LEFT_DOWN, &VideoDisplay::OnMouseEvent, this);
 	Bind(wxEVT_LEFT_UP, &VideoDisplay::OnMouseEvent, this);
+	Bind(wxEVT_MIDDLE_DOWN, &VideoDisplay::OnMouseEvent, this);
+	Bind(wxEVT_MIDDLE_UP, &VideoDisplay::OnMouseEvent, this);
 	Bind(wxEVT_MOTION, &VideoDisplay::OnMouseEvent, this);
 	Bind(wxEVT_MOUSEWHEEL, &VideoDisplay::OnMouseWheel, this);
 
@@ -191,11 +194,14 @@ void VideoDisplay::Render() try {
 		PositionVideo();
 
 	videoOut->Render(viewport_left, viewport_bottom, viewport_width, viewport_height);
-	E(glViewport(0, std::min(viewport_bottom, 0), videoSize.GetWidth(), videoSize.GetHeight()));
+
+	int client_w, client_h;
+	GetClientSize(&client_w, &client_h);
+	E(glViewport(0, 0, client_w, client_h));
 
 	E(glMatrixMode(GL_PROJECTION));
 	E(glLoadIdentity());
-	E(glOrtho(0.0f, videoSize.GetWidth() / scale_factor, videoSize.GetHeight() / scale_factor, 0.0f, -1000.0f, 1000.0f));
+	E(glOrtho(0.0f, client_w / scale_factor, client_h / scale_factor, 0.0f, -1000.0f, 1000.0f));
 
 	if (OPT_GET("Video/Overscan Mask")->GetBool()) {
 		double ar = con->videoController->GetAspectRatioValue();
@@ -268,8 +274,11 @@ void VideoDisplay::PositionVideo() {
 	auto provider = con->project->VideoProvider();
 	if (!provider || !IsShownOnScreen()) return;
 
+	int client_w, client_h;
+	GetClientSize(&client_w, &client_h);
+
 	viewport_left = 0;
-	viewport_bottom = GetClientSize().GetHeight() * scale_factor - videoSize.GetHeight();
+	viewport_bottom = client_h * scale_factor - videoSize.GetHeight();
 	viewport_top = 0;
 	viewport_width = videoSize.GetWidth();
 	viewport_height = videoSize.GetHeight();
@@ -279,27 +288,33 @@ void VideoDisplay::PositionVideo() {
 		int vidH = provider->GetHeight();
 
 		AspectRatio arType = con->videoController->GetAspectRatioType();
-		double displayAr = double(viewport_width) / viewport_height;
+		double displayAr = double(client_w) / client_h;
 		double videoAr = arType == AspectRatio::Default ? double(vidW) / vidH : con->videoController->GetAspectRatioValue();
 
 		// Window is wider than video, blackbox left/right
 		if (displayAr - videoAr > 0.01) {
-			int delta = viewport_width - videoAr * viewport_height;
+			int delta = client_w - videoAr * client_h;
 			viewport_left = delta / 2;
-			viewport_width -= delta;
 		}
 		// Video is wider than window, blackbox top/bottom
 		else if (videoAr - displayAr > 0.01) {
-			int delta = viewport_height - viewport_width / videoAr;
-			viewport_top = viewport_bottom = delta / 2;
+			int delta = client_h - client_w / videoAr;
+			viewport_top += delta / 2;
+			viewport_bottom += delta / 2;
 			viewport_height -= delta;
+			viewport_width = viewport_height * videoAr;
 		}
 	}
 
-	if (tool)
+	viewport_left += pan_x;
+	viewport_top += pan_y;
+	viewport_bottom -= pan_y;
+
+	if (tool) {
+		tool->SetClientSize(client_w * scale_factor, client_h * scale_factor);
 		tool->SetDisplayArea(viewport_left / scale_factor, viewport_top / scale_factor,
 		                     viewport_width / scale_factor, viewport_height / scale_factor);
-
+	}
 	Render();
 }
 
@@ -308,23 +323,24 @@ void VideoDisplay::UpdateSize() {
 	if (!provider || !IsShownOnScreen()) return;
 
 	videoSize.Set(provider->GetWidth(), provider->GetHeight());
-	videoSize *= zoomValue;
-	if (con->videoController->GetAspectRatioType() != AspectRatio::Default)
-		videoSize.SetWidth(videoSize.GetHeight() * con->videoController->GetAspectRatioValue());
+	videoSize *= videoZoomValue * windowZoomValue;
 
 	wxEventBlocker blocker(this);
 	if (freeSize) {
 		wxWindow *top = GetParent();
 		while (!top->IsTopLevel()) top = top->GetParent();
 
-		wxSize cs = GetClientSize();
+		wxSize oldClientSize = GetClientSize();
+		double csAr = (double)oldClientSize.GetWidth() / (double)oldClientSize.GetHeight();
+		wxSize newClientSize = wxSize(std::lround(provider->GetHeight() * csAr), provider->GetHeight()) * windowZoomValue / scale_factor;
 		wxSize oldSize = top->GetSize();
-		top->SetSize(top->GetSize() + videoSize / scale_factor - cs);
-		SetClientSize(cs + top->GetSize() - oldSize);
+		top->SetSize(oldSize + (newClientSize - oldClientSize));
+		SetClientSize(oldClientSize + (top->GetSize() - oldSize));
 	}
 	else {
-		SetMinClientSize(videoSize / scale_factor);
-		SetMaxClientSize(videoSize / scale_factor);
+		wxSize newSize = wxSize(provider->GetWidth(), provider->GetHeight()) * windowZoomValue / scale_factor;
+		SetMinClientSize(newSize);
+		SetMaxClientSize(newSize);
 
 		GetGrandParent()->Layout();
 	}
@@ -334,11 +350,16 @@ void VideoDisplay::UpdateSize() {
 
 void VideoDisplay::OnSizeEvent(wxSizeEvent &event) {
 	if (freeSize) {
-		videoSize = GetClientSize() * scale_factor;
-		PositionVideo();
-		zoomValue = double(viewport_height) / con->project->VideoProvider()->GetHeight();
-		zoomBox->ChangeValue(fmt_wx("%g%%", zoomValue * 100.));
-		con->ass->Properties.video_zoom = zoomValue;
+		/* If the video is not moved */
+		if (videoZoomValue == 1.0f && pan_x == 0 && pan_y == 0)
+			videoSize = GetClientSize() * scale_factor;
+		/* If the video is moving, we only need to update the size in this case */
+		else if (videoSize.GetWidth() == 0 && videoSize.GetHeight() == 0)
+			videoSize = GetClientSize() * videoZoomValue * scale_factor;
+		windowZoomValue = double(GetClientSize().GetHeight()) / con->project->VideoProvider()->GetHeight();
+		zoomBox->ChangeValue(fmt_wx("%g%%", windowZoomValue * 100.));
+		con->ass->Properties.video_zoom = windowZoomValue;
+		UpdateSize();
 	}
 	else {
 		PositionVideo();
@@ -351,6 +372,30 @@ void VideoDisplay::OnMouseEvent(wxMouseEvent& event) {
 
 	last_mouse_pos = mouse_pos = event.GetPosition();
 
+	///if video pan
+	bool videoPan = OPT_GET("Video/Video Pan")->GetBool();
+
+	if (videoPan){
+		if (event.GetButton() == wxMOUSE_BTN_MIDDLE) {
+			if ((panning = event.ButtonDown()))
+				pan_last_pos = event.GetPosition();
+		}
+		if (panning && event.Dragging()) {
+			pan_x += event.GetX() - pan_last_pos.X();
+			pan_y += event.GetY() - pan_last_pos.Y();
+			pan_last_pos = event.GetPosition();
+
+			PositionVideo();
+		}
+	}
+	else if ((pan_x != 0 || pan_y != 0) && !videoPan)
+	{
+	    pan_x = pan_y = 0;
+	    PositionVideo();
+	}
+
+	///
+
 	if (tool)
 		tool->OnMouseEvent(event);
 }
@@ -362,9 +407,13 @@ void VideoDisplay::OnMouseLeave(wxMouseEvent& event) {
 }
 
 void VideoDisplay::OnMouseWheel(wxMouseEvent& event) {
+	bool videoPan = OPT_GET("Video/Video Pan")->GetBool();
 	if (int wheel = event.GetWheelRotation()) {
 		if (ForwardMouseWheelEvent(this, event))
-			SetZoom(zoomValue + .125 * (wheel / event.GetWheelDelta()));
+			if (event.ControlDown() || !videoPan)
+				SetWindowZoom(windowZoomValue + .125 * (wheel / event.GetWheelDelta()));
+			else
+				SetVideoZoom(wheel / event.GetWheelDelta());
 	}
 }
 
@@ -378,22 +427,63 @@ void VideoDisplay::OnKeyDown(wxKeyEvent &event) {
 	hotkey::check("Video", con, event);
 }
 
-void VideoDisplay::SetZoom(double value) {
+void VideoDisplay::ResetPan() {
+	pan_x = pan_y = 0;
+	videoZoomValue = 1;
+	UpdateSize();
+	PositionVideo();
+}
+
+void VideoDisplay::SetWindowZoom(double value) {
 	if (value == 0) return;
-	zoomValue = std::max(value, .125);
-	size_t selIndex = zoomValue / .125 - 1;
+	value = std::max(value, .125);
+	pan_x *= value / windowZoomValue;
+	pan_y *= value / windowZoomValue;
+	windowZoomValue = value;
+	size_t selIndex = windowZoomValue / .125 - 1;
 	if (selIndex < zoomBox->GetCount())
 		zoomBox->SetSelection(selIndex);
-	zoomBox->ChangeValue(fmt_wx("%g%%", zoomValue * 100.));
-	con->ass->Properties.video_zoom = zoomValue;
+	zoomBox->ChangeValue(fmt_wx("%g%%", windowZoomValue * 100.));
+	con->ass->Properties.video_zoom = windowZoomValue;
+	UpdateSize();
+}
+
+void VideoDisplay::SetVideoZoom(int step) {
+	if (step == 0) return;
+	double newVideoZoom = videoZoomValue + (.125 * step) * videoZoomValue;
+	if (newVideoZoom < 0.125 || newVideoZoom > 10.0)
+		return;
+
+	// With the current blackbox algorithm in PositionVideo(), viewport_{width,height} could go negative. Stop that here
+	wxSize cs = GetClientSize();
+	wxSize videoNewSize = videoSize * (newVideoZoom / videoZoomValue);
+	float windowAR = (float)cs.GetWidth() / cs.GetHeight();
+	float videoAR = (float)videoNewSize.GetWidth() / videoNewSize.GetHeight();
+	if (windowAR < videoAR) {
+		int delta = cs.GetHeight() - cs.GetWidth() / videoAR;
+		if (videoNewSize.GetHeight() - delta < 0)
+			return;
+	}
+
+	// Mouse coordinates, relative to the video, at the current zoom level
+	Vector2D mp = GetMousePosition() * videoZoomValue * windowZoomValue;
+
+	// The video size will change by this many pixels
+	int pixelChangeW = std::lround(videoSize.GetWidth() * (newVideoZoom / videoZoomValue - 1.0));
+	int pixelChangeH = std::lround(videoSize.GetHeight() * (newVideoZoom / videoZoomValue - 1.0));
+
+	pan_x -= pixelChangeW * (mp.X() / videoSize.GetWidth());
+	pan_y -= pixelChangeH * (mp.Y() / videoSize.GetHeight());
+
+	videoZoomValue = newVideoZoom;
 	UpdateSize();
 }
 
 void VideoDisplay::SetZoomFromBox(wxCommandEvent &) {
 	int sel = zoomBox->GetSelection();
 	if (sel != wxNOT_FOUND) {
-		zoomValue = (sel + 1) * .125;
-		con->ass->Properties.video_zoom = zoomValue;
+		windowZoomValue = (sel + 1) * .125;
+		con->ass->Properties.video_zoom = windowZoomValue;
 		UpdateSize();
 	}
 }
@@ -405,7 +495,7 @@ void VideoDisplay::SetZoomFromBoxText(wxCommandEvent &) {
 
 	double value;
 	if (strValue.ToDouble(&value))
-		SetZoom(value / 100.);
+		SetWindowZoom(value / 100.);
 }
 
 void VideoDisplay::SetTool(std::unique_ptr<VisualToolBase> new_tool) {
diff --git a/src/video_display.h b/src/video_display.h
index f0d65edb67..bd27a05692 100644
--- a/src/video_display.h
+++ b/src/video_display.h
@@ -84,8 +84,19 @@ class VideoDisplay final : public wxGLCanvas {
 	/// The height of the video in screen pixels
 	int viewport_height = 0;
 
-	/// The current zoom level, where 1.0 = 100%
-	double zoomValue;
+	/// The current window zoom level, where 1.0 = 100%
+	double windowZoomValue;
+	/// The current video zoom level, where 1.0 = 100% relative to the display window size
+	double videoZoomValue;
+
+	/// The last position of the mouse, when dragging
+	Vector2D pan_last_pos;
+	/// True if middle mouse button is down, and we should update pan_{x,y}
+	bool panning = false;
+	/// The current video pan offset width
+	int pan_x = 0;
+	/// The current video pan offset height
+	int pan_y = 0;
 
 	/// The video renderer
 	std::unique_ptr<VideoOutGL> videoOut;
@@ -156,9 +167,13 @@ class VideoDisplay final : public wxGLCanvas {
 
 	/// @brief Set the zoom level
 	/// @param value The new zoom level
-	void SetZoom(double value);
+	void SetWindowZoom(double value);
+	void SetVideoZoom(int step);
 	/// @brief Get the current zoom level
-	double GetZoom() const { return zoomValue; }
+	double GetZoom() const { return windowZoomValue; }
+
+	/// @brief Reset the video pan
+	void ResetPan();
 
 	/// Get the last seen position of the mouse in script coordinates
 	Vector2D GetMousePosition() const;
diff --git a/src/visual_tool.cpp b/src/visual_tool.cpp
index 61d3207226..6465fe2484 100644
--- a/src/visual_tool.cpp
+++ b/src/visual_tool.cpp
@@ -132,6 +132,10 @@ AssDialogue* VisualToolBase::GetActiveDialogueLine() {
 	return nullptr;
 }
 
+void VisualToolBase::SetClientSize(int w, int h) {
+	client_size = Vector2D(w, h);
+}
+
 void VisualToolBase::SetDisplayArea(int x, int y, int w, int h) {
 	if (x == video_pos.X() && y == video_pos.Y() && w == video_res.X() && h == video_res.Y()) return;
 
diff --git a/src/visual_tool.h b/src/visual_tool.h
index 72eec42249..15d0b007dc 100644
--- a/src/visual_tool.h
+++ b/src/visual_tool.h
@@ -104,6 +104,7 @@ class VisualToolBase {
 	Vector2D script_res; ///< Script resolution
 	Vector2D video_pos; ///< Top-left corner of the video in the display area
 	Vector2D video_res; ///< Video resolution
+	Vector2D client_size; ///< The size of the display area
 
 	const agi::OptionValue *highlight_color_primary_opt;
 	const agi::OptionValue *highlight_color_secondary_opt;
@@ -144,6 +145,7 @@ class VisualToolBase {
 	// Stuff called by VideoDisplay
 	virtual void OnMouseEvent(wxMouseEvent &event)=0;
 	virtual void Draw()=0;
+	virtual void SetClientSize(int w, int h);
 	virtual void SetDisplayArea(int x, int y, int w, int h);
 	virtual void SetToolbar(wxToolBar *) { }
 	virtual ~VisualToolBase() = default;
diff --git a/src/visual_tool_cross.cpp b/src/visual_tool_cross.cpp
index ffbf5329b3..ae82be7750 100644
--- a/src/visual_tool_cross.cpp
+++ b/src/visual_tool_cross.cpp
@@ -70,9 +70,9 @@ void VisualToolCross::Draw() {
 	gl.SetLineColour(*wxWHITE, 1.0, 1);
 	float lines[] = {
 		0.f, mouse_pos.Y(),
-		video_res.X() + video_pos.X() * 2, mouse_pos.Y(),
+		client_size.X(), mouse_pos.Y(),
 		mouse_pos.X(), 0.f,
-		mouse_pos.X(), video_res.Y() + video_pos.Y() * 2
+		mouse_pos.X(), client_size.Y(),
 	};
 	gl.DrawLines(2, lines, 4);
 	gl.ClearInvert();
@@ -87,12 +87,12 @@ void VisualToolCross::Draw() {
 	// Place the text in the corner of the cross closest to the center of the video
 	int dx = mouse_pos.X();
 	int dy = mouse_pos.Y();
-	if (dx > video_res.X() / 2)
+	if (dx > client_size.X() / 2)
 		dx -= tw + 4;
 	else
 		dx += 4;
 
-	if (dy < video_res.Y() / 2)
+	if (dy < client_size.Y() / 2)
 		dy += 3;
 	else
 		dy -= th + 3;