ClangFormat: apply to source, most of intern

Apply clang format as proposed in T53211.

For details on usage and instructions for migrating branches
without conflicts, see:

https://wiki.blender.org/wiki/Tools/ClangFormat

1 files changed, 339 insertions, 339 deletions

diff --git a/source/blender/editors/screen/screen_geometry.c b/source/blender/editors/screen/screen_geometry.c
index 68fd28013f8..1ad0e930582 100644
--- a/source/blender/editors/screen/screen_geometry.c
+++ b/source/blender/editors/screen/screen_geometry.c
@@ -39,108 +39,108 @@
 
 #include "screen_intern.h"
 
-
 int screen_geom_area_height(const ScrArea *area)
 {
-	return area->v2->vec.y - area->v1->vec.y + 1;
+  return area->v2->vec.y - area->v1->vec.y + 1;
 }
 int screen_geom_area_width(const ScrArea *area)
 {
-	return area->v4->vec.x - area->v1->vec.x + 1;
+  return area->v4->vec.x - area->v1->vec.x + 1;
 }
 
 ScrVert *screen_geom_vertex_add_ex(ScrAreaMap *area_map, short x, short y)
 {
-	ScrVert *sv = MEM_callocN(sizeof(ScrVert), "addscrvert");
-	sv->vec.x = x;
-	sv->vec.y = y;
+  ScrVert *sv = MEM_callocN(sizeof(ScrVert), "addscrvert");
+  sv->vec.x = x;
+  sv->vec.y = y;
 
-	BLI_addtail(&area_map->vertbase, sv);
-	return sv;
+  BLI_addtail(&area_map->vertbase, sv);
+  return sv;
 }
 ScrVert *screen_geom_vertex_add(bScreen *sc, short x, short y)
 {
-	return screen_geom_vertex_add_ex(AREAMAP_FROM_SCREEN(sc), x, y);
+  return screen_geom_vertex_add_ex(AREAMAP_FROM_SCREEN(sc), x, y);
 }
 
 ScrEdge *screen_geom_edge_add_ex(ScrAreaMap *area_map, ScrVert *v1, ScrVert *v2)
 {
-	ScrEdge *se = MEM_callocN(sizeof(ScrEdge), "addscredge");
+  ScrEdge *se = MEM_callocN(sizeof(ScrEdge), "addscredge");
 
-	BKE_screen_sort_scrvert(&v1, &v2);
-	se->v1 = v1;
-	se->v2 = v2;
+  BKE_screen_sort_scrvert(&v1, &v2);
+  se->v1 = v1;
+  se->v2 = v2;
 
-	BLI_addtail(&area_map->edgebase, se);
-	return se;
+  BLI_addtail(&area_map->edgebase, se);
+  return se;
 }
 ScrEdge *screen_geom_edge_add(bScreen *sc, ScrVert *v1, ScrVert *v2)
 {
-	return screen_geom_edge_add_ex(AREAMAP_FROM_SCREEN(sc), v1, v2);
+  return screen_geom_edge_add_ex(AREAMAP_FROM_SCREEN(sc), v1, v2);
 }
 
 bool screen_geom_edge_is_horizontal(ScrEdge *se)
 {
-	return (se->v1->vec.y == se->v2->vec.y);
+  return (se->v1->vec.y == se->v2->vec.y);
 }
 
 /**
  * \param bounds_rect: Either window or screen bounds. Used to exclude edges along window/screen edges.
  */
