Subject: FVWM: Manual window movement with SNAPPING!

From: Kobus Retief <[email-masked]>
Date: Wed, 2 Feb 2005 21:53:57 +0200

Ola

I wrote about this I while ago, but didn't get any response.  Decided to
give it another shot (at the start of the month, for a change)...

I move windows around with key bindings; to tell the truth most of my
fvwm configuration is keyboard-based.  The problem is that, sure, it's
easy to move windows to specific positions, but what I really need is
something that will snap the window to the closest intervening window
border (almost comparable to the "grow" option of the resize functions).

I hacked up a simple solution -- please note, it's a HACK, so it's not
guaranteed to take into account anybody else's preferences.  For
example, I've hardcoded it to do animated moves, which really should be
a distinct parameter.  The fvwm2rc syntax is also a bit dodgy, but for a
proof-of-concept patch it works admirably (after all, I use it every
day).

To use: apply the patch (against fvwm-2.5.12), add the following lines
to your .fvwm2rc ...

Key Up		WSF	C	SnapMove North
Key Left	WSF	C	SnapMove West
Key Down	WSF	C	SnapMove South
Key Right	WSF	C	SnapMove East

... and happily move windows around with Ctrl-Cursor.  Good idea/bad
idea -- let me know please.

Cheers
-- 
Kobus Retief
diff -Nurp fvwm-2.5.12/fvwm/commands.h fvwm-2.5.12-new/fvwm/commands.h
--- fvwm-2.5.12/fvwm/commands.h	2004-09-30 19:47:16.000000000 +0200
+++ fvwm-2.5.12-new/fvwm/commands.h	2005-01-31 23:31:15.100199288 +0200
@@ -178,6 +178,7 @@ enum
 	F_RESIZEMOVE_MAXIMIZE,
 	F_RESTACKTRANSIENTS,
 	F_SEND_STRING,
+	F_SNAPMOVE,
 	F_STATE,
 	F_STICK,
 	F_STICKACROSSDESKS,
@@ -355,6 +356,7 @@ P(SetAnimation);
 P(SetEnv);
 P(SnapAttraction);
 P(SnapGrid);
+P(SnapMove);
 P(State);
 P(Stick);
 P(StickAcrossDesks);
diff -Nurp fvwm-2.5.12/fvwm/functable.c fvwm-2.5.12-new/fvwm/functable.c
--- fvwm-2.5.12/fvwm/functable.c	2004-09-30 19:47:16.000000000 +0200
+++ fvwm-2.5.12-new/fvwm/functable.c	2005-01-31 23:31:15.100199288 +0200
@@ -553,6 +553,10 @@ const func_t func_table[] =
 	CMD_ENT("snapgrid", CMD_SnapGrid, F_SNAP_GRID, 0, 0),
 	/* - Control grid used with SnapAttraction */
 
+	CMD_ENT("snapmove", CMD_SnapMove, F_SNAPMOVE,
+		FUNC_NEEDS_WINDOW, CRS_MOVE),
+	/* - Move a window to snap to nearest neighbour */
+	
 	CMD_ENT("state", CMD_State, F_STATE,
 		FUNC_NEEDS_WINDOW, CRS_SELECT),
 	/* - Control user defined window states */
diff -Nurp fvwm-2.5.12/fvwm/move_resize.c fvwm-2.5.12-new/fvwm/move_resize.c
--- fvwm-2.5.12/fvwm/move_resize.c	2004-09-27 11:33:04.000000000 +0200
+++ fvwm-2.5.12-new/fvwm/move_resize.c	2005-01-31 23:44:03.382402640 +0200
@@ -60,6 +60,7 @@
 #include "colormaps.h"
 #include "update.h"
 #include "stack.h"
+#include "placement.h"
 
 /* ----- move globals ----- */
 
@@ -2670,6 +2671,256 @@ void CMD_SnapGrid(F_CMD_ARGS)
 	return;
 }
 
