View2D - Commented and finished off cleaning up code added so far

5 files changed, 282 insertions, 166 deletions

diff --git a/source/blender/editors/include/UI_view2d.h b/source/blender/editors/include/UI_view2d.h
index 7b5712b66de..1a37463aaab 100644
--- a/source/blender/editors/include/UI_view2d.h
+++ b/source/blender/editors/include/UI_view2d.h
@@ -21,29 +21,47 @@
  * All rights reserved.
  *
  * 
- * Contributor(s): Blender Foundation
+ * Contributor(s): Blender Foundation, Joshua Leung
  *
+ *
+ * Generic 2d view with should allow drawing grids,
+ * panning, zooming, scrolling, .. 
  * ***** END GPL LICENSE BLOCK *****
  */
 
 #ifndef UI_VIEW2D_H
 #define UI_VIEW2D_H
 
-/* start of a generic 2d view with should allow drawing grids,
- * panning, zooming, scrolling, .. */
+/* ------------------------------------------ */
+/* Settings: 								*/
 
+/* grid-units (for drawing time) */
 #define V2D_UNIT_SECONDS	0
 #define V2D_UNIT_FRAMES		1
 
+/* clamping of grid values to whole numbers */
 #define V2D_GRID_CLAMP		0
 #define V2D_GRID_NOCLAMP	1
 
+/* generic value to use when coordinate lies out of view when converting */
 #define V2D_IS_CLIPPED	12000
 
-#define V2D_HORIZONTAL_LINES	1
-#define V2D_VERTICAL_LINES		2
-#define V2D_HORIZONTAL_AXIS		4
-#define V2D_VERTICAL_AXIS		8
+/* flags for grid-lines to draw */
+#define V2D_HORIZONTAL_LINES	(1<<0)
+#define V2D_VERTICAL_LINES		(1<<1)
+#define V2D_HORIZONTAL_AXIS		(1<<2)
+#define V2D_VERTICAL_AXIS		(1<<3)
+
+/* ------------------------------------------ */
+/* Macros:								*/
+
+/* test if mouse in scrollbar */
+// XXX do we want more elegant method?
+#define IN_2D_VERT_SCROLL(v2d, co) (BLI_in_rcti(&v2d->vert, co[0], co[1]))
+#define IN_2D_HORIZ_SCROLL(v2d, co) (BLI_in_rcti(&v2d->hor, co[0], co[1]))
+
+/* ------------------------------------------ */
+/* Type definitions: 						*/
 
 struct View2D;
 struct View2DGrid;
@@ -51,15 +69,21 @@ struct bContext;
 
 typedef struct View2DGrid View2DGrid;
 
+/* ----------------------------------------- */
+/* Prototypes:						    */
+
 /* setup */
 void UI_view2d_ortho(const struct bContext *C, struct View2D *v2d);
 void UI_view2d_update_size(struct View2D *v2d, int winx, int winy);
 
 /* grid drawing */
-View2DGrid *UI_view2d_calc_grid(const struct bContext *C, struct View2D *v2d, int unit, int type, int winx, int winy);
+View2DGrid *UI_view2d_calc_grid(const struct bContext *C, struct View2D *v2d, short unit, short type, int winx, int winy);
 void UI_view2d_draw_grid(const struct bContext *C, struct View2D *v2d, View2DGrid *grid, int flag);
 void UI_view2d_free_grid(View2DGrid *grid);
 
+/* scrollbar drawing */
+
+
 /* coordinate conversion */
 void UI_view2d_region_to_view(struct View2D *v2d, short x, short y, float *viewx, float *viewy);
 void UI_view2d_view_to_region(struct View2D *v2d, float x, float y, short *regionx, short *regiony);
diff --git a/source/blender/editors/interface/view2d.c b/source/blender/editors/interface/view2d.c
index 322d88489bf..6d86f6dcb1a 100644
--- a/source/blender/editors/interface/view2d.c
+++ b/source/blender/editors/interface/view2d.c
@@ -1,3 +1,29 @@
+/**
+ * $Id$
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version. 
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2008 Blender Foundation.
+ * All rights reserved.
+ * 
+ * Contributor(s): Blender Foundation, Joshua Leung
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
 
 #include <math.h>
 
@@ -17,68 +43,50 @@
 #include "UI_resources.h"
 #include "UI_view2d.h"
 
-/* minimum pixels per gridstep */
-#define IPOSTEP 35
-
-struct View2DGrid {
-	float dx, dy, startx, starty;
-	int machtx, machty;
-};
-
-/* Setup */
+/* *********************************************************************** */
+/* Setup and Refresh Code */
 