-ScrEdge *screen_geom_area_map_find_active_scredge(
-        const ScrAreaMap *area_map,
-        const rcti *bounds_rect,
-        const int mx, const int my)
+ScrEdge *screen_geom_area_map_find_active_scredge(const ScrAreaMap *area_map,
+                                                  const rcti *bounds_rect,
+                                                  const int mx,
+                                                  const int my)
 {
-	int safety = U.widget_unit / 10;
-
-	CLAMP_MIN(safety, 2);
-
-	for (ScrEdge *se = area_map->edgebase.first; se; se = se->next) {
-		if (screen_geom_edge_is_horizontal(se)) {
-			if ((se->v1->vec.y > bounds_rect->ymin) && (se->v1->vec.y < (bounds_rect->ymax - 1))) {
-				short min, max;
-				min = MIN2(se->v1->vec.x, se->v2->vec.x);
-				max = MAX2(se->v1->vec.x, se->v2->vec.x);
-
-				if (abs(my - se->v1->vec.y) <= safety && mx >= min && mx <= max)
-					return se;
-			}
-		}
-		else {
-			if ((se->v1->vec.x > bounds_rect->xmin) && (se->v1->vec.x < (bounds_rect->xmax - 1))) {
-				short min, max;
-				min = MIN2(se->v1->vec.y, se->v2->vec.y);
-				max = MAX2(se->v1->vec.y, se->v2->vec.y);
-
-				if (abs(mx - se->v1->vec.x) <= safety && my >= min && my <= max)
-					return se;
-			}
-		}
-	}
-
-	return NULL;
+  int safety = U.widget_unit / 10;
+
+  CLAMP_MIN(safety, 2);
+
+  for (ScrEdge *se = area_map->edgebase.first; se; se = se->next) {
+    if (screen_geom_edge_is_horizontal(se)) {
+      if ((se->v1->vec.y > bounds_rect->ymin) && (se->v1->vec.y < (bounds_rect->ymax - 1))) {
+        short min, max;
+        min = MIN2(se->v1->vec.x, se->v2->vec.x);
+        max = MAX2(se->v1->vec.x, se->v2->vec.x);
+
+        if (abs(my - se->v1->vec.y) <= safety && mx >= min && mx <= max)
+          return se;
+      }
+    }
+    else {
+      if ((se->v1->vec.x > bounds_rect->xmin) && (se->v1->vec.x < (bounds_rect->xmax - 1))) {
+        short min, max;
+        min = MIN2(se->v1->vec.y, se->v2->vec.y);
+        max = MAX2(se->v1->vec.y, se->v2->vec.y);
+
+        if (abs(mx - se->v1->vec.x) <= safety && my >= min && my <= max)
+          return se;
+      }
+    }
+  }
+
+  return NULL;
 }
 
 /* need win size to make sure not to include edges along screen edge */