+
+
+/*
+ * Move a window to the closest position that'll snap to the border of
+ * an intervening or adjacent window.  Picture setting SnapAttraction,
+ * then moving the window by hand in a direction (north, south, east or
+ * west).  The first place it snaps is where this function places the
+ * window.
+ *
+ * Syntax: SnapMove North | South | East | West
+ *
+ * This is a proof-of-concept implementation, so don't expect it to be
+ * pretty...
+ *
+ * TODO:
+ * - Handle Warp/Animate parameters instead of just setting 'em
+ * - See rant about __move_window()
+ * - Should I handle NorthEast, SouthWest etc?
+ * - Should I snap to SnapGrid as well?
+ * - If I do snap to SnapGrid, shouldn't I be checking snap behaviour?
+ *   I.e. snap only to SnapGrid if SnapAttraction is set to 0...
+ *        snap only to window borders if SnapGrid is set to 0...
+ * - If I do check snap behaviour, shouldn't there be a clearer
+ *   mechanism to state user preference (e.g. SnapBehaviour)
+ * - I think I might be doing something horribly wrong in the depths of
+ *   this function; it works well with my .fvwm2rc, but I don't use
+ *   icons.  It'll probably break with a different config.
+ * - Xinerama spanning, screen border handling (what about
+ *   EdgeResistance?)
+ * - ...
+ */
+void CMD_SnapMove(F_CMD_ARGS)
+{
+	/* Read parameters */
+	direction_t direction = gravity_parse_dir_argument(action, &action, DIR_NONE);
+	if (direction != DIR_N && direction != DIR_S && direction != DIR_E && direction != DIR_W)
+		return;
+
+	/* May we move it? */
+	FvwmWindow *fw = exc->w.fw;
+	if (!is_function_allowed(F_MOVE, NULL, fw, True, False))
+		return;
+
+	/* Extract current window geometry
+	 * Is there a better, fail-safe method to do this?  A more
+	 * arcane, voodoo-magic bit of code that I didn't notice?  What
+	 * I really want to know is, is get_..._geometry() sufficient
+	 * for snap checking?
+	 */
+	rectangle self;
+	if (!get_visible_window_or_icon_geometry(fw, &self))
+		return;
+
+	/* Compare with other window borders */
+	FvwmWindow *tmp;
+	rectangle other;
+
+	int new_x = self.x;
+	int new_y = self.y;
+
+	int min_dx = 99999;
+	int max_dx = -99999;
+	int min_dy = 99999;
+	int max_dy = -99999;
+
+	for (tmp = Scr.FvwmRoot.next; tmp; tmp = tmp->next) {
+		if (fw->Desk != tmp->Desk || fw == tmp)
+			continue;
+		if (!get_visible_window_or_icon_geometry(tmp, &other))
+			continue;
+
+		/* Placement penalty -- unabashedly ripped from placement.c */
+		int placement_penalty = 0;
+		if (IS_ICONIFIED(tmp))
+			placement_penalty = ICON_PLACEMENT_PENALTY(tmp);
+		else if (compare_window_layers(tmp, fw) > 0)
+			placement_penalty = ONTOP_PLACEMENT_PENALTY(tmp);
+		else if (compare_window_layers(tmp, fw) < 0)
+			placement_penalty = BELOW_PLACEMENT_PENALTY(tmp);
+		else if (IS_STICKY_ACROSS_PAGES(tmp) || IS_STICKY_ACROSS_DESKS(tmp))
+			placement_penalty = STICKY_PLACEMENT_PENALTY(tmp);
+		else
+			placement_penalty = NORMAL_PLACEMENT_PENALTY(tmp);
+		if (placement_penalty == 0) continue;
+
+		int tmp_x, tmp_dx;
+		int tmp_y, tmp_dy;
+
+		if (self.y >= other.y - self.height && self.y <= other.y + other.height) {
+			tmp_x = other.x + other.width;
+			tmp_dx = tmp_x - self.x;
+			if (tmp_x < 0)
+				tmp_x = 0;
+			if (tmp_x > Scr.MyDisplayWidth - self.width)
+				tmp_x = Scr.MyDisplayWidth - self.width;
+			if (direction == DIR_W && tmp_dx < 0 && tmp_dx > max_dx) {
+				new_x = tmp_x;
+				max_dx = tmp_dx;
+			}
+			if (direction == DIR_E && tmp_dx > 0 && tmp_dx < min_dx) {
+				new_x = tmp_x;
+				min_dx = tmp_dx;
+			}
+
+			tmp_x = other.x - self.width;
+			tmp_dx = tmp_x - self.x;
+			if (tmp_x < 0)
+				tmp_x = 0;
+			if (tmp_x > Scr.MyDisplayWidth - self.width)
+				tmp_x = Scr.MyDisplayWidth - self.width;
+			if (direction == DIR_W && tmp_dx < 0 && tmp_dx > max_dx) {
+				new_x = tmp_x;
+				max_dx = tmp_dx;
+			}
+			if (direction == DIR_E && tmp_dx > 0 && tmp_dx < min_dx) {
+				new_x = tmp_x;
+				min_dx = tmp_dx;
+			}
+		}
+
+		if (self.x >= other.x - self.width && self.x <= other.x + other.width) {
+			tmp_y = other.y + other.height;
+			tmp_dy = tmp_y - self.y;
+			if (tmp_y < 0)
+				tmp_y = 0;
+			if (tmp_y > Scr.MyDisplayHeight - self.height)
+				tmp_y = Scr.MyDisplayHeight - self.height;
+			if (direction == DIR_N && tmp_dy < 0 && tmp_dy > max_dy) {
+				new_y = tmp_y;
+				max_dy = tmp_dy;
+			}
+			if (direction == DIR_S && tmp_dy > 0 && tmp_dy < min_dy) {
+				new_y = tmp_y;
+				min_dy = tmp_dy;
+			}
+
+			tmp_y = other.y - self.height;
+			tmp_dy = tmp_y - self.y;
+			if (tmp_y < 0)
+				tmp_y = 0;
+			if (tmp_y > Scr.MyDisplayHeight - self.height)
+				tmp_y = Scr.MyDisplayHeight - self.height;
+			if (direction == DIR_N && tmp_dy < 0 && tmp_dy > max_dy) {
+				new_y = tmp_y;
+				max_dy = tmp_dy;
+			}
+			if (direction == DIR_S && tmp_dy > 0 && tmp_dy < min_dy) {
+				new_y = tmp_y;
+				min_dy = tmp_dy;
+			}
+		}
+	}
+
+	/* Compare with display borders */
+	if (self.x < 0)
+		new_x = 0;
+	if (self.x > Scr.MyDisplayWidth - self.width)
+		new_x = Scr.MyDisplayWidth - self.width;
+	if (self.y < 0)
+		new_y = 0;
+	if (self.y > Scr.MyDisplayHeight - self.height)
+		new_y = Scr.MyDisplayHeight - self.height;
+	if (new_x == self.x) {
+		if (direction == DIR_W)
+			new_x = 0;
+		if (direction == DIR_E)
+			new_x = Scr.MyDisplayWidth - self.width;
+	}
+
+	if (new_y == self.y) {
+		if (direction == DIR_N)
+			new_y = 0;
+		if (direction == DIR_S)
+			new_y = Scr.MyDisplayHeight - self.height;
+	}
+
+	/* Move the window -- this code unabashedly copied, pasted and
+	 * modified from __move_window().  It's ugly and hackish, but I
+	 * decided to use tried and tested code blindly instead of
+	 * painstakingly attempting to figure out exactly what it does,
+	 * and then duplicating it by hand.  Clever, no?
+	 *
+	 * <RANT>
+	 * Shouldn't this code block be abstracted to its own function?
+	 * It does almost exactly the same thing as __move_icon(), only
+	 * for client windows.  In my opinion __move_window() shouldn't
+	 * be parsing parameters, it should simply move windows.  I'm
+	 * biased, of course, since a pure movement function will make
+	 * my life a bit easier...
+	 * </RANT>
+	 */
+	Window w;
+
+	w = FW_W_FRAME(fw);
+	if (IS_ICONIFIED(fw))
+	{
+		if (FW_W_ICON_PIXMAP(fw) != None)
+		{
+			w = FW_W_ICON_PIXMAP(fw);
+			XUnmapWindow(dpy,FW_W_ICON_TITLE(fw));
+		}
+		else
+		{
+			w = FW_W_ICON_TITLE(fw);
+		}
+	}
+
+	Window JunkRoot;
+	int JunkWidth, JunkHeight, JunkBW, JunkDepth;
+	int old_x, old_y;
+	XGetGeometry(dpy, w, &JunkRoot, &old_x, &old_y, &JunkWidth, &JunkHeight, &JunkBW, &JunkDepth);
+
+	/* These two should probably be set through parameters */
+	Bool do_animate	= TRUE;		/* Li'l hack */
+	Bool fWarp	= TRUE;		/* Li'l hackity hack hack hack */
+
+	if (w == FW_W_FRAME(fw))
+	{
+		int dx = new_x - fw->frame_g.x;
+		int dy = new_y - fw->frame_g.y;
+		if (do_animate)
+			AnimatedMoveFvwmWindow(fw, w, -1, -1, new_x, new_y, fWarp, -1, NULL);
+		frame_setup_window( fw, new_x, new_y, fw->frame_g.width, fw->frame_g.height, True);
+		if (fWarp & !do_animate)
+			FWarpPointer(dpy, None, None, 0, 0, 0, 0, new_x - old_x, new_y - old_y);
+		if (IS_MAXIMIZED(fw))
+		{
+			fw->max_g.x += dx;
+			fw->max_g.y += dy;
+		}
+		else
+		{
+			fw->normal_g.x += dx;
+			fw->normal_g.y += dy;
+		}
+		update_absolute_geometry(fw);
+		maximize_adjust_offset(fw);
+		XFlush(dpy);
+		GNOME_SetWinArea(fw);
+	}
+	else /* icon window */
+	{
+		__move_icon(fw, new_x, new_y, old_x, old_y, do_animate, fWarp);
+		XFlush(dpy);
+	}
+
+	return;
+}
+
+
 static Pixmap XorPixmap = None;
 
 void CMD_XorValue(F_CMD_ARGS)