+/* Set view matrices to ortho for View2D drawing */
 void UI_view2d_ortho(const bContext *C, View2D *v2d)
 {
 	wmOrtho2(C->window, v2d->cur.xmin, v2d->cur.xmax, v2d->cur.ymin, v2d->cur.ymax);
 }
 
+/* Adjust mask size in response to view size changes */
+// XXX pre2.5 -> this used to be called  calc_scrollrcts()
 void UI_view2d_update_size(View2D *v2d, int winx, int winy)
 {
+	/* mask - view frame */
 	v2d->mask.xmin= v2d->mask.ymin= 0;
 	v2d->mask.xmax= winx;
 	v2d->mask.ymax= winy;
 	
-#if 0
-	if(sa->spacetype==SPACE_ACTION) {
-		if(sa->winx > ACTWIDTH+50) { 
-			v2d->mask.xmin+= ACTWIDTH;
-			v2d->hor.xmin+=ACTWIDTH;
-		}
-	}
-	else if(sa->spacetype==SPACE_NLA){
-		if(sa->winx > NLAWIDTH+50) { 
-			v2d->mask.xmin+= NLAWIDTH;
-			v2d->hor.xmin+=NLAWIDTH;
-		}
-	}
-	else if(sa->spacetype==SPACE_IPO) {
-		int ipobutx = calc_ipobuttonswidth(sa);
-		
-		v2d->mask.xmax-= ipobutx;
-		
-		if(v2d->mask.xmax<ipobutx)
-			v2d->mask.xmax= winx;
-	}
-#endif
-	
+	/* scrollbars shrink mask area, but should be based off regionsize */
+	// XXX scrollbars should become limited to one bottom lower edges of region like everyone else does!
 	if(v2d->scroll) {
-		if(v2d->scroll & L_SCROLL) {
+		/* vertical scrollbar */
+		if (v2d->scroll & L_SCROLL) {
+			/* on left-hand edge of region */
 			v2d->vert= v2d->mask;
 			v2d->vert.xmax= SCROLLB;
 			v2d->mask.xmin= SCROLLB;
 		}
 		else if(v2d->scroll & R_SCROLL) {
+			/* on right-hand edge of region */
 			v2d->vert= v2d->mask;
 			v2d->vert.xmin= v2d->vert.xmax-SCROLLB;
 			v2d->mask.xmax= v2d->vert.xmin;
 		}
 		
-		if((v2d->scroll & B_SCROLL) || (v2d->scroll & B_SCROLLO)) {
+		/* horizontal scrollbar */
+		if ((v2d->scroll & B_SCROLL) || (v2d->scroll & B_SCROLLO)) {
+			/* on bottom edge of region (B_SCROLLO is outliner, the ohter is for standard) */
 			v2d->hor= v2d->mask;
 			v2d->hor.ymax= SCROLLH;
 			v2d->mask.ymin= SCROLLH;
 		}
 		else if(v2d->scroll & T_SCROLL) {
+			/* on upper edge of region */
 			v2d->hor= v2d->mask;
 			v2d->hor.ymin= v2d->hor.ymax-SCROLLH;
 			v2d->mask.ymax= v2d->hor.ymin;
@@ -86,58 +94,82 @@ void UI_view2d_update_size(View2D *v2d, int winx, int winy)
 	}
 }
 
-/* Grid */
+/* *********************************************************************** */
+/* Gridlines */
 
-static void step_to_grid(float *step, int *macht, int unit)
+/* minimum pixels per gridstep */
+#define MINGRIDSTEP 	35
+
+/* View2DGrid is typedef'd in UI_view2d.h */
+struct View2DGrid {
+	float dx, dy;			/* stepsize (in pixels) between gridlines */
+	float startx, starty;	/* */
+	int powerx, powery;		/* step as power of 10 */
+};
+
+/* --------------- */
+
+/* try to write step as a power of 10 */
+static void step_to_grid(float *step, int *power, int unit)
 {
-	float loga, rem;
+	const float loga= log10(*step);
+	float rem;
 	
-	/* try to write step as a power of 10 */
+	*power= (int)(loga);
 	
-	loga= log10(*step);
-	*macht= (int)(loga);
-
-	rem= loga- *macht;
+	rem= loga - (*power);
 	rem= pow(10.0, rem);
 	
-	if(loga<0.0) {
-		if(rem < 0.2) rem= 0.2;
-		else if(rem < 0.5) rem= 0.5;
-		else rem= 1.0;
-
-		*step= rem*pow(10.0, (float)*macht);
-
-		if(unit == V2D_UNIT_FRAMES) {
-			rem = 1.0;
-			*step = 1.0;
+	if (loga < 0.0f) {
+		if (rem < 0.2f) rem= 0.2f;
+		else if(rem < 0.5f) rem= 0.5f;
+		else rem= 1.0f;
+		
+		*step= rem * pow(10.0, (double)(*power));
+		
+		/* for frames, we want 1.0 frame intervals only */
+		if (unit == V2D_UNIT_FRAMES) {
+			rem = 1.0f;
+			*step = 1.0f;
 		}
-
-		if(rem==1.0) (*macht)++;	// prevents printing 1.0 2.0 3.0 etc
+		
+		/* prevents printing 1.0 2.0 3.0 etc */
+		if (rem == 1.0f) (*power)++;	
 	}
 	else {
-		if(rem < 2.0) rem= 2.0;
-		else if(rem < 5.0) rem= 5.0;
-		else rem= 10.0;
+		if (rem < 2.0f) rem= 2.0f;
+		else if(rem < 5.0f) rem= 5.0f;
+		else rem= 10.0f;
 		
-		*step= rem*pow(10.0, (float)*macht);
+		*step= rem * pow(10.0, (double)(*power));
 		
-		(*macht)++;
-		if(rem==10.0) (*macht)++;	// prevents printing 1.0 2.0 3.0 etc
+		(*power)++;
+		/* prevents printing 1.0, 2.0, 3.0, etc. */
+		if (rem == 10.0f) (*power)++;	
 	}
 }
 
-View2DGrid *UI_view2d_calc_grid(const bContext *C, View2D *v2d, int unit, int clamp, int winx, int winy)
+/* Intialise settings necessary for drawing gridlines in a 2d-view 
+ *	- Currently, will return pointer to View2DGrid struct that needs to 
+ *	  be freed with UI_view2d_free_grid()
+ *	- Is used for scrollbar drawing too (for units drawing)  --> (XXX needs review)
+ *	
+ *	- unit	= V2D_UNIT_*  grid steps in seconds or frames 
+ *	- clamp	= V2D_CLAMP_* only show whole-number intervals
+ *	- winx	= width of region we're drawing to
+ *	- winy	= height of region we're drawing into
+ */
+View2DGrid *UI_view2d_calc_grid(const bContext *C, View2D *v2d, short unit, short clamp, int winx, int winy)
 {
 	View2DGrid *grid;
 	float space, pixels, seconddiv;
 	int secondgrid;
-
+	
+	/* grid here is allocated... */
 	grid= MEM_callocN(sizeof(View2DGrid), "View2DGrid");
-
-	/* rule: gridstep is minimal IPOSTEP pixels */
-	/* how large is IPOSTEP pixels? */
 	
-	if(unit == V2D_UNIT_FRAMES) {
+	/* rule: gridstep is minimal GRIDSTEP pixels */
+	if (unit == V2D_UNIT_FRAMES) {
 		secondgrid= 0;
 		seconddiv= 0.01f * FPS;
 	}
@@ -145,187 +177,233 @@ View2DGrid *UI_view2d_calc_grid(const bContext *C, View2D *v2d, int unit, int cl
 		secondgrid= 1;
 		seconddiv= 1.0f;
 	}
-
+	
 	space= v2d->cur.xmax - v2d->cur.xmin;
 	pixels= v2d->mask.xmax - v2d->mask.xmin;
 	
-	grid->dx= IPOSTEP*space/(seconddiv*pixels);
-	step_to_grid(&grid->dx, &grid->machtx, unit);
-	grid->dx*= seconddiv;
+	grid->dx= (MINGRIDSTEP * space) / (seconddiv * pixels);
+	step_to_grid(&grid->dx, &grid->powerx, unit);
+	grid->dx *= seconddiv;
 	
-	if(clamp == V2D_GRID_CLAMP) {
-		if(grid->dx < 0.1) grid->dx= 0.1;
-		grid->machtx-= 2;
-		if(grid->machtx<-2) grid->machtx= -2;
+	if (clamp == V2D_GRID_CLAMP) {
+		if (grid->dx < 0.1f) grid->dx= 0.1f;
+		grid->powerx-= 2;
+		if (grid->powerx < -2) grid->powerx= -2;
 	}
 	
 	space= (v2d->cur.ymax - v2d->cur.ymin);
 	pixels= winy;
-	grid->dy= IPOSTEP*space/pixels;
-	step_to_grid(&grid->dy, &grid->machty, unit);
+	grid->dy= MINGRIDSTEP*space/pixels;
+	step_to_grid(&grid->dy, &grid->powery, unit);
 	
-	if(clamp == V2D_GRID_CLAMP) {
-		if(grid->dy < 1.0) grid->dy= 1.0;
-		if(grid->machty<1) grid->machty= 1;
+	if (clamp == V2D_GRID_CLAMP) {
+		if (grid->dy < 1.0f) grid->dy= 1.0f;
+		if (grid->powery < 1) grid->powery= 1;
 	}
 	
 	grid->startx= seconddiv*(v2d->cur.xmin/seconddiv - fmod(v2d->cur.xmin/seconddiv, grid->dx/seconddiv));
-	if(v2d->cur.xmin<0.0) grid->startx-= grid->dx;
+	if (v2d->cur.xmin < 0.0f) grid->startx-= grid->dx;
 	
 	grid->starty= (v2d->cur.ymin-fmod(v2d->cur.ymin, grid->dy));
-	if(v2d->cur.ymin<0.0) grid->starty-= grid->dy;
+	if (v2d->cur.ymin < 0.0f) grid->starty-= grid->dy;
 
 	return grid;
 }
 
+/* Draw gridlines in the given 2d-region */
 void UI_view2d_draw_grid(const bContext *C, View2D *v2d, View2DGrid *grid, int flag)
 {
 	float vec1[2], vec2[2];
 	int a, step;
 	
-	if(flag & V2D_VERTICAL_LINES) {
-		/* vertical lines */
+	/* vertical lines */
+	if (flag & V2D_VERTICAL_LINES) {
+		/* initialise initial settings */
 		vec1[0]= vec2[0]= grid->startx;
 		vec1[1]= grid->starty;
 		vec2[1]= v2d->cur.ymax;
 		
-		step= (v2d->mask.xmax - v2d->mask.xmin+1)/IPOSTEP;
+		/* minor gridlines */
+		step= (v2d->mask.xmax - v2d->mask.xmin + 1) / MINGRIDSTEP;
 		
 		UI_ThemeColor(TH_GRID);
 		
-		for(a=0; a<step; a++) {
+		for (a=0; a<step; a++) {
 			glBegin(GL_LINE_STRIP);
-			glVertex2fv(vec1); glVertex2fv(vec2);
+				glVertex2fv(vec1); 
+				glVertex2fv(vec2);
 			glEnd();
+			
 			vec2[0]= vec1[0]+= grid->dx;
 		}
 		
-		vec2[0]= vec1[0]-= 0.5*grid->dx;
+		/* major gridlines */
+		vec2[0]= vec1[0]-= 0.5f*grid->dx;
 		
 		UI_ThemeColorShade(TH_GRID, 16);
 		
 		step++;
-		for(a=0; a<=step; a++) {
+		for (a=0; a<=step; a++) {
 			glBegin(GL_LINE_STRIP);
-			glVertex2fv(vec1); glVertex2fv(vec2);
+				glVertex2fv(vec1); 
+				glVertex2fv(vec2);
 			glEnd();
+			
 			vec2[0]= vec1[0]-= grid->dx;
 		}
 	}
 	
-	if(flag & V2D_HORIZONTAL_LINES) {
-		/* horizontal lines */
+	/* horizontal lines */
+	if (flag & V2D_HORIZONTAL_LINES) {
+		/* only major gridlines */
 		vec1[0]= grid->startx;
 		vec1[1]= vec2[1]= grid->starty;
 		vec2[0]= v2d->cur.xmax;
 		
-		step= (C->area->winy+1)/IPOSTEP;
+		step= (v2d->mask.ymax - v2d->mask.ymax + 1) / MINGRIDSTEP;
 		
 		UI_ThemeColor(TH_GRID);
-		for(a=0; a<=step; a++) {
+		for (a=0; a<=step; a++) {
 			glBegin(GL_LINE_STRIP);
-			glVertex2fv(vec1); glVertex2fv(vec2);
+				glVertex2fv(vec1); 
+				glVertex2fv(vec2);
 			glEnd();
+			
 			vec2[1]= vec1[1]+= grid->dy;
 		}
-		vec2[1]= vec1[1]-= 0.5*grid->dy;
+		
+		vec2[1]= vec1[1]-= 0.5f*grid->dy;
 		step++;
 	}
 	
+	/* Axes are drawn as darker lines */
 	UI_ThemeColorShade(TH_GRID, -50);
 	
-	if(flag & V2D_HORIZONTAL_AXIS) {
-		/* horizontal axis */
+	/* horizontal axis */
+	if (flag & V2D_HORIZONTAL_AXIS) {
 		vec1[0]= v2d->cur.xmin;
 		vec2[0]= v2d->cur.xmax;
-		vec1[1]= vec2[1]= 0.0;
-		glBegin(GL_LINE_STRIP);
-		
-		glVertex2fv(vec1);
-		glVertex2fv(vec2);
+		vec1[1]= vec2[1]= 0.0f;
 		
+		glBegin(GL_LINE_STRIP);
+			glVertex2fv(vec1);
+			glVertex2fv(vec2);
 		glEnd();
 	}
 	
-	if(flag & V2D_VERTICAL_AXIS) {
-		/* vertical axis */
+	/* vertical axis */
+	if (flag & V2D_VERTICAL_AXIS) {
 		vec1[1]= v2d->cur.ymin;
 		vec2[1]= v2d->cur.ymax;
-		vec1[0]= vec2[0]= 0.0;
+		vec1[0]= vec2[0]= 0.0f;
+		
 		glBegin(GL_LINE_STRIP);
-		glVertex2fv(vec1); glVertex2fv(vec2);
+			glVertex2fv(vec1); 
+			glVertex2fv(vec2);
 		glEnd();
 	}
 }
 
+/* free temporary memory used for drawing grid */
 void UI_view2d_free_grid(View2DGrid *grid)
 {
 	MEM_freeN(grid);
 }
 
-/* Coordinate conversion */
+/* *********************************************************************** */
+/* Coordinate Conversions */
 
+/* Convert from screen/region space to 2d-View space 
+ *	
+ *	- x,y 			= coordinates to convert
+ *	- viewx,viewy		= resultant coordinates
+ */
 void UI_view2d_region_to_view(View2D *v2d, short x, short y, float *viewx, float *viewy)
 {
 	float div, ofs;
 
-	if(viewx) {
-		div= v2d->mask.xmax-v2d->mask.xmin;
+	if (viewx) {
+		div= v2d->mask.xmax - v2d->mask.xmin;
 		ofs= v2d->mask.xmin;
-
-		*viewx= v2d->cur.xmin+ (v2d->cur.xmax-v2d->cur.xmin)*(x-ofs)/div;
+		
+		*viewx= v2d->cur.xmin + (v2d->cur.xmax-v2d->cur.xmin) * (x - ofs) / div;
 	}
 
-	if(viewy) {
-		div= v2d->mask.ymax-v2d->mask.ymin;
+	if (viewy) {
+		div= v2d->mask.ymax - v2d->mask.ymin;
 		ofs= v2d->mask.ymin;
-
-		*viewy= v2d->cur.ymin+ (v2d->cur.ymax-v2d->cur.ymin)*(y-ofs)/div;
+		
+		*viewy= v2d->cur.ymin + (v2d->cur.ymax - v2d->cur.ymin) * (y - ofs) / div;
 	}
 }
 
+/* Convert from 2d-View space to screen/region space
+ *	- Coordinates are clamped to lie within bounds of region
+ *
+ *	- x,y 				= coordinates to convert
+ *	- regionx,regiony 	= resultant coordinates 
+ */
 void UI_view2d_view_to_region(View2D *v2d, float x, float y, short *regionx, short *regiony)
 {
-	*regionx= V2D_IS_CLIPPED;
-	*regiony= V2D_IS_CLIPPED;
-
-	x= (x - v2d->cur.xmin)/(v2d->cur.xmax-v2d->cur.xmin);
-	y= (x - v2d->cur.ymin)/(v2d->cur.ymax-v2d->cur.ymin);
-
-	if(x>=0.0 && x<=1.0) {
-		if(y>=0.0 && y<=1.0) {
-			if(regionx)
-				*regionx= v2d->mask.xmin + x*(v2d->mask.xmax-v2d->mask.xmin);
-			if(regiony)
-				*regiony= v2d->mask.ymin + y*(v2d->mask.ymax-v2d->mask.ymin);
-		}
+	/* set initial value in case coordinate lies outside of bounds */
+	if (regionx)
+		*regionx= V2D_IS_CLIPPED;
+	if (regiony)
+		*regiony= V2D_IS_CLIPPED;
+	
+	/* express given coordinates as proportional values */
+	x= (x - v2d->cur.xmin) / (v2d->cur.xmax - v2d->cur.xmin);
+	y= (x - v2d->cur.ymin) / (v2d->cur.ymax - v2d->cur.ymin);
+	
+	/* check if values are within bounds */
+	if ((x>=0.0f) && (x<=1.0f) && (y>=0.0f) && (y<=1.0f)) {
+		if (regionx)
+			*regionx= v2d->mask.xmin + x*(v2d->mask.xmax-v2d->mask.xmin);
+		if (regiony)
+			*regiony= v2d->mask.ymin + y*(v2d->mask.ymax-v2d->mask.ymin);
 	}
 }
 
+/* Convert from 2d-view space to screen/region space
+ *	- Coordinates are NOT clamped to lie within bounds of region
+ *
+ *	- x,y 				= coordinates to convert
+ *	- regionx,regiony 	= resultant coordinates 
+ */
 void UI_view2d_to_region_no_clip(View2D *v2d, float x, float y, short *regionx, short *regiony)
 {
-	x= (x - v2d->cur.xmin)/(v2d->cur.xmax-v2d->cur.xmin);
-	y= (x - v2d->cur.ymin)/(v2d->cur.ymax-v2d->cur.ymin);
-
-	x= v2d->mask.xmin + x*(v2d->mask.xmax-v2d->mask.xmin);
-	y= v2d->mask.ymin + y*(v2d->mask.ymax-v2d->mask.ymin);
-
-	if(regionx) {
-		if(x<-32760) *regionx= -32760;
-		else if(x>32760) *regionx= 32760;
+	/* step 1: express given coordinates as proportional values */
+	x= (x - v2d->cur.xmin) / (v2d->cur.xmax - v2d->cur.xmin);
+	y= (x - v2d->cur.ymin) / (v2d->cur.ymax - v2d->cur.ymin);
+	
+	/* step 2: convert proportional distances to screen coordinates  */
+	x= v2d->mask.xmin + x*(v2d->mask.xmax - v2d->mask.xmin);
+	y= v2d->mask.ymin + y*(v2d->mask.ymax - v2d->mask.ymin);
+	
+	/* although we don't clamp to lie within region bounds, we must avoid exceeding size of shorts */
+	if (regionx) {
+		if (x < -32760) *regionx= -32760;
+		else if(x > 32760) *regionx= 32760;
 		else *regionx= x;
 	}
-
-	if(regiony) {
-		if(y<-32760) *regiony= -32760;
-		else if(y>32760) *regiony= 32760;
+	if (regiony) {
+		if (y < -32760) *regiony= -32760;
+		else if(y > 32760) *regiony= 32760;
 		else *regiony= y;
 	}
 }
 
+/* *********************************************************************** */
+/* Utilities */
+
+/* Calculate the scale per-axis of the drawing-area
+ *	- Is used to inverse correct drawing of icons, etc. that need to follow view 
+ *	  but not be affected by scale
+ *
+ *	- x,y	= scale on each axis
+ */
 void UI_view2d_getscale(View2D *v2d, float *x, float *y) 
 {
-	if (x) *x = (v2d->mask.xmax-v2d->mask.xmin)/(v2d->cur.xmax-v2d->cur.xmin);
-	if (y) *y = (v2d->mask.ymax-v2d->mask.ymin)/(v2d->cur.ymax-v2d->cur.ymin);
+	if (x) *x = (v2d->mask.xmax - v2d->mask.xmin) / (v2d->cur.xmax - v2d->cur.xmin);
+	if (y) *y = (v2d->mask.ymax - v2d->mask.ymin) / (v2d->cur.ymax - v2d->cur.ymin);
 }
-
diff --git a/source/blender/makesdna/DNA_screen_types.h b/source/blender/makesdna/DNA_screen_types.h
index c03a60ff65f..39cf6454c2c 100644
--- a/source/blender/makesdna/DNA_screen_types.h
+++ b/source/blender/makesdna/DNA_screen_types.h
@@ -178,14 +178,17 @@ typedef struct ARegion {
 #define WIN_BACK_OK		2
 #define WIN_EQUAL		3
 
-#define L_SCROLL 1			/* left scrollbar */
+/* scrollbar flags for View2D */
+	/* left scrollbar */
+#define L_SCROLL 1			
 #define R_SCROLL 2
 #define VERT_SCROLL 3
 #define T_SCROLL 4
 #define B_SCROLL 8
 #define HOR_SCROLL  12
-#define B_SCROLLO   16		/* special hack for outliner hscroll - prevent hanging */
-#define HOR_SCROLLO 20		/*        in older versions of blender 			     */
+	/* special hack for outliner hscroll - prevent hanging older versions of Blender */
+#define B_SCROLLO   16
+#define HOR_SCROLLO 20
 
 /* Panel->snap - for snapping to screen edges */
 #define PNL_SNAP_NONE		0
diff --git a/source/blender/makesdna/DNA_space_types.h b/source/blender/makesdna/DNA_space_types.h
index d1eff908c86..9fd4770c977 100644
--- a/source/blender/makesdna/DNA_space_types.h
+++ b/source/blender/makesdna/DNA_space_types.h
@@ -471,9 +471,6 @@ typedef struct SpaceImaSel {
 #define MOVIEFILE_ICON		1024 /* movie file that preview can't load */
 #define FOLDERFILE			2048 /* represents folders for filtering */
 
-#define SCROLLH	16			/* height scrollbar */
-#define SCROLLB	16			/* width scrollbar */
-
 /* SpaceImage->mode */
 #define SI_TEXTURE		0
 #define SI_SHOW			1
diff --git a/source/blender/makesdna/DNA_view2d_types.h b/source/blender/makesdna/DNA_view2d_types.h
index d7c422407ca..d4425b43f76 100644
--- a/source/blender/makesdna/DNA_view2d_types.h
+++ b/source/blender/makesdna/DNA_view2d_types.h
@@ -24,7 +24,7 @@
  *
  * The Original Code is: all of this file.
  *
- * Contributor(s): none yet.
+ * Contributor(s): Joshua Leung
  *
  * ***** END GPL LICENSE BLOCK *****
  */
@@ -33,32 +33,46 @@
 
 #include "DNA_vec_types.h"
 
+/* ---------------------------------- */
+
+/* View 2D data - stored per region */
 typedef struct View2D {
 	rctf tot, cur;
 	rcti vert, hor, mask;
+	
 	float min[2], max[2];
 	float minzoom, maxzoom;
-	short scroll, keeptot;
+	
+	short scroll, keeptot;			/* scroll - scrollbars to display (bitflag); keeptot - 'tot' rect  */
 	short keepaspect, keepzoom;
 	short oldwinx, oldwiny;
-	int flag;
 	
-	float cursor[2]; /* only used in the UV view for now*/
-	short around;
+	int flag;						/* settings */
+	
+	float cursor[2]; 				/* only used in the UV view for now (for 2D-cursor) */
+	short around;					/* pivot point for transforms (rotate and scale) */
 	char pad[6];
 } View2D;
 
+/* ---------------------------------- */
+
 /* v2d->keepzoom */
 #define V2D_KEEPZOOM	0x0001	
 #define V2D_LOCKZOOM_X	0x0100
 #define V2D_LOCKZOOM_Y	0x0200
 
 /* event codes for locking function */
-#define V2D_LOCK_COPY	1
-#define V2D_LOCK_REDRAW	2
+#define V2D_LOCK_COPY		1
+#define V2D_LOCK_REDRAW		2
 
 /* v2d->flag */
-#define V2D_VIEWLOCK	1
+#define V2D_VIEWLOCK	(1<<0)
+
+/* scrollbar thickness */
+	/* height */
+#define SCROLLH	16
+	/* width */
+#define SCROLLB	16
 
 #endif