-ScrEdge *screen_geom_find_active_scredge(
-        const wmWindow *win, const bScreen *screen,
-        const int mx, const int my)
+ScrEdge *screen_geom_find_active_scredge(const wmWindow *win,
+                                         const bScreen *screen,
+                                         const int mx,
+                                         const int my)
 {
-	/* Use layout size (screen excluding global areas) for screen-layout area edges */
-	rcti screen_rect;
-	ScrEdge *se;
-
-	WM_window_screen_rect_calc(win, &screen_rect);
-	se = screen_geom_area_map_find_active_scredge(AREAMAP_FROM_SCREEN(screen), &screen_rect, mx, my);
-
-	if (!se) {
-		/* Use entire window size (screen including global areas) for global area edges */
-		rcti win_rect;
-		WM_window_rect_calc(win, &win_rect);
-		se = screen_geom_area_map_find_active_scredge(&win->global_areas, &win_rect, mx, my);
-	}
-	return se;
+  /* Use layout size (screen excluding global areas) for screen-layout area edges */
+  rcti screen_rect;
+  ScrEdge *se;
+
+  WM_window_screen_rect_calc(win, &screen_rect);
+  se = screen_geom_area_map_find_active_scredge(AREAMAP_FROM_SCREEN(screen), &screen_rect, mx, my);
+
+  if (!se) {
+    /* Use entire window size (screen including global areas) for global area edges */
+    rcti win_rect;
+    WM_window_rect_calc(win, &win_rect);
+    se = screen_geom_area_map_find_active_scredge(&win->global_areas, &win_rect, mx, my);
+  }
+  return se;
 }
 
 /**
@@ -152,262 +152,261 @@ ScrEdge *screen_geom_find_active_scredge(
  */
 void screen_geom_vertices_scale(const wmWindow *win, bScreen *sc)
 {
-	/* clamp Y size of header sized areas when expanding windows
-	 * avoids annoying empty space around file menu */
+  /* clamp Y size of header sized areas when expanding windows
+   * avoids annoying empty space around file menu */
 #define USE_HEADER_SIZE_CLAMP
 
-	rcti window_rect, screen_rect;
-
-	WM_window_rect_calc(win, &window_rect);
-	WM_window_screen_rect_calc(win, &screen_rect);
+  rcti window_rect, screen_rect;
 
-	const int headery_init = ED_area_headersize();
-	const int screen_size_x = BLI_rcti_size_x(&screen_rect);
-	const int screen_size_y = BLI_rcti_size_y(&screen_rect);
-	ScrVert *sv = NULL;
-	ScrArea *sa;
-	int screen_size_x_prev, screen_size_y_prev;
-	float min[2], max[2];
+  WM_window_rect_calc(win, &window_rect);
+  WM_window_screen_rect_calc(win, &screen_rect);
 
-	/* calculate size */
-	min[0] = min[1] = 20000.0f;
-	max[0] = max[1] = 0.0f;
+  const int headery_init = ED_area_headersize();
+  const int screen_size_x = BLI_rcti_size_x(&screen_rect);
+  const int screen_size_y = BLI_rcti_size_y(&screen_rect);
+  ScrVert *sv = NULL;
+  ScrArea *sa;
+  int screen_size_x_prev, screen_size_y_prev;
+  float min[2], max[2];
 
-	for (sv = sc->vertbase.first; sv; sv = sv->next) {
-		const float fv[2] = {(float)sv->vec.x, (float)sv->vec.y};
-		minmax_v2v2_v2(min, max, fv);
-	}
+  /* calculate size */
+  min[0] = min[1] = 20000.0f;
+  max[0] = max[1] = 0.0f;
 
-	screen_size_x_prev = (max[0] - min[0]) + 1;
-	screen_size_y_prev = (max[1] - min[1]) + 1;
+  for (sv = sc->vertbase.first; sv; sv = sv->next) {
+    const float fv[2] = {(float)sv->vec.x, (float)sv->vec.y};
+    minmax_v2v2_v2(min, max, fv);
+  }
 
+  screen_size_x_prev = (max[0] - min[0]) + 1;
+  screen_size_y_prev = (max[1] - min[1]) + 1;
 
 #ifdef USE_HEADER_SIZE_CLAMP
-#define TEMP_BOTTOM 1
-#define TEMP_TOP 2
-
-	/* if the window's Y axis grows, clamp header sized areas */
-	if (screen_size_y_prev < screen_size_y) {  /* growing? */
-		const int headery_margin_max = headery_init + 5;
-		for (sa = sc->areabase.first; sa; sa = sa->next) {
-			ARegion *ar = BKE_area_find_region_type(sa, RGN_TYPE_HEADER);
-			sa->temp = 0;
-
-			if (ar && !(ar->flag & RGN_FLAG_HIDDEN)) {
-				if (sa->v2->vec.y == max[1]) {
-					if (screen_geom_area_height(sa) < headery_margin_max) {
-						sa->temp = TEMP_TOP;
-					}
-				}
-				else if (sa->v1->vec.y == min[1]) {
-					if (screen_geom_area_height(sa) < headery_margin_max) {
-						sa->temp = TEMP_BOTTOM;
-					}
-				}
-			}
-		}
-	}
+#  define TEMP_BOTTOM 1
+#  define TEMP_TOP 2
+
+  /* if the window's Y axis grows, clamp header sized areas */
+  if (screen_size_y_prev < screen_size_y) { /* growing? */
+    const int headery_margin_max = headery_init + 5;
+    for (sa = sc->areabase.first; sa; sa = sa->next) {
+      ARegion *ar = BKE_area_find_region_type(sa, RGN_TYPE_HEADER);
+      sa->temp = 0;
+
+      if (ar && !(ar->flag & RGN_FLAG_HIDDEN)) {
+        if (sa->v2->vec.y == max[1]) {
+          if (screen_geom_area_height(sa) < headery_margin_max) {
+            sa->temp = TEMP_TOP;
+          }
+        }
+        else if (sa->v1->vec.y == min[1]) {
+          if (screen_geom_area_height(sa) < headery_margin_max) {
+            sa->temp = TEMP_BOTTOM;
+          }
+        }
+      }
+    }
+  }
 #endif
 
+  if (screen_size_x_prev != screen_size_x || screen_size_y_prev != screen_size_y) {
+    const float facx = ((float)screen_size_x - 1) / ((float)screen_size_x_prev - 1);
+    const float facy = ((float)screen_size_y - 1) / ((float)screen_size_y_prev - 1);
 
-	if (screen_size_x_prev != screen_size_x || screen_size_y_prev != screen_size_y) {
-		const float facx = ((float)screen_size_x - 1) / ((float)screen_size_x_prev - 1);
-		const float facy = ((float)screen_size_y - 1) / ((float)screen_size_y_prev - 1);
-
-		/* make sure it fits! */
-		for (sv = sc->vertbase.first; sv; sv = sv->next) {
-			sv->vec.x = screen_rect.xmin + round_fl_to_short((sv->vec.x - min[0]) * facx);
-			CLAMP(sv->vec.x, screen_rect.xmin, screen_rect.xmax - 1);
-
-			sv->vec.y = screen_rect.ymin + round_fl_to_short((sv->vec.y - min[1]) * facy);
-			CLAMP(sv->vec.y, screen_rect.ymin, screen_rect.ymax - 1);
-		}
-	}
+    /* make sure it fits! */
+    for (sv = sc->vertbase.first; sv; sv = sv->next) {
+      sv->vec.x = screen_rect.xmin + round_fl_to_short((sv->vec.x - min[0]) * facx);
+      CLAMP(sv->vec.x, screen_rect.xmin, screen_rect.xmax - 1);
 
+      sv->vec.y = screen_rect.ymin + round_fl_to_short((sv->vec.y - min[1]) * facy);
+      CLAMP(sv->vec.y, screen_rect.ymin, screen_rect.ymax - 1);
+    }
+  }
 
 #ifdef USE_HEADER_SIZE_CLAMP
-	if (screen_size_y_prev < screen_size_y) {  /* growing? */
-		for (sa = sc->areabase.first; sa; sa = sa->next) {
-			ScrEdge *se = NULL;
-
-			if (sa->temp == 0)
-				continue;
-
-			if (sa->v1 == sa->v2)
-				continue;
-
-			/* adjust headery if verts are along the edge of window */
-			if (sa->temp == TEMP_TOP) {
-				/* lower edge */
-				const int yval = sa->v2->vec.y - headery_init;
-				se = BKE_screen_find_edge(sc, sa->v4, sa->v1);
-				if (se != NULL) {
-					screen_geom_select_connected_edge(win, se);
-				}
-				for (sv = sc->vertbase.first; sv; sv = sv->next) {
-					if (sv != sa->v2 && sv != sa->v3) {
-						if (sv->flag) {
-							sv->vec.y = yval;
-						}
-					}
-				}
-			}
-			else {
-				/* upper edge */
-				const int yval = sa->v1->vec.y + headery_init;
-				se = BKE_screen_find_edge(sc, sa->v2, sa->v3);
-				if (se != NULL) {
-					screen_geom_select_connected_edge(win, se);
-				}
-				for (sv = sc->vertbase.first; sv; sv = sv->next) {
-					if (sv != sa->v1 && sv != sa->v4) {
-						if (sv->flag) {
-							sv->vec.y = yval;
-						}
-					}
-				}
-			}
-		}
-	}
-
-#undef USE_HEADER_SIZE_CLAMP
-#undef TEMP_BOTTOM
-#undef TEMP_TOP
+  if (screen_size_y_prev < screen_size_y) { /* growing? */
+    for (sa = sc->areabase.first; sa; sa = sa->next) {
+      ScrEdge *se = NULL;
+
+      if (sa->temp == 0)
+        continue;
+
+      if (sa->v1 == sa->v2)
+        continue;
+
+      /* adjust headery if verts are along the edge of window */
+      if (sa->temp == TEMP_TOP) {
+        /* lower edge */
+        const int yval = sa->v2->vec.y - headery_init;
+        se = BKE_screen_find_edge(sc, sa->v4, sa->v1);
+        if (se != NULL) {
+          screen_geom_select_connected_edge(win, se);
+        }
+        for (sv = sc->vertbase.first; sv; sv = sv->next) {
+          if (sv != sa->v2 && sv != sa->v3) {
+            if (sv->flag) {
+              sv->vec.y = yval;
+            }
+          }
+        }
+      }
+      else {
+        /* upper edge */
+        const int yval = sa->v1->vec.y + headery_init;
+        se = BKE_screen_find_edge(sc, sa->v2, sa->v3);
+        if (se != NULL) {
+          screen_geom_select_connected_edge(win, se);
+        }
+        for (sv = sc->vertbase.first; sv; sv = sv->next) {
+          if (sv != sa->v1 && sv != sa->v4) {
+            if (sv->flag) {
+              sv->vec.y = yval;
+            }
+          }
+        }
+      }
+    }
+  }
+
+#  undef USE_HEADER_SIZE_CLAMP
+#  undef TEMP_BOTTOM
+#  undef TEMP_TOP
 #endif
 
-
-	/* test for collapsed areas. This could happen in some blender version... */
-	/* ton: removed option now, it needs Context... */
-
-	/* make each window at least ED_area_headersize() high */
-	for (sa = sc->areabase.first; sa; sa = sa->next) {
-		int headery = headery_init;
-
-		/* adjust headery if verts are along the edge of window */
-		if (sa->v1->vec.y > window_rect.ymin)
-			headery += U.pixelsize;
-		if (sa->v2->vec.y < (window_rect.ymax - 1))
-			headery += U.pixelsize;
-
-		if (screen_geom_area_height(sa) < headery) {
-			/* lower edge */
-			ScrEdge *se = BKE_screen_find_edge(sc, sa->v4, sa->v1);
-			if (se && sa->v1 != sa->v2) {
-				const int yval = sa->v2->vec.y - headery + 1;
-
-				screen_geom_select_connected_edge(win, se);
-
-				/* all selected vertices get the right offset */
-				for (sv = sc->vertbase.first; sv; sv = sv->next) {
-					/* if is a collapsed area */
-					if (sv != sa->v2 && sv != sa->v3) {
-						if (sv->flag) {
-							sv->vec.y = yval;
-						}
-					}
-				}
-			}
-		}
-	}
-
-	/* Global areas have a fixed size that only changes with the DPI. Here we ensure that exactly this size is set. */
-	for (ScrArea *area = win->global_areas.areabase.first; area; area = area->next) {
-		if (area->global->flag & GLOBAL_AREA_IS_HIDDEN) {
-			continue;
-		}
-
-		int height = ED_area_global_size_y(area) - 1;
-
-		if (area->v1->vec.y > window_rect.ymin) {
-			height += U.pixelsize;
-		}
-		if (area->v2->vec.y < (window_rect.ymax - 1)) {
-			height += U.pixelsize;
-		}
-
-		/* width */
-		area->v1->vec.x = area->v2->vec.x = window_rect.xmin;
-		area->v3->vec.x = area->v4->vec.x = window_rect.xmax - 1;
-		/* height */
-		area->v1->vec.y = area->v4->vec.y = window_rect.ymin;
-		area->v2->vec.y = area->v3->vec.y = window_rect.ymax - 1;
-
-		switch (area->global->align) {
-			case GLOBAL_AREA_ALIGN_TOP:
-				area->v1->vec.y = area->v4->vec.y = area->v2->vec.y - height;
-				break;
-			case GLOBAL_AREA_ALIGN_BOTTOM:
-				area->v2->vec.y = area->v3->vec.y = area->v1->vec.y + height;
-				break;
-		}
-	}
+  /* test for collapsed areas. This could happen in some blender version... */
+  /* ton: removed option now, it needs Context... */
+
+  /* make each window at least ED_area_headersize() high */
+  for (sa = sc->areabase.first; sa; sa = sa->next) {
+    int headery = headery_init;
+
+    /* adjust headery if verts are along the edge of window */
+    if (sa->v1->vec.y > window_rect.ymin)
+      headery += U.pixelsize;
+    if (sa->v2->vec.y < (window_rect.ymax - 1))
+      headery += U.pixelsize;
+
+    if (screen_geom_area_height(sa) < headery) {
+      /* lower edge */
+      ScrEdge *se = BKE_screen_find_edge(sc, sa->v4, sa->v1);
+      if (se && sa->v1 != sa->v2) {
+        const int yval = sa->v2->vec.y - headery + 1;
+
+        screen_geom_select_connected_edge(win, se);
+
+        /* all selected vertices get the right offset */
+        for (sv = sc->vertbase.first; sv; sv = sv->next) {
+          /* if is a collapsed area */
+          if (sv != sa->v2 && sv != sa->v3) {
+            if (sv->flag) {
+              sv->vec.y = yval;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  /* Global areas have a fixed size that only changes with the DPI. Here we ensure that exactly this size is set. */
+  for (ScrArea *area = win->global_areas.areabase.first; area; area = area->next) {
+    if (area->global->flag & GLOBAL_AREA_IS_HIDDEN) {
+      continue;
+    }
+
+    int height = ED_area_global_size_y(area) - 1;
+
+    if (area->v1->vec.y > window_rect.ymin) {
+      height += U.pixelsize;
+    }
+    if (area->v2->vec.y < (window_rect.ymax - 1)) {
+      height += U.pixelsize;
+    }
+
+    /* width */
+    area->v1->vec.x = area->v2->vec.x = window_rect.xmin;
+    area->v3->vec.x = area->v4->vec.x = window_rect.xmax - 1;
+    /* height */
+    area->v1->vec.y = area->v4->vec.y = window_rect.ymin;
+    area->v2->vec.y = area->v3->vec.y = window_rect.ymax - 1;
+
+    switch (area->global->align) {
+      case GLOBAL_AREA_ALIGN_TOP:
+        area->v1->vec.y = area->v4->vec.y = area->v2->vec.y - height;
+        break;
+      case GLOBAL_AREA_ALIGN_BOTTOM:
+        area->v2->vec.y = area->v3->vec.y = area->v1->vec.y + height;
+        break;
+    }
+  }
 }
 
 /**
  * \return 0 if no split is possible, otherwise the screen-coordinate at which to split.
  */
-short screen_geom_find_area_split_point(const ScrArea *sa, const rcti *window_rect, char dir, float fac)
+short screen_geom_find_area_split_point(const ScrArea *sa,
+                                        const rcti *window_rect,
+                                        char dir,
+                                        float fac)
 {
-	short x, y;
-	const int cur_area_width = screen_geom_area_width(sa);
-	const int cur_area_height = screen_geom_area_height(sa);
-	const short area_min_x = AREAMINX;
-	const short area_min_y = ED_area_headersize();
-	int area_min;
-
-	// area big enough?
-	if ((dir == 'v') && (cur_area_width <= 2 * area_min_x)) {
-		return 0;
-	}
-	if ((dir == 'h') && (cur_area_height <= 2 * area_min_y)) {
-		return 0;
-	}
-
-	// to be sure
-	CLAMP(fac, 0.0f, 1.0f);
-
-	if (dir == 'h') {
-		y = sa->v1->vec.y + round_fl_to_short(fac * cur_area_height);
-
-		area_min = area_min_y;
-
-		if (sa->v1->vec.y > window_rect->ymin) {
-			area_min += U.pixelsize;
-		}
-		if (sa->v2->vec.y < (window_rect->ymax - 1)) {
-			area_min += U.pixelsize;
-		}
-
-		if (y - sa->v1->vec.y < area_min) {
-			y = sa->v1->vec.y + area_min;
-		}
-		else if (sa->v2->vec.y - y < area_min) {
-			y = sa->v2->vec.y - area_min;
-		}
-
-		return y;
-	}
-	else {
-		x = sa->v1->vec.x + round_fl_to_short(fac * cur_area_width);
-
-		area_min = area_min_x;
-
-		if (sa->v1->vec.x > window_rect->xmin) {
-			area_min += U.pixelsize;
-		}
-		if (sa->v4->vec.x < (window_rect->xmax - 1)) {
-			area_min += U.pixelsize;
-		}
-
-		if (x - sa->v1->vec.x < area_min) {
-			x = sa->v1->vec.x + area_min;
-		}
-		else if (sa->v4->vec.x - x < area_min) {
-			x = sa->v4->vec.x - area_min;
-		}
-
-		return x;
-	}
+  short x, y;
+  const int cur_area_width = screen_geom_area_width(sa);
+  const int cur_area_height = screen_geom_area_height(sa);
+  const short area_min_x = AREAMINX;
+  const short area_min_y = ED_area_headersize();
+  int area_min;
+
+  // area big enough?
+  if ((dir == 'v') && (cur_area_width <= 2 * area_min_x)) {
+    return 0;
+  }
+  if ((dir == 'h') && (cur_area_height <= 2 * area_min_y)) {
+    return 0;
+  }
+
+  // to be sure
+  CLAMP(fac, 0.0f, 1.0f);
+
+  if (dir == 'h') {
+    y = sa->v1->vec.y + round_fl_to_short(fac * cur_area_height);
+
+    area_min = area_min_y;
+
+    if (sa->v1->vec.y > window_rect->ymin) {
+      area_min += U.pixelsize;
+    }
+    if (sa->v2->vec.y < (window_rect->ymax - 1)) {
+      area_min += U.pixelsize;
+    }
+
+    if (y - sa->v1->vec.y < area_min) {
+      y = sa->v1->vec.y + area_min;
+    }
+    else if (sa->v2->vec.y - y < area_min) {
+      y = sa->v2->vec.y - area_min;
+    }
+
+    return y;
+  }
+  else {
+    x = sa->v1->vec.x + round_fl_to_short(fac * cur_area_width);
+
+    area_min = area_min_x;
+
+    if (sa->v1->vec.x > window_rect->xmin) {
+      area_min += U.pixelsize;
+    }
+    if (sa->v4->vec.x < (window_rect->xmax - 1)) {
+      area_min += U.pixelsize;
+    }
+
+    if (x - sa->v1->vec.x < area_min) {
+      x = sa->v1->vec.x + area_min;
+    }
+    else if (sa->v4->vec.x - x < area_min) {
+      x = sa->v4->vec.x - area_min;
+    }
+
+    return x;
+  }
 }
 
 /**
@@ -415,44 +414,45 @@ short screen_geom_find_area_split_point(const ScrArea *sa, const rcti *window_re
  */
 void screen_geom_select_connected_edge(const wmWindow *win, ScrEdge *edge)
 {
-	bScreen *sc = WM_window_get_active_screen(win);
-	bool oneselected = true;
-	char dir;
-
-	/* select connected, only in the right direction */
-	/* 'dir' is the direction of EDGE */
-
-	if (edge->v1->vec.x == edge->v2->vec.x) {
-		dir = 'v';
-	}
-	else {
-		dir = 'h';
-	}
-
-	ED_screen_verts_iter(win, sc, sv) {
-		sv->flag = 0;
-	}
-
-	edge->v1->flag = 1;
-	edge->v2->flag = 1;
-
-	while (oneselected) {
-		oneselected = false;
-		for (ScrEdge *se = sc->edgebase.first; se; se = se->next) {
-			if (se->v1->flag + se->v2->flag == 1) {
-				if (dir == 'h') {
-					if (se->v1->vec.y == se->v2->vec.y) {
-						se->v1->flag = se->v2->flag = 1;
-						oneselected = true;
-					}
-				}
-				if (dir == 'v') {
-					if (se->v1->vec.x == se->v2->vec.x) {
-						se->v1->flag = se->v2->flag = 1;
-						oneselected = true;
-					}
-				}
-			}
-		}
-	}
+  bScreen *sc = WM_window_get_active_screen(win);
+  bool oneselected = true;
+  char dir;
+
+  /* select connected, only in the right direction */
+  /* 'dir' is the direction of EDGE */
+
+  if (edge->v1->vec.x == edge->v2->vec.x) {
+    dir = 'v';
+  }
+  else {
+    dir = 'h';
+  }
+
+  ED_screen_verts_iter(win, sc, sv)
+  {
+    sv->flag = 0;
+  }
+
+  edge->v1->flag = 1;
+  edge->v2->flag = 1;
+
+  while (oneselected) {
+    oneselected = false;
+    for (ScrEdge *se = sc->edgebase.first; se; se = se->next) {
+      if (se->v1->flag + se->v2->flag == 1) {
+        if (dir == 'h') {
+          if (se->v1->vec.y == se->v2->vec.y) {
+            se->v1->flag = se->v2->flag = 1;
+            oneselected = true;
+          }
+        }
+        if (dir == 'v') {
+          if (se->v1->vec.x == se->v2->vec.x) {
+            se->v1->flag = se->v2->flag = 1;
+            oneselected = true;
+          }
+        }
+      }
+    }
+  }
 }