Index: source/blender/editors/screen/area.c
===================================================================
--- source/blender/editors/screen/area.c (revision 56461)
+++ source/blender/editors/screen/area.c (working copy)
@@ -863,10 +863,10 @@ static void region_azone_add(ScrArea *sa, ARegion *ar, int alignment)
 static int rct_fits(rcti *rect, char dir, int size)
 {
 	if (dir == 'h') {
-		return BLI_rcti_size_x(rect) - size;
+		return BLI_rcti_size_x(rect) + 1 - size;
 	}
 	else {  /* 'v' */
-		return BLI_rcti_size_y(rect) - size;
+		return BLI_rcti_size_y(rect) + 1 - size;
 	}
 }
 
Index: source/blender/editors/screen/screen_edit.c
===================================================================
--- source/blender/editors/screen/screen_edit.c (revision 56461)
+++ source/blender/editors/screen/screen_edit.c (working copy)
@@ -264,7 +264,7 @@ int scredge_is_horizontal(ScrEdge *se)
 	return (se->v1->vec.y == se->v2->vec.y);
 }
 
-ScrEdge *screen_find_active_scredge(bScreen *sc, int mx, int my)
+ScrEdge *screen_find_active_scredge(bScreen *sc, int winsizex, int winsizey, int mx, int my)
 {
 	ScrEdge *se;
 	int safety = U.widget_unit / 10;
@@ -272,7 +272,7 @@ ScrEdge *screen_find_active_scredge(bScreen *sc, int mx, int my)
 	if (safety < 2) safety = 2;
 	
 	for (se = sc->edgebase.first; se; se = se->next) {
-		if (scredge_is_horizontal(se)) {
+		if (scredge_is_horizontal(se) && se->v1->vec.y < winsizey - 1 && se->v1->vec.y > 0) {
 			short min, max;
 			min = MIN2(se->v1->vec.x, se->v2->vec.x);
 			max = MAX2(se->v1->vec.x, se->v2->vec.x);
@@ -280,7 +280,7 @@ ScrEdge *screen_find_active_scredge(bScreen *sc, int mx, int my)
 			if (abs(my - se->v1->vec.y) <= safety && mx >= min && mx <= max)
 				return se;
 		}
-		else {
+		else if (se->v1->vec.x < winsizex - 1 && se->v1->vec.x > 0) {
 			short min, max;
 			min = MIN2(se->v1->vec.y, se->v2->vec.y);
 			max = MAX2(se->v1->vec.y, se->v2->vec.y);
@@ -649,8 +649,8 @@ static void screen_test_scale(bScreen *sc, int winsizex, int winsizey)
 		sv->vec.y -= min[1];
 	}
 	
-	sizex = max[0] - min[0];
-	sizey = max[1] - min[1];
+	sizex = max[0] - min[0] + 1;
+	sizey = max[1] - min[1] + 1;
 	
 	if (sizex != winsizex || sizey != winsizey) {
 		facx = winsizex;
@@ -667,14 +667,14 @@ static void screen_test_scale(bScreen *sc, int winsizex, int winsizey)
 			sv->vec.x += AREAGRID - 1;
 			sv->vec.x -=  (sv->vec.x % AREAGRID);
 
-			CLAMP(sv->vec.x, 0, winsizex);
+			CLAMP(sv->vec.x, 0, winsizex - 1);
 			
 			tempf = ((float)sv->vec.y) * facy;
 			sv->vec.y = (short)(tempf + 0.5f);
 			sv->vec.y += AREAGRID - 1;
 			sv->vec.y -=  (sv->vec.y % AREAGRID);
 
-			CLAMP(sv->vec.y, 0, winsizey);
+			CLAMP(sv->vec.y, 0, winsizey - 1);
 		}
 	}
 	
@@ -683,9 +683,15 @@ static void screen_test_scale(bScreen *sc, int winsizex, int winsizey)
 	
 	/* make each window at least ED_area_headersize() high */
 	for (sa = sc->areabase.first; sa; sa = sa->next) {
-		int headery = ED_area_headersize() + U.pixelsize;
+		int headeryoffset = ED_area_headersize() - U.pixelsize;
 		
-		if (sa->v1->vec.y + headery > sa->v2->vec.y) {
+		/* adjust headeryoffset if verts along the edge of window */
+		if (sa->v1->vec.y > 0)
+			headeryoffset++;
+		if (sa->v2->vec.y < winsizey - 1)
+			headeryoffset++;
+		
+		if (sa->v1->vec.y + headeryoffset > sa->v2->vec.y) {
 			/* lower edge */
 			ScrEdge *se = screen_findedge(sc, sa->v4, sa->v1);
 			if (se && sa->v1 != sa->v2) {
@@ -694,7 +700,7 @@ static void screen_test_scale(bScreen *sc, int winsizex, int winsizey)
 				select_connected_scredge(sc, se);
 				
 				/* all selected vertices get the right offset */
-				yval = sa->v2->vec.y - headery;
+				yval = sa->v2->vec.y - headeryoffset;
 				sv = sc->vertbase.first;
 				while (sv) {
 					/* if is a collapsed area */
@@ -1237,7 +1243,7 @@ static void screen_cursor_set(wmWindow *win, wmEvent *event)
 		}
 	}
 	else {
-		ScrEdge *actedge = screen_find_active_scredge(win->screen, event->x, event->y);
+		ScrEdge *actedge = screen_find_active_scredge(win->screen, WM_window_pixels_x(win), WM_window_pixels_y(win), event->x, event->y);
 		
 		if (actedge) {
 			if (scredge_is_horizontal(actedge))
Index: source/blender/editors/screen/screen_intern.h
===================================================================
--- source/blender/editors/screen/screen_intern.h (revision 56461)
+++ source/blender/editors/screen/screen_intern.h (working copy)
@@ -53,7 +53,7 @@ void        removedouble_scrverts(bScreen *sc);
 void        removedouble_scredges(bScreen *sc);
 void        removenotused_scredges(bScreen *sc);
 int         scredge_is_horizontal(ScrEdge *se);
-ScrEdge    *screen_find_active_scredge(bScreen *sc, int mx, int my);
+ScrEdge    *screen_find_active_scredge(bScreen *sc, int winsizex, int winsizey, int mx, int my);
 
 struct AZone *is_in_area_actionzone(ScrArea *sa, const int xy[2]);
 
Index: source/blender/editors/screen/screen_ops.c
===================================================================
--- source/blender/editors/screen/screen_ops.c (revision 56461)
+++ source/blender/editors/screen/screen_ops.c (working copy)
@@ -975,18 +975,28 @@ typedef struct sAreaMoveData {
 	char dir;
 } sAreaMoveData;
 
-/* helper call to move area-edge, sets limits */
-static void area_move_set_limits(bScreen *sc, int dir, int *bigger, int *smaller)
+/* helper call to move area-edge, sets limits
+ * need window size to make adjustments for verts at window edge */
+static void area_move_set_limits(bScreen *sc, int dir, int winsizex, int winsizey, int *bigger, int *smaller)
 {
 	ScrArea *sa;
-	int areaminy = ED_area_headersize() + U.pixelsize;	// pixelsize is used as area divider
+	int areaminy = ED_area_headersize();
+	int areamin;
 	
 	/* we check all areas and test for free space with MINSIZE */
 	*bigger = *smaller = 100000;
 	
 	for (sa = sc->areabase.first; sa; sa = sa->next) {
-		if (dir == 'h') {
-			int y1 = sa->v2->vec.y - sa->v1->vec.y - areaminy;
+		if (dir == 'h') {			
+			int y1;
+			areamin = areaminy - U.pixelsize;
+			
+			if (sa->v1->vec.y > 0)
+				areamin += U.pixelsize;
+			if (sa->v2->vec.y < winsizey - 1)
+				areamin += U.pixelsize;
+			
+			y1 = sa->v2->vec.y - sa->v1->vec.y - areamin;
 			
 			/* if top or down edge selected, test height */
 			if (sa->v1->editflag && sa->v4->editflag)
@@ -994,9 +1004,17 @@ static void area_move_set_limits(bScreen *sc, int dir, int *bigger, int *smaller
 			else if (sa->v2->editflag && sa->v3->editflag)
 				*smaller = min_ii(*smaller, y1);
 		}
-		else {
-			int x1 = sa->v4->vec.x - sa->v1->vec.x - AREAMINX;
+		else {	
+			int x1;
+			areamin = AREAMINX - U.pixelsize;
 			
+			if (sa->v1->vec.y > 0)
+				areamin += U.pixelsize;
+			if (sa->v2->vec.y < winsizex-1)
+				areamin += U.pixelsize;
+
+			x1= sa->v4->vec.x - sa->v1->vec.x-areamin;
+
 			/* if left or right edge selected, test width */
 			if (sa->v1->editflag && sa->v2->editflag)
 				*bigger = min_ii(*bigger, x1);
@@ -1011,6 +1029,7 @@ static void area_move_set_limits(bScreen *sc, int dir, int *bigger, int *smaller
 static int area_move_init(bContext *C, wmOperator *op)
 {
 	bScreen *sc = CTX_wm_screen(C);
+	wmWindow *win = CTX_wm_window(C);
 	ScrEdge *actedge;
 	sAreaMoveData *md;
 	ScrVert *v1;
@@ -1021,7 +1040,7 @@ static int area_move_init(bContext *C, wmOperator *op)
 	y = RNA_int_get(op->ptr, "y");
 	
 	/* setup */
-	actedge = screen_find_active_scredge(sc, x, y);
+	actedge = screen_find_active_scredge(sc, win->sizex, win->sizey, x, y);
 	if (actedge == NULL) return 0;
 	
 	md = MEM_callocN(sizeof(sAreaMoveData), "sAreaMoveData");
@@ -1036,7 +1055,7 @@ static int area_move_init(bContext *C, wmOperator *op)
 	for (v1 = sc->vertbase.first; v1; v1 = v1->next)
 		v1->editflag = v1->flag;
 	
-	area_move_set_limits(sc, md->dir, &md->bigger, &md->smaller);
+	area_move_set_limits(sc, md->dir, WM_window_pixels_x(win), WM_window_pixels_y(win), &md->bigger, &md->smaller);
 	
 	return 1;
 }
@@ -1048,7 +1067,8 @@ static void area_move_apply_do(bContext *C, int origval, int delta, int dir, int
 	bScreen *sc = CTX_wm_screen(C);
 	ScrVert *v1;
 	ScrArea *sa;
-	int areaminy = ED_area_headersize() + 1;
+	int doredraw = 0;
+	int oldval;
 	
 	delta = CLAMPIS(delta, -smaller, bigger);
 	
@@ -1056,28 +1076,38 @@ static void area_move_apply_do(bContext *C, int origval, int delta, int dir, int
 		if (v1->editflag) {
 			/* that way a nice AREAGRID  */
 			if ((dir == 'v') && v1->vec.x > 0 && v1->vec.x < WM_window_pixels_x(win) - 1) {
+				oldval = v1->vec.x;
 				v1->vec.x = origval + delta;
-				if (delta != bigger && delta != -smaller) v1->vec.x -= (v1->vec.x % AREAGRID);
+				
+				if (delta != bigger && delta != -smaller) {
+					v1->vec.x -= (v1->vec.x % AREAGRID);
+					v1->vec.x = CLAMPIS(v1->vec.x, origval - smaller, origval + bigger);
+				}
+				if (oldval != v1->vec.x)
+					doredraw = 1;
 			}
 			if ((dir == 'h') && v1->vec.y > 0 && v1->vec.y < WM_window_pixels_y(win) - 1) {
+				oldval = v1->vec.y;
 				v1->vec.y = origval + delta;
 				
-				v1->vec.y += AREAGRID - 1;
-				v1->vec.y -= (v1->vec.y % AREAGRID);
-				
-				/* prevent too small top header */
-				if (v1->vec.y > WM_window_pixels_y(win) - areaminy)
-					v1->vec.y = WM_window_pixels_y(win) - areaminy;
+				if (delta != bigger && delta != -smaller) {
+					v1->vec.y -= (v1->vec.y % AREAGRID);
+					v1->vec.y = CLAMPIS(v1->vec.y, origval - smaller, origval + bigger);
+				}
+				if (oldval != v1->vec.y)
+					doredraw = 1;
 			}
 		}
 	}
 
-	for (sa = sc->areabase.first; sa; sa = sa->next) {
-		if (sa->v1->editflag || sa->v2->editflag || sa->v3->editflag || sa->v4->editflag)
-			ED_area_tag_redraw(sa);
-	}
+	if (doredraw) {
+		for (sa = sc->areabase.first; sa; sa = sa->next) {
+			if (sa->v1->editflag || sa->v2->editflag || sa->v3->editflag || sa->v4->editflag)
+				ED_area_tag_redraw(sa);
+		}
 
-	WM_event_add_notifier(C, NC_SCREEN | NA_EDITED, NULL); /* redraw everything */
+		WM_event_add_notifier(C, NC_SCREEN | NA_EDITED, NULL); /* redraw everything */
+	}
 }
 
 static void area_move_apply(bContext *C, wmOperator *op)
@@ -1396,6 +1426,7 @@ static void area_split_exit(bContext *C, wmOperator *op)
 /* UI callback, adds new handler */
 static int area_split_invoke(bContext *C, wmOperator *op, const wmEvent *event)
 {
+	wmWindow *win = CTX_wm_window(C);
 	sAreaSplitData *sd;
 	int dir;
 	
@@ -1449,7 +1480,7 @@ static int area_split_invoke(bContext *C, wmOperator *op, const wmEvent *event)
 		else
 			y = event->x;
 		
-		actedge = screen_find_active_scredge(CTX_wm_screen(C), x, y);
+		actedge = screen_find_active_scredge(CTX_wm_screen(C), WM_window_pixels_x(win), WM_window_pixels_y(win), x, y);
 		if (actedge == NULL)
 			return OPERATOR_CANCELLED;
 		
@@ -1472,7 +1503,7 @@ static int area_split_invoke(bContext *C, wmOperator *op, const wmEvent *event)
 		
 		/* do the split */
 		if (area_split_apply(C, op)) {
-			area_move_set_limits(CTX_wm_screen(C), dir, &sd->bigger, &sd->smaller);
+			area_move_set_limits(CTX_wm_screen(C), dir, WM_window_pixels_x(win), WM_window_pixels_y(win), &sd->bigger, &sd->smaller);
 			
 			/* add temp handler for edge move or cancel */
 			WM_event_add_modal_handler(C, op);
@@ -2504,10 +2535,11 @@ static void SCREEN_OT_area_join(wmOperatorType *ot)
 
 static int screen_area_options_invoke(bContext *C, wmOperator *op, const wmEvent *event)
 {
+	wmWindow *win = CTX_wm_window(C);
 	uiPopupMenu *pup;
 	uiLayout *layout;
 	PointerRNA ptr1, ptr2;
-	ScrEdge *actedge = screen_find_active_scredge(CTX_wm_screen(C), event->x, event->y);
+	ScrEdge *actedge = screen_find_active_scredge(CTX_wm_screen(C), WM_window_pixels_x(win), WM_window_pixels_y(win), event->x, event->y);
 	
 	if (actedge == NULL) return OPERATOR_CANCELLED;