---

From: Thomas Adam <[email-masked]>
Date: Wed, 2 Feb 2005 21:24:39 +0000

On Wed, Feb 02, 2005 at 09:53:57PM +0200, Kobus Retief wrote:
> Ola
>
> I wrote about this I while ago, but didn't get any response. Decided
> to give it another shot (at the start of the month, for a change)...
>
> I move windows around with key bindings; to tell the truth most of
> my fvwm configuration is keyboard-based. The problem is that, sure,
> it's easy to move windows to specific positions, but what I really
> need is something that will snap the window to the closest intervening
> window border (almost comparable to the "grow" option of the resize
> functions).

Cool.  Tavis Ormandy has already done this, by way of complex functions.
You can see this in his config file[1].  The functions which do this
are:

PackWindow{Up,Down,Left,Right}

-- Thomas Adam

[1] http://www.tonywhitmore.co.uk/scripts/report_home_size

-- 
I know nothing, and understand even less.
--
Visit the official FVWM web page at <URL: http://www.fvwm.org/>.
To unsubscribe from the list, send "unsubscribe fvwm" in the body of a
message to [email-masked].
To report problems, send mail to [email-masked].

---

From: Tavis Ormandy <[email-masked]>
Date: Thu, 3 Feb 2005 13:11:08 +0000

> > window border (almost comparable to the "grow" option of the resize

Ahh, I don't remember seeing your original post, I would have mentioned
these PackWindow functions I have, they sound like what you're looking
for. 

I use them from time to time and find them very handy, I have them
bound to Alt+Shift+Arrows.

Thomas Adam accidentally put the wrong URL, it's at: 
http://dev.gentoo.org/~taviso/fvwm2rc.html

-- 
-------------------------------------
[email-masked] | finger me for my gpg key.
-------------------------------------------------------
--
Visit the official FVWM web page at <URL: http://www.fvwm.org/>.
To unsubscribe from the list, send "unsubscribe fvwm" in the body of a
message to [email-masked].
To report problems, send mail to [email-masked].