archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity

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

Browse Source
This commit is contained in:
Joshua Leung
2008-11-28 04:01:35 +00:00
parent d6769d513e
commit c8098f953d
5 changed files with 283 additions and 167 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
source/blender/editors/include/UI_view2d.h
View File

@@ -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);

368
source/blender/editors/interface/view2d.c
View File

@@ -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= MEM_callocN(sizeof(View2DGrid), "View2DGrid");
/* rule: gridstep is minimal IPOSTEP pixels */
/* how large is IPOSTEP pixels? */
if(unit == V2D_UNIT_FRAMES) {
/* grid here is allocated... */
grid= MEM_callocN(sizeof(View2DGrid), "View2DGrid");
/* 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;
vec1[1]= vec2[1]= 0.0f;
glBegin(GL_LINE_STRIP);
glVertex2fv(vec1);
glVertex2fv(vec2);
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);
}

9
source/blender/makesdna/DNA_screen_types.h
View File

@@ -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

3
source/blender/makesdna/DNA_space_types.h
View File

@@ -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

30
source/blender/makesdna/DNA_view2d_types.h
View File

@@ -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